Problème de link dans un singleton

Version imprimable

Bonjour,

voici une implémentation du singleton :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
template<typename T>
class Singleton
{
        private: static T instance;
        private: Singleton()
        {
        };
        private: Singleton(const T&);
        private: T& operator=(const T&);
        public: static T& getInstance()
        {
                return instance;
        }
};
int main(void)
{
        int& n1 = Singleton<int>::getInstance();
        return 0;
}

Mais le link génère l'erreur :

Code:

1
2
/tmp/ccWMzoqa.o: In function `Singleton<int>::getInstance()':
test.cpp:(.text._ZN9SingletonIiE11getInstanceEv[Singleton<int>::getInstance()]+0x4): undefined reference to `Singleton<int>::instance'

Où est l'erreur ?

Merci .

Bon alors il y a quand même certaines choses choquante dans ton code, premièrement pourquoi définir private et public devant toutes tes fonctions? Par défaut une classe est en private donc change seulement pour public quand tu en as besoin.

Ensuite toute données statiques doivent être initialisées!

Aussi, tu définis

Code:

static T instance

comme donnée ce qui signifie que instance ne sera pas une instance mais dans ton exemple un int

Maintenant voila un code qui compile :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 template<typename T> class Singleton { static T *instance; Singleton() { }; Singleton(const T&); T& operator=(const T&); public: static T& getInstance() { return *instance; } }; template<typename T> T*Singleton<T>::instance = 0; int main(void) { int& n1 = Singleton<int>::getInstance(); return 0; }
Quand bien même ce code compile il ne s'exécutera pas correctement puisque la valeur pointée par instance n'est pas définis... Mais je suppose que tu n'as pas finis la classe singleton...

28/02/2008, 07h53
screetch

il est possible de stocker un T dans la classe singleton.

ce qui manque c'est juste

Code:

template<typename T> T Singleton<T>::instance;

Si tu veux faire un singleton automatique, tu utilise un constructeur public :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
template<typename T>
class singleton
{
    static T* instance;
 
public:
    singleton() // avec une classe T qui dérive de singleton<T>
    {
        if(instance != 0) throw "le singleton existe déjà";
        else instance = dynamic_cast<T>(this);
    }
 
    singleton(T &val) // avec des objets T qui ne dérivent pas de singleton T (comme les types de base)
    {
        if(instance != 0) throw "le singleton existe déjà";
        else instance = &val;
    }
 
private:
    singleton(const singleton &) {}
    singleton &operator=(const singleton &) {}
 
public:
    ~singleton()
    {
        instance = 0;
    }
 
    static T* get() { return instance; }
    static void set(T &val) { instance = &val };
};

Je préfère cette solution là (plus automatisée).

J'ai eu un problème avec 'static T* instance" (le compilateur n'en voulait pas) donc j'ai fabriqué une petite classe qui s'occupe du stockage :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template<typename T>
class locker
{
    T* _val;
    bool _full;
 
public:
    locker(): _val(0), _full(false) {}
    locker(const T &val): _val(val), _full(true) {}
    ~locker() {}
 
    inline locker &operator=(T* val) { _val = val; _full = (val != 0); }
    inline T* operator T*() { return _val; }
    inline T* const get() { return _val; }
    inline bool full() const { return _full; }
};

et je remplace 'static T* instance;' par 'static locker<T> instance;' et le compilateur est content.

En effet il y a des erreurs de conception : un singleton embarque une instance de lui-même et pas le type "T".

Voici une version sans cette erreur, avec l'instance unique dans la méthode"getInstance", qui compile :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<typename T>
class Singleton
{
        private: Singleton<T>()
        {
        };
        private: Singleton<T>(const Singleton<T>&);
        private: Singleton<T>& operator=(const Singleton<T>&);
        public: static Singleton<T>& getInstance()
        {
                static Singleton<T> instance;
 
                return instance;
        }
};

