I want to make a Singleton class that has the singleton pattern enforced. I want to make it so that it is not possible to create multiple instances of the singleton. I''m using C++. The following code behaves strangely, and I would appreciate it if someone could explain why:

#include <iostream>
using namespace std;

class singleton
{
	protected:
		singleton() { };
		singleton(const singleton &) { };
		singleton & operator= (const singleton &) { return *this; };
};

class foo
{
	public:
		//foo() { }; 	// The program runs if this line is not commented out.

		singleton a, b, c;
};

int main(void)
{
	foo bar;
	cout << "Foobar!" << endl;
	return 0;
}

For brevity''s sake, the "singleton" here has no ability to maintain the single instance. But that''s not relevant, the weird thing here is that, if the foo class is declared with a constructor, the program will compile without error (under MetroWerks Codewarrior) despite the fact that it should not be possible to instantiate a class that contains singleton members. If the constructor in foo is commented out, the program does not compile, and generates an error for invalid use of a protected/private member. I''m hoping that someone more familiar with this sort of thing can explain what''s wrong here, and how to implement a proper singleton.

quote:If the constructor in foo is commented out, the program does not compile, and generates an error for invalid use of a protected/private member.

That is standard behavior. I do not understand why the foo constructor would make it compile, though. foo::foo () should be invoking singleton::singleton () implicitly for foo::a, foo::b, and foo::c. Sounds like a compiler bug to me.

quote:I''m hoping that someone more familiar with this sort of thing can explain what''s wrong here, and how to implement a proper singleton.

That depends on what kind of singleton you need.

The problem is that the class singleton has no relationship whatsoever to class foo. That means, from class foo''s viewpoint, singleton cannot created, because the default ctor, copy ctor, and assignment operator are all protected, and not public.

It''s no compiler bug, just the semantics of the C++ language at work.

This is how I implement 90% of my singletons:

#include <cassert>template<typename TypeT>class Singleton{public:  Singleton()  {    assert(sInstance == 0);    sInstance = static_cast<TypeT*>(this);  }  ~Singleton()  {    assert(sInstance != 0);    sInstance = 0;  }  static TypeT& GetInstance()  {    assert(sInstance != 0);    return *sInstance;  }protected:  static TypeT* sInstance;};template<typename TypeT>TypeT* Singleton<TypeT>::sInstance = 0;