Singleton base template class? How do you do that?!

So, I'm trying to create a singleton base template class so I can simulate XNA game services by allowing a class to be initialized only once, and by allowing that class to be added to a linked list of similar base objects.

The only solution I found to this problem was to create a singleton base template class, and create a static linked list of the base class to keep track of the services.



...This is proving to be more of a problem than anything, and here is why:


Singleton.h

Code:

template <class T>
class Singleton 
{
public: 
	~Singleton(void) {};
	static T& GetService(void) {return *Instance;}
protected:
	Singleton<T>(void) {};
	static T* Instance;
};

ApplicationManager.h

Code:

#include "application.h"
#include "singleton.h"
class ApplicationManager : public Singleton<ApplicationManager>
{
public:
	Application* ActiveApplication(void) {return _ActiveApplication;}
	~ApplicationManager(void);
private:
	ApplicationManager(void);
	ApplicationManager(Application* app);
	Application* _ActiveApplication;
};

The line in my main method:

Code:

ApplicationManager Prog = ApplicationManager::GetService();

The above line gives me the following external error:

LNK2001: unresolved external symbol "protected: static class ApplicationManager *Singleton<class ApplicationManager>::Instance"



What I was trying to do here, was to simply pass a single copy of the class into ApplicationManager prog.


Does anyone see the problem? Or does anyone know of a better/more elegant solution to this?

You need to initialize the static member, eg:

Code:

template <class T>
class Singleton 
{
public: 
	~Singleton(void) {};
	static T& GetService(void) {return *Instance;}
protected:
	Singleton<T>(void) {};
	static T* Instance;
};

template <class T>
T* Singleton<T>::Instance = 0;

And just a little food for thought:

Code:

template < typename Class >
struct Singleton
{
    Singleton( void )
    {    
        if( instance_ )
            throw; // or what have you...
        instance_ = ( Class* )this;    
    }

    static inline Class& instance( void )
    {
        return *instance_;
    }
    
    static inline bool exists( void )
    {
        return instance_ != 0;
    }
    
    virtual ~Singleton( void )
    {
        instance_ = 0;    
    }
    
    protected:
        
    static Class* 
        instance_;
};

template < typename Class >
Class* 
    Singleton< Class >::instance_ = 0;

And then:

Code:

/*
    What the client code sees
*/    
class ApplicationManager : public Singleton<ApplicationManager>
{
public:
    ~ApplicationManager(void)
    {    }
    
    virtual void foo( void ) = 0;
    
protected:
    
    ApplicationManager(void)
    {    }
};


/*
    The *real* implementation
*/
class MyApplicationManager : public ApplicationManager
{
public:    

    MyApplicationManager(void)
    {    }
    
    virtual void foo( void )
    {
        cout << "MyApplicationManager" << endl;
    }
};

MyApplicationManager
    mgr_;

And from the client code:

Code:

int main( void )
{
    ApplicationManager::instance( ).foo( );
}

The point is, you don't have to fool with wierd allocation schemes if you don't want to, and you can reassign the singleton by allowing the current one to go out of scope, or if it was dynamically allocated, deleted first. But at any rate the client code doesn't have to worry about how the singleton is managed internally - the code stays the same for them.

Wow...thank you guys for the feedback! I just realized I did some funky things haha

Good call on the struct, and virtual functions btw! I like that a lot!

class and struct are mostly the same.
Sebastiani simply uses structs due to personal preference.
You can use classes if you want. Classes have private visibility by default and struct have public by default. That's all there is to it.