Mais :
1) pourquoi ceci ne compile pas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<typename T>
class Singleton
{
        private: static Singleton<T> instance;
        private: Singleton<T>()
        {
        };
        private: Singleton<T>(const Singleton<T>&);
        private: Singleton<T>& operator=(const Singleton<T>&);
        public: static Singleton<T>& getInstance()
        {
                return instance;
        }
};

?
2) Comment embarquer l'instance unique en tant qu'attribut de la classe si cela est possible ?

Merci .

29/02/2008, 20h19
screetch

Citation:

Envoyé par screetch

il est possible de stocker un T dans la classe singleton.

ce qui manque c'est juste

Code:

template<typename T> T Singleton<T>::instance;
29/02/2008, 20h39
Pragmateek

A quel endroit faut il placer ce code s'il te plait :
- en tant que définition d'attribut
- en tant que retour de la fonction "getInstance"
- ... ?

Aucune des deux solutions citées ne compilant pour l'instant .

En te remerciant de ta patience .
29/02/2008, 21h01
screetch
sur une ligne a elle toute seule :)

quand tu ecris
Code:

1 2 3 4 5 class A { static A* instance; A* getInstance(); };
ce que tu fais c'est dire que la classe A contient une instance A et une fonction getInstance();, ce que l'on appelle une declaration. Cela indique au compilateur que tu vas mettre quelque art ces choses la, qu'elles existent.

Ensuite, tu dois en donner la definition :
Code:

1 2 3 4 5 A* A::getInstance() { return instance; }
cela tu le connais, c'est la definition de la methode, comme tu as dit au compilateur, voila, tu ne mens pas : voila cette fonction.

C'est pareil pour le static, tu dois le definir quelque part, comme les methodes, en ajoutant une ligne :

Code:

type classe::variable (= valeur)

la valeur est optionnelle.

pour A, cela ressemble donc a

Code:

A* A::instance = 0;

voila la definition de la variable A.

Enfin, comme tu travailles avec les templates, comme avec les methodes, la definition doit etre visible par le compilateur donc au lieu de la mettre dans un fichier C++ tu dois la mettre dans un fichier en-tete (.h)
29/02/2008, 21h20
Pragmateek
Merci de ces explications détaillées .
En effet tu as tout a fait raison, c'est la bonne explication et la bonne solution .

Ce qui est "bizarre" c'est que ce comportement, à savoir le fait que l'écriture d'un attribut d'une classe qualifié avec "static" ne soit qu'une déclaration et non une définition, n'est pas valable quand c'est une variable "static" située dans une fonction ou située en dehors de toute fonction ou structure, où il y a à la fois déclaration et définition :
Code:

1 2 3 4 class A { public: static int n; // Que une déclaration };
Code:

1 2 3 4 void f(void) { static int n; // Déclaration et définition }
Code:

static int n; // Déclaration et définition

Y a t'il une raison particulière à cela ?
Pourquoi n'avoir pas fait en sorte que ce soit à la fois une déclaration et une définition ?

Merci .
29/02/2008, 21h34
screetch
Code:

1 2 3 4 class A //Que une declaration egalement =) { public: static int n; // Que une déclaration };
Code:

1 2 3 4 void f(void) // (Declaration) mais surtout definition { static int n; // Déclaration et définition }
il y a un temps pour declarer et un temps pour definir; lorsqu'on definit il est inutile de declarer. Dans la fonction f tu vas declarer/definir une variable, celle ci ne sera atteignable que dans f. Au contraire dans A, tu declares, ce qui signifie que plusieurs gens vont lire ta declaration. c'est une mauvaise chose de mettre une definition car alors tout le monde verra ta definition aussi, d'ou plusieurs definitions.
29/02/2008, 21h50
Pragmateek

D'accord, alors l'explication est le principe de séparation de la déclaration et de la définition.

Donc pour les variables globales "static", peu importe de les déclarer et définir en même temps puisqu'elles ne sont accessibles que dans le fichier où a lieu cette déclaration/définition ?