Est-ce que les conteneurs de la STL fonctionnent comme un std::shared_ptr ?

Invité · 22/09/2014, 13h56

Salut!

J'ai lu sur plusieurs articles que les contenaires de la STL sont des capsules RAII et qu'il est important de les utiliser en c++.
Si j'ai bien compris, en gros, ça signifie que si je fait ça :

Code cpp :

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

1
2
3
 
std::vector<Objet*> list = {new Objet(), new Objet(), ...};
std::vector<Objet*> list2 = list;

Les objects contenu dans les listes seront bien détruis lorsque les 2 listes (list et list2) seront détruites ?

Sinon que se passerais t'il si je fais ça ?

Code cpp :

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

1
2
3
4
5
6
7
 
Objet* o1 = new Objet();
{
std::vector<Objet*> list = {o1, new Objet(), ...};
std::vector<Objet*> list2 = list;
}
//Utilisation de o1 -> crash ?

Le std::vector agit t'il comme un delete ou bien faut t'il delete tout les éléments du std::vector manuellement ?

Bon j'ai eu ma réponse ici (ce code ne crash pas)

Code cpp :

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

1
2
3
4
5
6
7
8
 
int main()
    std::string* s = new std::string("Hello!");
    {
        std::vector<std::string*> list = {s, new std::string("world")};
    }
    std::cout<<*s<<std::endl;
return 0;

Donc bon je ne comprend pas trop bien comment les contenaires de la STL delete les objets.

**Flob90** · 22/09/2014, 14h07

Non, rien (du moins pas ce à quoi tu penses) ne sera détruit dans ce cas. C'est dans le cas std::vector<Objet> où le contenu sera libéré automatiquement (contrairement à un Objet* sur lequel il faut appeler delete[]).

Invité · 22/09/2014, 14h11

Ha ok je vois donc le mieux dans mon cas ça serait d'utiliser un std::vector de std::unique_ptr pour celui qui à la responsabilité de détruire les entités. (Je dois utiliser des pointeurs pour éviter le slicing)

**phi1981** · 22/09/2014, 14h11

Tu vas sûrement trouver la réponse à ta question avant que je n'ai le temps de finir mon message, mais tant pis j'essaye quand même

La réponse est non: les objets ne seront pas détruits.

Ton exemple utilise std::vector, mais ce que je dis ici est valide pour les autres conteneurs de la STL : std::list, std::map, std::string etc.
A la destruction d'un conteneur, les éléments qu'il contient sont détruits: on appelle leur destructeur.
Mais dans ton cas, ton vector contient juste des pointeurs nus (Object *), et ces pointeurs nus n'ont pas de destructeur (c'est un type de base, pas une classe). Du coup, vector fait son travail: il libère bien la mémoire qu'il utilise. Mais tu ne fais pas le tien: tu n'effaces pas ce qui est pointé par les pointeurs que tu as stocké dans ton vector. Il en résulte une fuite mémoire.

D'ailleurs : comment vector pourrait-il savoir qu'il faut appeler delete sur chacun des pointeurs ? Rien ne le lui indique : peut être que tu possèdes d'autres pointeurs sur ces mêmes objets. Si cette mémoire était désallouée, tes autres pointeurs pointeraient sur quelque chose de bidon.

La solution à ce problème est hyper-élégante : utilise un vector pour stocker des pointeurs intelligents, comme std::shared_ptr ou std::unique_ptr (ou un pointeur intelligent écrit par quelqu'un d'autre).
Ces pointeurs intelligents, lorsque leur destructeur est appelé (donc, dans notre cas, lorsque le destructeur de vector est appelé), vont gérer la situation suivant leurs spécifications: unique_ptr appellera le destructeur de Objet, et libérera sa mémoire, shared_ptr ne le fera que si l'objet n'est pas référencé ailleurs.