web-dev-qa-db-fra.com

Est-ce que l'utilisation de .reset () sur std :: shared_ptr supprime toutes les instances

Je suis nouveau dans shared_ptr et j'essaie de comprendre la fonctionnalité exacte de la fonction .reset ().

#include <memory>
#include <stdio>

using namespace std;
class SomeClass{};

int main() 
{
   shared_ptr<SomeClass> sp (nullptr);

   //do some stuff, sp now has 10 co-owners

   cout << sp.use_count << endl;
   sp.reset();
   cout << sp.use_count << endl;
   return 0;
}

Serait sortie

10
0

Donc, depuis que j'ai utilisé la fonction de réinitialisation, toutes les instances sont-elles supprimées de la mémoire? Comme dans, ai-je simplement éliminé les éventuelles fuites de mémoire avec sp? Évidemment, c'était un exemple de jouet que j'ai rapidement inventé, désolé s'il y a des erreurs.

Situation de suivi:

shared_ptr<SomeClass> returnThis() {
    shared_ptr<SomeClass> someObject(new SomeClass(/*default constructor for example*/) );
    return someObject;
}

quelque part en principal:

shared_ptr<SomeClass> mainObject;
mainObject = returnThis();

Est-ce que mainObject a un nombre d'utilisation de 2 parce que someObject a été créé dans une fonction mais n'a jamais été effacé? Ou en est-il un et le nettoyage se fait automatiquement lors du retour de la valeur?

c++memorymemory-leaksshared-memoryshared-ptr
24
zeus_masta_funk

Lorsque vous utilisez .reset(), vous éliminez un propriétaire du pointeur, mais tous les autres propriétaires sont toujours présents. Voici un exemple:

#include <memory>
#include <cstdio>

class Test { public: ~Test() { std::puts("Test destroyed."); } };

int main()
{
    std::shared_ptr<Test> p = std::make_shared<Test>();
    std::shared_ptr<Test> q = p;
    std::puts("p.reset()...");
    p.reset();
    std::puts("q.reset()...");
    q.reset();
    std::puts("done");
    return 0;
}

La sortie du programme:

 p.reset () ... 
 q.reset () ... 
 Test détruit. 
 fait

Notez que p et q sont tous deux propriétaires de l'objet, et une fois que p et q sont réinitialisés, alors le l'instance est détruite.

41
Dietrich Epp

Non, l'objectif de shared_ptr est que vous ne pouvez pas le supprimer d'un endroit si quelqu'un l'utilise dans un autre. sp.reset () diminue simplement use_count de un et remplace son objet par nullptr.

10
Alex Telishev

La méthode .reset () s'applique uniquement à l'objet auquel elle est appelée.

Il remplace simplement le pointeur que la variable détient.

1
Yochai Timmer