Mon Singleton est-il correct ?

**olive_le_malin** · 15/12/2006, 10h50

Bonjour,

dans une appli A1, je dois mettre des infos en mémoire partagée, qui seront utilisées par une autre appli A2.
Donc pour ça j'ai fait une classe CSharedMemory. Pas de pb.

Dans cette appli A1, je sais donc que je dois utiliser un objet "global" CSharedMemory, et aprés avoir utilisé "extern" que je trouvais un peu pourri, et en voyant l'exeple de la faq sur le Singleton, je me suis dit pourquoi pas l'utiliser.

Est-ce correct ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class CGlobal
{
 
private :
	CSharedMemory sm;
 
	//Constructeur privé
    CGlobal() :
		sm(1000, "SM_TDELTA") {
	}
 
public :
	//Fonction static pour appeler notre seul objet CSharedMemory
	static CSharedMemory& GetSharedMemory();
};
 
 
CSharedMemory& CGlobal::GetSharedMemory()
{
	static CGlobal glob;
	return glob.sm;
}

Je compte utliiser cette classe CGlobal pour y mettre d'autres objets utilisés encore auourd'hui en "extern"

Merci par avance.
@+

**bolhrak** · 15/12/2006, 11h08

Il faut également que tu déclares le constructeur de copie et l'opérateur d'affectation en privé, sinon il y aura possibilité de dupliquer ton objet. Pas la peine de les définir par contre.

EDIT : j'avais aps fait attention, là c'est ton CGlobal qui est un singleton, pas CSharedMemory.

**olive_le_malin** · 15/12/2006, 11h20

EDIT : j'avais aps fait attention, là c'est ton CGlobal qui est un singleton, pas CSharedMemory.

Ben oui, c'est sûr que ça empeche personne de redéclarer un CSharedMemory,
mais ce que je voulais c'est + de propreté qu'un extern pour mes objets globaux ...

**bolhrak** · 15/12/2006, 11h22

Envoyé par olive_le_malin

Ben oui, c'est sûr que ça empeche personne de redéclarer un CSharedMemory,
mais ce que je voulais c'est + de propreté qu'un extern pour mes objets globaux ...

Ok pas de souci alors, c'est le commentaire de la méthode GetCSharedMemory qui m'a induit en erreur :p

**Laurent Gomila** · 15/12/2006, 11h25

Par contre si tu veux gérer plusieurs variables tu ne pourras plus déclarer ton instance de CGlobal en static dans les fonctions. A moins de faire une fonction unique GetGlobals() qui renvoie l'instance unique de CGlobal, puis de faire des accesseurs classiques pour accéder à ses diverses données membres.

Attention aussi à la durée de vie de tes objets : avec une instance statique tu ne contrôles pas la destruction de ton singleton, et donc de ses données membres.

Je plussoie aussi sur l'opérateur = et le constructeur par copie privés non définis. Sinon ton singleton sera bancal.

**Jan Rendek** · 15/12/2006, 11h43

La conception n'est pas claire. Dans ce cas, ça marchera parce qu'il n'y a qu'une seule fonction membre de CGlobal qui peut être utilisée et que c'est dans cette fonction que le l'instance unique de CGlobal est créée. Mais que se passera-t-til s'il y en a deux ?

En fait, ta solution est à cheval entre deux modèles de conception. Celui d'une classe 'singleton' et celui d'une classe non-instanciable qui ne regroupe que des variable 'statiques'.

Le premier modèle correspond à ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
 
class CGlobal
{
public:
  // accès au singleton
  CGlobal& instance() {
    static CGlobal sf_instance;
    return sf_instance;
  }  
 
  Ressource1& ressource1() {
    return ressource1_;
 }
 
  Ressource2& ressource2() {
    return ressource2_;
 }
 
protected:
  CGlobal() {
    /* init des variables membre */
  }
 
private:
  Ressource1 ressource1_;
  Ressource2 ressource2_;
 
  // Interdiction des copies
  CGlobal(const CGlobal& other);
  CGlobal& operator=(const CGlobal& other);
};
...
/* Accès à une ressource */
CGlobal::instance().ressource1();

le second modèle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
class CGlobal
{
public:
  static Ressource1& ressource1() {
    static Ressource1 sf_ressource1;
    return ressource1;
 }
 
  static Ressource2& ressource2() {
    static Ressource2 sf_ressource2;
    return ressource2;
 }
private:
  CGlobal(); // Classe non instanciable
};
 
