Classe singleton ?

**deubelte** · 09/12/2011, 21h39

Yo!

Je voudrais savoir si la classe suivante est bien un singleton. Surtout au niveau de l'appel de la fonction instance(). Est ce que cela consiste bien en un singleton.

Merci

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
38
39
40
41
42
43
44
45
class Statique
{
public:
    static Statique* instance()
	{
		static Statique static_;
			 return &static_;
	}
	 ~Statique()
	{
	  //  delete T;
		std::cout<<"Statique::dtor default"<<endl; 
	};
	 void set_o(int arg1)
	{
	    o=arg1;
	}
private:
	Statique(const Statique& right)
	{
		std::cout<<"Statique::ctor copy"<<endl;  
		o=right.o;
		c=right.c; 
	};
	Statique():o(0),c('d')
	{ 
	//	T[0]=0;
	//	T[1]=1;
		std::cout<<"Statique::ctor default"<<endl; 
	};
 
   private:
		int o;
		char c;
	//	char *T;
};
 
int main(){
 
	Statique* ind(Statique::instance());
 
	Statique* obj2(Statique::instance());
 
	ind->set_o(99);
}

**Dalini71** · 09/12/2011, 21h59

A vue de nez ca à l'air bon.

Par contre pourquoi implémenter le constructeur par copie ? Ça n'a pas vraiment de sens vu que tu ne peux pas avoir plus d'une instance de ta classe.

Plus de détails sur les Singletons dans FAQ C++.

**deubelte** · 09/12/2011, 22h14

Par contre pourquoi implémenter le constructeur par copie ?

Par habitude. Sinon, j'ai fait 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
35
 
enum AS{
	Coeur, 
	Trefle,
	Carreau
};
 
class Gr
{
public:
	Gr()
	{
		cout<<"std::default ctor";
	}	
	Gr(const Gr& right)
	{
		cout<<"std::copy ctor"; 
	}
	Gr(ASarg1, std::string arg2):f(arg1),g(arg2)
	{
	}
	~Gr()
	{
		std::cout<<("ee");
	}
private:
	AS f;
	std::string g;
 
};
 
static const Gr Tab[2]={
	Gr(AS::Carreau,"Carreau"),
	Gr(AS::Coeur, "Coeur"),
};

En fait je veux créer un tableau statique ("globlal" donc) qui contient des éléments de la classe Gr. Lorsque je crée ce tableau, le destructeur est appelé à chaque fois, ce qui est normal. Je n'arrive pas à rendre statique les
élements du tableau, bien que le tableau le soit.

**deubelte** · 09/12/2011, 23h17

Quand on fait ca par exemple,

Code :

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

1
2
 
static int tab[]={1,4...}

alors c'est sur que les éléments du tableau ne vont pas être supprimés une fois que le tableau sera instancié dans la zone mémoire réservée au variable statiques.

Avec mon ancien code, les éléments du tableau étaient deletés un fois le tableau crée. Ce qui est normal en fait.
J'ai fait 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
35
36
37
38
39
40
41
42
enum AS{
	Coeur, 
	Trefle,
	Carreau
};
 
class Gr
{
public:
	static Gr* instance(AS f, std::string g)
	{		cout<<"std::default ctor"<<endl;
 
	 Gr* fuck=new Gr(f,g);
	 return fuck;
 
	}
	Gr()
	{
		cout<<"std::default ctor"<<endl;
	}
	Gr(const Gr& right) 
	{
		cout<<"std::copy ctor"<<endl; 
	}
 
	Gr(AS arg1, std::string arg2):f(arg1),g(arg2)
	{
		std::cout<<("ctor ")<<endl;
	}
	~Gr()
	{
		std::cout<<("dtor ")<<endl;
	}
private:
	AS f;
	std::string g;
 
};
static const Gr* Tab[2]={
	Gr::instance(AS::Carreau,"Carreau"),
	Gr::instance(AS::Coeur, "Coeur"),
};

Mais j'ai alloué sur de la mémoire sur le tas. Ne risque t-on pas d'avoir de la memory leak, étant donné que je n'appelle pas l'operateur delete?
Merci

**koala01** · 10/12/2011, 09h39

Salut,

