membre static et heritage

Version imprimable

Bonjour,

Pour commencer, la FAQ:
Comment initialiser un membre static ?
http://cpp.developpez.com/faq/cpp/?p...SS_init_static
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 // dans le fichier Exemple.h #ifndef EXEMPLE_H #define EXEMPLE_H class Exemple { public: static int compteur; }; #endif // dans le fichier Exemple.cpp #include "Exemple.h" int Exemple::compteur = 0;
On voit ci-dessus comment utiliser un membre static. Personnellement je veux faire pareil, un compteur qui s'incremente dans le constructeur.

Seulement, moi ma classe est herite, et je souhaiterai avoir une variable par classe.
Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Exemple { Exemple() { compteur++; } public: static int compteur; }; class maC1 : public Exemple { maC1() { cout << "maC1 compteur vaut" << compteur; } } class maC2 : public Exemple { maC2() { cout << "maC2 compteur vaut" << compteur; } }
Dans le main
Code:

1 2 3 maC1 a; maC1 b; maC2 c;
En sortie:

Citation:

maC1 compteur vaut1
maC1 compteur vaut2
maC2 compteur vaut3

On voit que les classes maC1 et maC2 partage le meme compteur(herite de exemple).

Moi je voudrai:

Citation:

maC1 compteur vaut1
maC1 compteur vaut2
maC2 compteur vaut1

A part en redefinnissant ma variable a chaque fois je vois pas comment faire!
Une idée?

Merci

Template power ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 template<typename T> class Compteur { public: Compteur() { sm_compteur++; } ~Compteur() { sm_compteur--; } public: static unsigned int sm_compteur; }; class A : public Compteur<A> { }; class B : public Compteur<B> { };
C'est un peu trop compliqué par rapport a le faire a la main, mais ça marche tout autant, normalement.

19/12/2007, 13h04
Floréal

Ce n'est pas très élégant ça.
Par contre, le problème (si c'en est réellement un?) soulevé n'est pas un problème propre au C++, mais plutôt à la théorie objet.
En fait le compteur que tu utilise dans la classe fille est le même que celui de la classe mère et C'est normal, puisque une instance de la classe fille est aussi une instance de la classe mère. Cependant tu peux contrer ce problème en ajoutant un compteur à ta classe fille (tu peux l'appeler "compteur" aussi, il te suffira d'utiliser l'opérateur :: précédé du nom de la classe mère pour faire appel au compteur de la classe mère, s'il n'est pas privé, bien sur). Ainsi comme les deux constructeurs seront appelés les deux compteurs seront incrémentés (et oui 2 instances de la classe mère dont une qui est aussi une instance de la classe fille).

Citation:
Envoyé par Kujara
Template power ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 template<typename T> class Compteur { public: Compteur() { sm_compteur++; } ~Compteur() { sm_compteur--; } public: static unsigned int sm_compteur; }; class A : public Compteur<A> { }; class B : public Compteur<B> { };
C'est un peu trop compliqué par rapport a le faire a la main, mais ça marche tout autant, normalement.
cool ta solution :king:
Mais lors d'un héritage, je ne sait pas trop ce qui va se passer :cry:
[edit]
As si une solution serait d'avoir un constructeur protected de la class mère (genre qui prend un bool) qui initialise la class mère mais n'icremente pas le compteur. Ou une fonction protected qui decremente le compteur de la class mère.

19/12/2007, 14h31
kacedda

mmoui d'accord pour les templates, mais je trouve que ca complique un peu...

Sinon je cree un fonction increment() en virtuel de maniere a obliger l'implementation, mais ca revient au meme, je suis obliger de declarer la variable dans la classe fille.

Bon, d'autre idee:aie:?

Pourquoi ne pas faire une simple factory (et sous forme de singleton puisque le compteur est déjà statique)?

Un truc du style:

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
class Exemple
{
    //...
};
 
class C1 : public Exemple
{
    C1(int compteur);
    //...
};
 
class C2 : public Exemple
{
    C2(int compteur);
    //...
};
 
class ExempleFactory
{
public:
    ExempleFactory* GetInstance(); //singleton
 
    <template T>
    Exemple* CreateExemple(){return new T(compteur++);}
 
private:
    static int compteur;
    ExempleFactory();
};

19/12/2007, 14h36
kacedda

Citation:

Envoyé par Floréal