// Accès à une ressource
CGlobal()::ressource1();

Méler les deux me semble bancal

**olive_le_malin** · 15/12/2006, 11h45

Bonjour,
merci pour vos réponses.

Il faut également que tu déclares le constructeur de copie et l'opérateur d'affectation en privé, sinon il y aura possibilité de dupliquer ton objet. Pas la peine de les définir par contre.

Je plussoie aussi sur l'opérateur = et le constructeur par copie privés non définis. Sinon ton singleton sera bancal.

OK, je vais le faire

Par contre, je comprends pas ça :

Par contre si tu veux gérer plusieurs variables tu ne pourras plus déclarer ton instance de CGlobal en static dans les fonctions. A moins de faire une fonction unique GetGlobals() qui renvoie l'instance unique de CGlobal, puis de faire des accesseurs classiques pour accéder à ses diverses données membres.

Puisque là je renvoie un accesseur à ma variable membre privée CSharedMemory, qu'est ce qui m'empêche de le faire pour les autres ?

@+

**Jan Rendek** · 15/12/2006, 11h56

Envoyé par olive_le_malin

Par contre, je comprends pas ça :
Puisque là je renvoie un accesseur à ma variable membre privée CSharedMemory, qu'est ce qui m'empêche de le faire pour les autres ?

Singleton = une seule instance de la classe CGlobal.
Si je suis ton modèle, avec 2 ressources cela donne ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
 
class CGlobal
{
 
private :
	CSharedMemory sm;
        CRessource ressource;
 
   //Constructeur privé
    CGlobal() : sm(1000, "SM_TDELTA"), ressource(...)
        {
	}
 
public :
	//Fonction static pour appeler notre seul objet CSharedMemory
	static CSharedMemory& GetSharedMemory();
 
	//Fonction static pour appeler notre seul Ressource
	static CSharedMemory& GetRessource();
 
};
 
 
CSharedMemory& CGlobal::GetSharedMemory()
{
	static CGlobal glob; // <--- Création d'une instance de CGlobal
	return glob.sm;
}
 
CSharedMemory& CGlobal::GetRessource()
{
	static CGlobal glob; // <--- Création d'une instance de CGlobal
	return glob.ressource;
}

Ce qui pose beaucoup de soucis, puisque deux instance de CGlobal sont créées.
Cela implique que le constructeur de CGlobal sera appelé 2 fois, donc 2 instances de Ressource et CSharedMemory seront initialisées.
Si ma deuxième ressource nécéssite des ressources uniques (socket sur une adresse IP par exemple), les conséquences sont désastreuses.

**olive_le_malin** · 15/12/2006, 11h59

Pauvre de moi, exact !!!
Merci ... ce fut trés clair !

Effectivement, sans l'écrire avec Plusieurs variables membres, je l'avais pas vu !

Je vais donc arranger ça comme il faut.

Par contre, Et il est vrai que ce que je veux faire correspond peut être mieux au second modele décrit par Jan Rendeck.

Merci beaucoup

**olive_le_malin** · 15/12/2006, 14h49

Re-bonjour,
une dernière question :

par rapport au premier modèle donné par Jan Rendeck :
ne serait-il pas mieux d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
37
 
class CGlobal
{
private :
  // accès au singleton
  static CGlobal& instance() {
    static CGlobal sf_instance;
    return sf_instance;
  }  
 
public:
  static Ressource1& ressource1() {
    return instance().ressource1_;
 }
 
  static Ressource2& ressource2() {
    return instance().ressource2_;
 }
 
protected:
  CGlobal() {
    /* init des variables membre */
  }
 
private:
  Ressource1 ressource1_;
  Ressource2 ressource2_;
 
  // Interdiction des copies
  CGlobal(const CGlobal& other);
  CGlobal& operator=(const CGlobal& other);
};
...
/* Accès à une ressource */
CGlobal::ressource1();
CGlobal::ressource2();

De ce fait on simplifie la notation à l'utilisation, non ?

@+

**Jan Rendek** · 15/12/2006, 14h52

Ce n'est pas plus simple, AMA. Tu mélanges une fois encore les 2 méthodes.
Si les méthodes ressource1() et ressource2() sont 'static', quelle est l'utilité de l'instance unique de la classe CGlobal ?
Dans ce cas, il faut mieux utiliser une classe non-instanciable pour regrouper l'ensemble de ces fonctions et variables comme je l'expose dans mon précédent message.