membre static et heritage

**kacedda** · 19/12/2007, 12h06

Bonjour,

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

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
// 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 :

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 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 :

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

1
2
3
maC1 a;
maC1 b;
maC2 c;

En sortie:

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:

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

**Kujara** · 19/12/2007, 12h14

Template power ?

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
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.

**Floréal** · 19/12/2007, 13h04

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).

**yan** · 19/12/2007, 14h10

Envoyé par Kujara

Template power ?

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
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

Mais lors d'un héritage, je ne sait pas trop ce qui va se passer

[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.

**kacedda** · 19/12/2007, 14h31

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

?

**r0d** · 19/12/2007, 14h33

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

Un truc du style:

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
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();
};

**kacedda** · 19/12/2007, 14h36

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é

). Parce que c'est exactement le meme principe que les fonctions mais avec une variable que je veux faire.

**yan** · 19/12/2007, 14h38

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

**kacedda** · 19/12/2007, 14h38

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

**Floréal** · 19/12/2007, 14h43

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é

). 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:

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 :

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
#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:

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

**r0d** · 19/12/2007, 14h44

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.

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)

**kacedda** · 19/12/2007, 15h40

Floréal

Envoyé par kacedda

Tu crois que c'est impossible?

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

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?

**r0d** · 19/12/2007, 16h08

Un truc dans le style:

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
#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 :

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
#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:

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.

**NiamorH** · 19/12/2007, 16h57

Envoyé par Kujara

Template power ?

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
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

**Floréal** · 19/12/2007, 19h08

Envoyé par kacedda

Floréal

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

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.

**NiamorH** · 19/12/2007, 19h56

Avec une encapsulation plus cohérente :

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
// 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 :

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
// 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.