Static Members - Easier Way?

[LB]

I was wondering if there was a better way for a static member function to access each an every class than this:

struct Staticlass
{
	int Int;

private:
	static vector<Staticlass*> List;

public:
	Staticlass()
	{
		Int = 0;
		List.push_back(this);
	}
	~Staticlass()
	{
		for(unsigned long i = 0; i < List.size(); ++i)
		{
			if(List[i] == this)
			{
				List.erase(List.begin() + i);
				return;
			}
		}
	}

	static void AddAll()
	{
		for(unsigned long i = 0; i < List.size(); ++i)
		{
			++(List[i]->Int);
		}
	}
	static void PrintAll()
	{
		for(unsigned long i = 0; i < List.size(); ++i)
		{
			cout << (List[i]->Int) << endl;
		}
	}
};
vector<Staticlass*> Staticlass::List;

Note this is just a test, and it seems to work well. But as I said above, I wonder if I am overcomplicating the process?

[jsmith]

Well, what are you trying to do?

This works, though you have not accounted for copy construction.

There are shorter ways to write each of those functions, but they involve using boost::lambda.

Though your destructor could be written using just algorithms:

#include <algorithm>
#include <boost/lambda/lambda.hpp>

~Staticlass() {
    List.erase( std::find( List.begin(), List.end(), this ) );
}

static void AddAll() {
    std::for_each( List.begin(), List.end(),
        &boost::lambda::_1->*&Staticlass::Int += 1 );
}

static void PrintAll() {
    std::for_each( List.begin(), List.end(),
        std::cout << &boost::lambda::_1->*&Staticlass::Int << '\n' );
}

[ne555]

Why you need to handle the collection in the same class?

class A{
  ContA *where_I_belong; //Cont & if is you can't change ownership
//...
};
class ContA{
   std::vector<A*> List;
  //all the algorithms of a collection (add, erase, update, print ...)
}

[moorecm]

Does a set help?

struct Staticlass
{
	int Int;

private:
	static set<Staticlass*> List;

public:
	Staticlass()
	{
		Int = 0;
		List.insert(this);
	}
	~Staticlass()
	{
		List.erase(this);
	}

	//...
};
//...
vector<Staticlass*> Staticlass::List;
//...