Discussion :

[Rick_Cplusplus]

Bonjour la communauté,

Ci dessous 2 codes (minimal) qui (je pense) fonctionnent pour gérer une collection d'objet via un Vector :

"A l'ancienne" donc avec des pointeurs nus :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
{
std::vector <Objet *> vPobjet; // Objet est une classe définie par ailleurs
for(int i=0; i<5; i++) vPobjet.push_back(new Objet()); // 5 Pointeurs vers 5 nouveaux objets poussés dans le vector
...
vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
...
vPobjet[2] -> destruct(); // utilisation d'une méthode qui appelle le destructeur de la classe (destruction de l'objet 3)
delete vPobjet[2]; // libération de la mémoire occupée par l'objet 3 maintenant détruit
vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
}

En C++ "moderne" donc avec des pointeurs smart :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
{
std::vector <std::unique_ptr<Objet>> vPobjet; // Objet est une classe définie par ailleurs
for(int i=0; i<5; i++) vPfenetre.push_back(std::make_unique<Objet> ()); // 5 Pointeurs uniques vers 5 nouveaux objets poussés dans le vector <= Ici "emplace_back" est peut être préférable ?
...
vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
...
vPobjet[2] -> destruct(); // utilisation d'une méthode qui appelle le destructeur de la classe (destruction de l'objet 3)
// PAS DE DELETE Pke Pointeur smart (il se débrouille pour libérer la mémoire) :D
vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
}

Normalement dans les 2 cas je n'ai pas de fuite mémoire... Est-ce correct ?

Rick.

[dalfab]

Bonjour,

Je suis d'accord sauf que je ne comprends pas du tout ce que tu fais ligne 8 pour tes 2 codes. C'est quoi cette fonction destruct() ? Il ne faut pas détruire l'objet 2 fois! Et s'il y a des choses supplémentaires pourquoi ne sont-elles pas dans le destructeur de Objet.

[koala01]

Salut,

Le destructeur est la seule fonction d'une classe qui ne doive JAMAIS (*) être appelée de manière explicite à partir d'une instance de la classe!!!

Ni de manière directe, sous une forme qui serait proche de

Code :

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

1
2
3
4
5
int main(){
     Object * ptr= new Obejct;
     /* ... */
     ptr->~Object();
}

ni de manière indirecte, sous une forme qui serait proche de

Code :

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

1
2
3
4
5
int main(){
     Object * ptr= new Obejct;
     /* ... */
     ptr->destruct(); // fonction qui fait appel à ~Object()
}

La raison en est simple : le destructeur est appelé systématiquement et automatiquement par le compilateur
1- lorsqu'on quitte la portée d'une variable:

Code :

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

1
2
3
4
5
6
void foo(){
    Oject obj;
    /* ...*/ 
} /* obj est automatiquement détruit (et son destructeur automatiquement appelé-
   * ici, parce qu'il n'est plus accessible au delà  de ce point
   */

2- lorsque l'on invoque delete (ou delete[]) sur un objet dont la mémoire a été alloué de manière dynamique au travers de new (ou de new [] , sous une forme proche de

Code :

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

1
2
3
4
5
void foo(){
     Object * ptr= new Obejct;
     /* ... */
     delete ptr; // delete fait appel au destructeur de l'objet
}

(*) Bien sur, il y a des exceptions à cette règle, comme pour toutes les règles "un peu trop strictes", mais tu auras largement l'occasion de les apprendre "plus tard". Contentes toi donc de l'appliquer à la lettre dans un premier temps

Ton code devrais donc prendre une forme qui serait plus proche de quelque chose comme

Code :

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

1
2
3
4
5
6
7
8
9
10
{
std::vector <Objet *> vPobjet; // Objet est une classe définie par ailleurs
for(int i=0; i<5; i++) vPobjet.push_back(new Objet()); // 5 Pointeurs vers 5 nouveaux objets poussés dans le vector
...
vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
...
delete vPobjet[2]; // libère la mémoire allouée à l'objet 3 (et appelle le destructeur pour ce faire)
vPobjet[2] = nullptr;  // indique explicitement que ce pointeur représente une adresse mémoire invalide
vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
}

Quant à l'utilisation des pointeurs intelligents, elle prendrait une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
{
std::vector <std::unique_ptr<Objet>> vPobjet; // Objet est une classe définie par ailleurs
for(int i=0; i<5; i++) vPfenetre.push_back(std::make_unique<Objet> ()); // 5 Pointeurs uniques vers 5 nouveaux objets poussés dans le vector <= Ici "emplace_back" est peut être préférable ?
...
vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
...
vPobjet[2].reset(); // ordonne au pointeur de libérer l'espace mémoire alloué à son pointeur sous-jacent
                     // en invoquant delete dessus et en appelant donc le destructeur de manière correcte
// PAS DE DELETE Pke Pointeur smart (il se débrouille pour libérer la mémoire) :D
vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
}

Pour le reste, tu as effectivement compris le principe : la classe std::unique_ptr prend la responsabilité complète de la gestion du pointeur sous-jacent qu'on lui fournit, et veille bel et bien à libérer la mémoire qui y a été allouée au moment opportun

[Rick_Cplusplus]

Tout à fait d'accord, on ne détruit qu'une fois. ^^
J'avais juste un doute sur la pertinence à mettre le destructeur en "Public"...
Effectivement, au vu de ce qu'explique Koala, le rôle joué par "delete" est plus complet que je ne l'avais compris.

Du coup, je pense que ce petit sujet va trouver toute sa pertinence auprès les débutants enthousiastes mais isolés.
Merci à tous, sujet clos pour moi.

Rick.

[Invité]

Bonjour,

Normalement dans les 2 cas je n'ai pas de fuite mémoire... Est-ce correct ?

Les pointeurs intelligents : pas de soucis, autre que ceux évoqués par koala01.

Les pointeurs nus…

• Tu ne delete que le pointeur d'indice 2. Que fais-tu des 4 autres ?
• Que se passe-t-il si un de tes new échoue et lance une exception ?
• Que se passe-t-il si un push_back() échoue et lance une exception ?
• Que se passe-t-il si faitUnTruc() ou ce qu'il y a dans les ... lance une exception ?

[Rick_Cplusplus]

Bonjour,

Les pointeurs nus…

• ...
  la liste de question
  ...

Oui oui je connais les défaut inhérents aux pointeurs nus (c'est bien expliqué dans la FAQ de ce site par ailleurs). c'est pour ça que j'avais écrit : "Normalement, dans les 2 cas..."
Je suis personnellement convaincu qu'un pointeur smart (unique dans ce cas) c'est bien plus sûr, mais je voulais avoir confirmation (et correction ) de la gestion de ceux-ci avec un vector.
Koala a été très clair, et en plus m'a confirmé qu'un "delete" appelle le destructeur de l'objet pointé ce dont je n'étais pas certain. Merci encore d'aider ainsi les apprentis.

Rick.