Question

I’m experiencing a weird issue in which I need to have a default constructor for my template class to work, but some of the classes I’d like to use with the template cannot have default constructors.

What I mean by some classes cannot have default constructors is they have a const reference field, hence, they must be set in the constructor/initialization list. If I have a default constructor, there is nothing to set these references to.

So, I guess there are two possible solutions to this: Find a way to allow for non-default constructors in the template class sometimes or find a way to set the const reference fields in a default constructor.

How do I resolve this?

Here’s my template code:

#pragma once

template<class T>
class Singleton
{
public:
    static T* getInstance()
    {
        if(!instance) instance = new T;
        return instance;
    }
static void setInstance(T* inst)
{
    instance = inst;
}
protected:
    Singleton();
    ~Singleton();
private:
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    static T* instance;
};

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

Here’s where I set the const reference (in a .cpp):

InputHandler::InputHandler(const sf::Input& inputObject)
    : input(inputObject)
{

And input is defined in the header:

const sf::Input& input;

I have to use a constant reference because of this area of code (in a different file):

const sf::Input& input = window.GetInput();
InputHandler* inputHandler = new InputHandler(input);
Singleton<InputHandler>::setInstance(inputHandler);

GetInput() is not one of my methods, and it must return a const sf::Input&

Answer 1

You’re invoking the default constructor in getInstance with:

instance = new T;

What do you expect to happen if someone calls getInstance before setInstance?

If it’s an error to call getInstance before setInstance, then getInstance should assert or throw or return NULL if called before instance is set. Just get rid of the new T, and your code will compile.

If it’s not an error to call getInstance before setInstance, then you don’t really have a singleton. Early callers would receive a default constructed object and later callers would get the one set later. That’s two instances and therefore not a singleton.