Ce n'est pas très élégant ça.
Par contre, le problème (si c'en est réellement un?) soulevé n'est pas un problème propre au C++, mais plutôt à la théorie objet.

Tu crois que c'est impossible? car la moi je dirai que c'est une question de porte de variable. Le probleme c'est que l'on peut pas definir de variable en virtual(j'ai essayé:aie:). Parce que c'est exactement le meme principe que les fonctions mais avec une variable que je veux faire.
19/12/2007, 14h38
yan

Citation:

Envoyé par r0d

Pourquoi ne pas faire une simple factory (et sous forme de singleton puisque le compteur est déjà statique)?

???
le compteur ne doit pas etre le même entre la class mère et les class fille
19/12/2007, 14h38
kacedda

rod: pas trop l'habitude des factory, mais en tout cas je ne veux pas faire de singleton, enfin pas dans ce cas present.

Citation:

Envoyé par kacedda

Tu crois que c'est impossible, car la moi je dirai que c'est une question de porte de variable. Le probleme c'est que l'on peut pas definir de variable en virtual(j'ai essayé:aie:). Parce que c'est exactement le meme principe que les fonctions mais avec une variable que je veux faire.

A quel moment ai-je parlé de mettre une variable avec un modificateur "virtual"? C'est justememnt parce que c'est impossible que j'ai proposé cette solution. Et je dis également que pour accéder à la variable compteur de la classe mère:

Citation:

il te suffira d'utiliser l'opérateur :: précédé du nom de la classe mère pour faire appel au compteur de la classe mère, s'il n'est pas privé, bien sur.

Edit: Voilà ou je voulais en venir
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 33 34 35 36 37 38 39 40 41 42 43 #include <iostream> class Mere { public: static unsigned int compteur; inline Mere() { ++compteur; std::cout << "compteur de Mere: " << compteur << std::endl; }; inline ~Mere() { --compteur; }; }; class Fille : public Mere { public: static unsigned int compteur; inline Fille() : Mere() { ++compteur; std::cout << "compteur de Fille: " << compteur << std::endl; }; inline ~Fille() { --compteur; }; }; unsigned int Mere::compteur = 0; unsigned int Fille::compteur = 0; int main() { Mere m1, m2; Fille f1; return 0; }
Resultat:

Citation:

compteur de Mere: 1
compteur de Mere: 2
compteur de Mere: 3
compteur de Fille: 1

19/12/2007, 14h44
r0d

Citation:

Envoyé par Mongaulois

???
le compteur ne doit pas etre le même entre la class mère et les class fille

Ha oui, j'avais mal compris. pardon.

Citation:

Envoyé par kacedda

rod: pas trop l'habitude des factory, mais en tout cas je ne veux pas faire de singleton, enfin pas dans ce cas present.

Comme tu veux, mais pour programmer proprement en c++ l'utilisation de factories devient rapidement inévitable.

Sinon oui, je comprend mieux ton problème, mais je ne vois pas de solution simple. Surtout sans passer par une factory ^^ (car en passant par une factory, il serait possible d'avoir un compteur par type de classe fille, par exemple)
19/12/2007, 15h40
kacedda

Floréal

Citation:

Envoyé par kacedda

Tu crois que c'est impossible?

En fait ici c'etait une question, je n'affirmai rien , m'ai trompe:aie:

Sinon je comprend ton exemple mais ca revient au meme il faut que je redeclare ma variable.
Precision: en fait je pensai, j'aurai voulu en tout cas, que la variable compteur et le mecanisme soit transparent, sans rajouter des trucs dans mes classes filles.

rod: ok, je veux bien en savoir plus, au moins pour la culture, car la dans ton exemple je ne comprend pas trop comment ca marche! en plus il faut passer le compteur en parametre?

Un truc dans le style:

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
33
#include <vector>
 
typedef std::vector<unsigned int> UIVector;
 
struct Exemple
{
	Exemple(unsigned int count = 0):counter(count){}
	unsigned int counter;
};
 
class C1 : public Exemple
{
public:
	C1(unsigned int counter):Exemple(counter){}
};
 
class C2 : public Exemple
{
public:
	C2(unsigned int counter):Exemple(counter){}
};
 
class ExempleFactory
{
public:
	ExempleFactory(){UIVector(2).swap(m_counters);}
 
	C1* CreateC1(){return new C1(m_counters[0]++);}
	C2* CreateC2(){return new C2(m_counters[1]++);}
 
private:
	static UIVector m_counters;
};

Et un exemple d'utilisation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
 
#include "Exemple.h"
 
UIVector ExempleFactory::m_counters;
 
int main()
{
	ExempleFactory exFactory;
 
	C1* pC11 = exFactory.CreateC1();
	C1* pC12 = exFactory.CreateC1();
	C2* pC21 = exFactory.CreateC2();
 
	std::cout << "pC11: " << pC11->counter << std::endl;
	std::cout << "pC12: " << pC12->counter << std::endl;
	std::cout << "pC21: " << pC21->counter << std::endl;
 
	std::cin.get();
	return 0;
}

L'execution de l'exemple affiche:

Citation:

pC11: 0
pC12: 1
pC21: 0

Hope it helps.

J'ai fais ce code rapido, il est un peu pourri, mais il fonctionne et c'est pour donner un exemple de ce que j'avais en tête en parlant de factory.

Citation:
Envoyé par Kujara
Template power ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 template<typename T> class Compteur { public: Compteur() { sm_compteur++; } ~Compteur() { sm_compteur--; } public: static unsigned int sm_compteur; }; class A : public Compteur<A> { }; class B : public Compteur<B> { };
C'est un peu trop compliqué par rapport a le faire a la main, mais ça marche tout autant, normalement.
Je ne vois pas ce qui n'est pas élégant ici (à part le fait que tout est public...), c'est même un exemple du livre C++ Templates : The Complete Guide

19/12/2007, 19h08
Floréal

Citation:

Envoyé par kacedda

Floréal

En fait ici c'etait une question, je n'affirmai rien , m'ai trompe:aie:

Sinon je comprend ton exemple mais ca revient au meme il faut que je redeclare ma variable.
Precision: en fait je pensai, j'aurai voulu en tout cas, que la variable compteur et le mecanisme soit transparent, sans rajouter des trucs dans mes classes filles.

rod: ok, je veux bien en savoir plus, au moins pour la culture, car la dans ton exemple je ne comprend pas trop comment ca marche! en plus il faut passer le compteur en parametre?

Oui oui, j'avais compris, ne t'inquiètes pas. Je ne faisais que préciser ma pensée. J'avais peur de n'avoir pas été suffisamment clair.
Je voulais simplement souligner que ce n'était pas une bizarrerie du C++, mais une règle de la POO.
Donc oui en effet au final tu es obligé de par par une déclaration de ton compteur dans tes classes filles. En fait je dois admettre que la solution de Kujara est plutôt séduisante, après avoir relu son exemple.

Avec une encapsulation plus cohérente :

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
33
34
35
36
// objectcounter.hpp 
 
#include <stddef.h> 
 
template <typename T> 
class Counter
{
protected: 
  Counter()
  {
    ++Counter<T>::count_;
  } 
 
  Counter( Counter<T> const & )
  {
    ++Counter<T>::count_;
  }
 
  ~Counter()
  {
    --Counter<T>::count_;
  }
 
public: 
  // Nombre d'objets en cours d'existance
  static size_t GetNbInstances()
  { 
    return Counter<T>::count_;
  } 
 
private: 
  static size_t count_;
}; 
 
template <typename T> 
size_t Counter<T>::count_ = 0;

Et ça s'utilise comme ça :

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
// testcounter.cpp 
 
#include "objectcounter.hpp" 
#include <iostream> 
 
class A : public Counter<A>
{ 
  … 
}; 
 
class B : public A,
            public Counter<B>
{ 
  … 
}; 
 
int main() 
{ 
    A a1, a2; 
    B b1; 
    std::cout << "number of A: " 
              << A::GetNbInstances() << std::endl; 
    std::cout << "number of B: " 
              << Counter<B>::GetNbInstances() << std::endl; 
}

Tu remarques que le destructeur n'est pas virtuel donc il n'y aura pas de vtable créée en plus. Ce n'est pas risqué car comme le destructeur est protégé, il n'est pas possible de faire un delete sur l'objet ailleurs que dans la classe.

19/12/2007, 21h48
Médinoc

D'ailleurs, l'héritage lui-même pourrait être non-public, non ?
19/12/2007, 22h45
NiamorH

Citation:

Envoyé par Médinoc

D'ailleurs, l'héritage lui-même pourrait être non-public, non ?

Hum il faut pouvoir accéder à la méthode GetNbInstances, a moins de l'utiliser uniquement comme ça ensuite : Counter<A>::GetNbInstances();
20/12/2007, 12h47
kacedda

Ok, c'est cool merci pour les exemples, factory et template, va bien me servir je crois finalement:mouarf:.