C++ singleton using templates

Question

Is this a good Singleton implementation? Is there anything I should be aware of? If so, how can it be improved?

template <class T>
class Singleton
{
public:
    static T& getInstance()
    {
        static T instance;
        return instance;
    }

protected:
    Singleton() {}
    ~Singleton() {}

private:
    Singleton(Singleton const&);
    void operator=(Singleton const&);
};

Usage example:

#include <stdio.h>

class A : public Singleton<A> {
public:
    A() {
        a = 100;
    }

    int get_a() { return a; }
    void set_a(int v) { a = v;  }
private:
    int a;
};

A& s = A::getInstance();

void free1() {
    printf("%d\n", s.get_a());
}

void free2() {
    s.set_a(200);
}

void free3() {
    printf("--> %d", s.get_a());
}

void main() {
    free1();
    free2();
    free3();
}

Let's consider an alternative to avoid the usage of Singletons, instead having:

class A : public Singleton<A>

let's say it becomes:

class A

and let's say we define a global variable:

A g_s = A();

and then this global variable will be accessed by other files using external, would that bring some sort of benefit?

external A g_s;

Answer 1

You cannot really say that it's a good or bad implementation. It depends, but this doesn't look ok to me: class A : public Singleton<A>. You don't need to inherit from it to use it: Singleton<A>::instance()

If you want to to use it as you wrote: A& s = A::getInstance(); then probably A's ctor/dtor shouldn't be public.

Answer 2

Assigning the singleton instance's reference to a file-scope static variable is un-necessary.

As is deriving from a singleton, which un-necessarily couples the design of A to the concept of a singleton.

I might be inclined to do it this way:

#include <cstdio>

// the concept of using a singleton.
template<class T>
T& use()
{
    static T t_;
    return t_;
}

// implementation not coupled to the singleton concept.    
class A
{
public:
    A()
    {
        a = 100;
    }

    int get_a() { return a; }

    void set_a(int v) { a = v; }

private:
    int a;
};

void free1()
{
    // use<> an A whenever required.
    printf("%d\n", use<A>().get_a());
}

void free2()
{
    use<A>().set_a(200);
}

void free3()
{
    printf("--> %d", use<A>().get_a());
}

int main()
{
    free1();
    free2();
    free3();
}

Answer 3

The trouble with templates is that they can potentially be instantiated in multiple compilation units. It is the job of the linker to remove reduce this number not the compiler. So not all linkers are that nice or compliant so you could still end up with multiple instantiations (thus giving you multiple instances not one).

OK. Lets assume your compiler/linker are good and obey the standard.

Shared libraries are beyond the scope of the C++ standard. So if you link together multiple shared libraries where all these references have been resolved your linker may not even notice that it is inheriting multiple instances from different libraries.