Quelle est bonne façon d'initialiser un membre statique dans une classe de type basé sur un modèle T & '?

Question

Je suis jouer avec une classe singleton générique désireux réinitialisant. L'idée est que vous héritez publiquement de la classe comme ceci:

class foo : public singleton<foo> { };

J'ai appris beaucoup dans le processus, mais je suis bloqué en ce moment parce qu'il est briser mon éditeur de liens Visual Studio 2008. Le problème est lié à l'élément d'instance statique et / ou de son initialisation.

template<class T>
class singleton {
    singleton();
    singleton(singleton const &);
    singleton & operator = (singleton const &);
public:
    static T & instance;
};
template<class T> T & T::instance;

Toute idée serait grandement appréciée!

EDIT:

Avec cette déclaration de classe ...

template<class T>
class singleton {
    singleton();
    singleton(singleton const &);
    singleton & operator = (singleton const &);
public:
    static T instance;
};
template <class T> T singleton<T>::instance;

Lorsque je tente de le faire ...

class foo : public singleton<foo> { };

Je reçois cette erreur ...

  

error C2248: ':: singleton singleton'   : Ne peut pas accéder à un membre privé   a déclaré dans la classe 'singleton'

     

...

     

Ce diagnostic a eu lieu dans le compilateur fonction générée 'foo :: foo (void)'

Mon interprétation est que singleton veut construire un objet foo qui, par héritage, dépend de la construction d'un singleton dont le constructeur est privé. Je me suis dit singleton aurait accès à son propre constructeur, mais je suppose que non. Toutes les idées?

EDIT 2:

Je me suis rendu compte que l'approche de héritant de singleton<T> a le problème d'exiger le changement de la classe à utiliser comme un singleton. J'ai fini avec le code suivant pour mon modèle de classe singleton désireux réinitialisant.

template<typename T>
class singleton_wrapper {
    singleton_wrapper();
    singleton_wrapper(singleton_wrapper const &);
    singleton_wrapper & operator = (singleton_wrapper const &);
    static T instance;
    template<typename T> friend T & singleton();
};
template<typename T> T singleton_wrapper<T>::instance;

template<typename T>
T & singleton() {
    return singleton_wrapper<T>::instance;
}

Pour la classe ...

class foo {
public:
    void bar() { }
};

... On pourrait accéder à une instance unique de celui-ci (avant initialisés main ()) en utilisant les éléments suivants:

singleton<foo>().bar();

Merci encore pour l'aide, en particulier GMan. Je suis très satisfait de ma première expérience sur la pile débordement .

Answer 1

Vous ne pouvez pas, puisque vous ne disposez pas d'un exemple concret. Vous pouvez avoir besoin de créer une instance réelle que vous pouvez vous référer à:

template <class T>
class singleton {
    ...
private:
    static T instance_;
public:
    static T& instance;
};
template <class T> T singleton<T>::instance_;
template <class T> T& singleton<T>::instance = singleton<T>::instance;

Ou, plus simplement, fossé la référence tout à fait:

template <class T>
class singleton {
    ...
public:
    static T instance;
};
template <class T> T singleton<T>::instance;

Answer 2

Off-the-manche:. Changer par exemple être de type 'T' au lieu de 'T &'