Tu l'as surement déjà lu sur le forum, je me contente donc juste d'un rappel, mais, les variables statiques (quelle que soit leur forme) CEYMAL...

La question que je me pose dés lors, c'est

pourquoi crois tu avoir besoin d'un tableau statique de cartes

Au pire, tu crées une collection de pointeurs sur des cartes allouées dynamiquement (pour prendre la responsabilité de la durée de vie des cartes

) (je verrais bien une liste plutot qu'un tableau

) qui appartient (je parle de la collection

) à une classe (appelons la "Sabot" par facilité

) dont la responsabilité est... de gérer les cartes, à savoir

de les sortir "à la demande" en début (ou en cours) de partie
de les récupérer en fin de partie / tour

La seule classe disposant du sabot est le croupier (ou la banque) qui va décider de prendre une carte dans le sabot pour la donner à un joueur ou à une main.

En fonction du jeu que tu veux créer, il n'est pas exclu que différentes classes puissent s'échanger les cartes, en en donnant par-ci en en prenant par là ou en en demandant au croupier (à la banque).

Mais, une chose est sure : quand le tour (ou la partie, selon le jeu que tu crées

) est fini, le croupier récupérera l'ensemble des cartes l'ensemble des cartes qui sont sorties du sabot pour les y remettre, en vue de préparer le prochain tour, la prochaine partie.

Lorsque tu lancera ton application, le croupier sera fatalement créé durant la phase d'initialisation (avant meme qu'un joueur ne se soit joint à la partie), et donc le sabot dont il dispose sera, lui aussi créé.

Comme le sabot sera créé, l'ensemble des cartes nécessaires pour le remplir sera, lui aussi, créé

et, inversement, lorsque tu décidera de quitter l'application, le croupier sera détruit dans la phase de "nettoyage" (une fois que tous les joueurs auront quitté la partie), et le sabot dont il dispose le sera d'office également.

C'est à ce moment là que toutes les cartes contenues dans le sabot seront elles aussi détruites

En gros, ton sabot n'a absolument aucun besoin d'être un singleton, vu qu'il ne doit etre connu que du croupier, qui ne doit lui-même absolument pas être un singleton, vu qu'il doit y en avoir un (différent !!!) pour chaque table qui n'a elle non plus aucune raison d'être un singleton vu que tu pourrais (pourquoi pas) prévoir d'avoir plusieurs tables actives en meme temps dans ton application.

Enfin, ce qui contient les différentes tables n'aura sans doute aucune raison d'être un singleton car ce sera sans doute ce qui sert d'interface vers l'extérieur (ce qui accepte l'arrivée d'un nouveau joueur et lui propose les différentes tables auxquelles il peut s'assoir, en fonction des places disponible), qui sera créé dans main et qui disposera sans doute d'une fonction run, appelée depuis main, dont on ne sortira plus tant que l'application tournera

As tu compris pourquoi il est inutile de créer un quelconque tableau statique de cartes ou un quelconque singleton

**deubelte** · 10/12/2011, 10h27

Au pire, tu crées une collection de pointeurs sur des cartes allouées dynamiquement (pour prendre la responsabilité de la durée de vie des cartes ) (je verrais bien une liste plutot qu'un tableau ) qui appartient (je parle de la collection ) à une classe (appelons la "Sabot" par facilité ) dont la responsabilité est... de gérer les cartes, à savoir

Ok, je vois. Je peux créer une variable statique dans la classe, qui sera initialisée tout au début, avant le début du jeu comme tu dis.
Donc on peut faire ca:

Code :

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

1
2
3
4
class Gr
{
public:
	static  const Gr* Tab[];

Mais, une chose est sure : quand le tour (ou la partie, selon le jeu que tu crées ) est fini, le croupier récupérera l'ensemble des cartes l'ensemble des cartes qui sont sorties du sabot pour les y remettre, en vue de préparer le prochain tour, la prochaine partie.

Ca ca doit vouloir dire que les éléments du tableau crées dynamiquement sont détruits à la fin du programme.

As tu compris pourquoi il est inutile de créer un quelconque tableau statique de cartes ou un quelconque singleto

Un singleton oui, mais je vois pas ce qui m'empeche de fiare un static.

Classe singleton ?

C++

Vue hybride

Discussions similaires

Partager

Partager