c++ - Si usa.reset() en un std:: shared_ptr, elimine todas las instancias

memory memory-leaks

Question

Soy nuevo en shared_ptr''s y estoy tratando de averiguar la funcionalidad exacta de la función .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;
}

Saldría

10
0

Entonces, ¿desde que usé la función de reinicio, todas las instancias se eliminaron de la memoria? Como en, ¿acabo de eliminar cualquier posible pérdida de memoria con sp? Obviamente, este fue un ejemplo de juguete que inventé rápidamente, perdón si tiene algún error.

Situación de seguimiento:

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

en algun lugar en main

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

¿Tiene mainObject una cuenta de uso de 2 porque someObject se creó en una función pero nunca se borró? ¿O es uno y la limpieza se realiza automáticamente al devolver el valor?

Answer 1

Cuando usas .reset() , estás eliminando un propietario del puntero, pero todos los demás propietarios aún están alrededor. Aquí hay un ejemplo:

#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;
}

El programa de salida:

p.reset()... q.reset()... Test destroyed. done

Tenga en cuenta que p y q son ambos propietarios del objeto, y una vez que se restablecen tanto p como q , se destruye la instancia.

Answer 2

El método .reset () solo se aplica al objeto al que se llama.

Simplemente reemplaza el puntero que mantiene la variable.

Answer 3

No, todo el propósito de shared_ptr es que no puede eliminarlo de un lugar si alguien lo está utilizando en otro. sp.reset () solo disminuye use_count en uno y reemplaza su objeto por nullptr .