compteur d'instance et allocation statique

bonjour,
aujourd'hui, problèmes de comptage.
donc, j'ai un vector dans lequel je stocke des instances d'une classe, instances créées, sauf erreur, en statique avec :

Code:

---

1 2 3 4 5 6 7

// dans le .h std::vector <Food> Foods; Food food; //et qq part dans le .cpp Food food(x,y); Foods.push_back(food);

---

jusque ici, tout marche, ça compile et ça s'exécute comme prévus.

Je désire maintenant connaitre le nombre d'instance de la classe Food en mémoire et la place que cela prend.
j'ai donc ajouté à ma classe et au constructeur:

Code:

---

1 2 3 4 5

static int nbFood; static int nbMemory; // et nbFood ++; memory += sizeof(Food);

---

Jusque ici, tout vas bien, j'en ajoute un, cela comptabilise.
Cela se gatte lorsque je supprime un food que je voudrais du coup comptabiliser en moins dans nFood.

Code:

---

1 2	nbFood --; memory -= sizeof(Food);

---

dans le destructeur m'affiche n'importe quoi, vus fort logiquement comme j'ai pu le lire, que le destructeur est appelé de façon implicite dès que le programme quitte la portée dans lequel l'objet existe, ce qui est visiblement régulièrement le cas avec des appels du type

Code:

---

Foods[i].qqchose()

---

à de multiples endroits de mon programme.

Je ne voudrais pas avoir à passez par l'allocation dynamique et les pointeurs, apparemment des vectors de pointeurs étant une quasi hérésie :) (surtout que je risque fort de ne pas maitriser la chose et de finir avec au mieux du code qui ne compile plus)...
Mais j'aimerais bien tout de même pouvoir suivre le nombre de Food crées et la place occupée...

Deux questions donc :
1 - puis je considérer qu'apres

Code:

---

Foods.pop_back();

---

le dernier food stocké et retiré de Foods n'existe plus nul part et est bien effacé de la mémoire ?
2 - Y a t'il une combine pour faire le petit comptage tant espéré sans passer par l'allocation dynamique ?

Salut,

Citation:

---

Envoyé par jahmanzaar

1 - puis je considérer qu'apres

Code:

---

Foods.pop_back();

---

le dernier food stocké et retiré de Foods n'existe plus nul part et est bien effacé de la mémoire ?

---

Oui.
La destruction des objets est déterministe en C++. Dès que tes variables sortent de la portée et dès que tes conteneurs sont vides, les objets sont détruits.
Seul l'allocation dynamique demande une destruction explicite (qui redevient implicite via l'utilisation de pointeur intelligent).

Citation:

---

Envoyé par jahmanzaar

2 - Y a t'il une combine pour faire le petit comptage tant espéré sans passer par l'allocation dynamique ?

---

Attention aux copies implicites qui font appel au constructeur par copie défini implicitement par le compilateur (Quand dois-je définir un constructeur par copie ?)

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

#include <iostream> struct Food { Food() { ++nbFood; } ~Food() { --nbFood; } static int nbFood; }; int Food::nbFood = 0;   int main() { { Food f; Food copy(f); // appel du constructeur par copie. nbFood n'est pas incrémenté } // Ici destructeur de f et de copy => nbFood est décrémenté 2 fois assert(Food::nbFood==-1);   return 0;   }

---

Ton constructeur par copie (comme tous les constructeurs de la classe de Food) doit incrémenter la variable statique :

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

#include <iostream> struct Food { Food() { ++nbFood; } Food(Food const&) { ++nbFood; } ~Food() { --nbFood; } static int nbFood; }; int Food::nbFood = 0;   int main() { { Food f; Food copy(f); // appel du constructeur par copie => Ok, nbFood est correctement incrémenté } // Ici destructeur de f et de copy => nbFood est décrémenté 2 fois assert(Food::nbFood==0);   return 0;   }

---

Bonjour,
Donc, tétu, même si l'on me dit que la que la destruction est déterministe, je veux tout de même savoir combien j'ai de food :P

Avec

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

Food() { ++nbFood; } Food(Food const&) { ++nbFood; } ~Food() { --nbFood; }

---

Cela fonctionne nickel, je sais maintenant combien j'ai de food a tout moment.
Sauf, que mes food ne s'initialisent plus correctement, visiblement ...

A l'initialisation d'un food, je fait :

Code:

---

1 2 3 4 5 6 7 8

Food f; f.init(rand()%100,rand()%100); Foods.push_back(f); // puis, plus loin des appels à Food du style f.affiche(); // avec dans Food : void Food::init(int a,int b){x = a;y = b;} void Food::affiche(){std::cout<<"pos x - y :"<< x <<" - "<< y<<std::endl;}

---

avant de definir Food(Food const&) , cela marchais, maintenant, les x et y des foods sont à 0 ... :calim2:

peut être bien que je vais essayer de ne pas m'obstiner et arrêter de compter... mais j'aimerais bien quand même compter ...

le problème c'est que maintenant que tu as defini un constructeur de copie, il faut faire toi-même la copie de Food dans ce constructeur de copie.

:(
c'est la que le bas blesse ...
Aucune idée de la manière de faire et je ne trouve rien de clair sur la toile ... mais peut être ai je mal cherché ...
Quelqu'un aurais t'il un début d'idée de la syntaxe à employer ?

il suffit de faire la copie de tous les champs de la classe un par un

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class X { int x, y, z, w; Foo foo; public: ... X(const X& other) : x(other.x) , y(other.y) , z(other.z) , w(other.w) , foo(other.foo) { s_instanceCount++;} };

---

j'avance à grand pas ...
seul petit problème maintenant,
ma classe étant dérivée d'une classe plus générale, s'agissant d'un champ private dans la classe mère, j'ai une erreur type membre inaccessible ... logique encore ... mais énervant ...

je crois avoir trouvé, il faut visiblement que je définisse aussi un constructeur de copie dans la classe mère pour ses membres private.
Ensuite, pour le constructeur de classe X, dérivée de Mere

Code:

---

1 2	X(const X& other):Mere(other)

---

si j'ai tout bien compris, cela devrais marcher ...

tu n'est pas obligé de le définir je crois; si tu n'en as pas le compilateur en met un pour toi.
c'est seulement si tu veuxu ne copie "speciale" (comme le compteur d'instance) que tu as besoin de le definir toi meme (a tester mais je crois bien)

Salut,
1/ L'héritage est souvent incompatible avec la copie.
2/ Au pire, pour dupliquer un tel objet, on se base sur le DP Clone afin de permettre un clonage de la classe dérivée y compris avec un pointeur/référence de la classe de base
3/ SRP oblige : sort le comptage de référence dans une classe dédiée et la classe de départ n'aura pas besoin de constructeur de copie explicite :

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

#include <iostream> #include <string>     struct Food { Food(int m1, std::string m2):membre1(m1),membre2(m2) {}     struct compteur { compteur() { ++nbInstances; } compteur(compteur const&) { ++nbInstances; } ~compteur() { --nbInstances; } static std::size_t nbInstances; };     private: int membre1; std::string membre2; compteur cpt;     }; std::size_t Food::compteur::nbInstances = 0;

---