c++ - make - shared_ptr reference

C++ 11 almacenando múltiples punteros compartidos como punteros en bruto

Question

Mi pregunta se refiere a shared_ptr y make_shared en C ++ 11. Tengo dos vectores, el primero almacena los punteros inteligentes y el segundo almacena los punteros sin procesar. El primer vector funciona como lo había expuesto, pero vector2 es simplemente confuso ...

Muestra de código

#include <iostream>
#include <vector>
#include <memory>

int main() {
    std::vector<std::shared_ptr<int>> vector1;
    vector1.push_back(std::make_shared<int>(1));
    vector1.push_back(std::make_shared<int>(2));
    vector1.push_back(std::make_shared<int>(3));

    std::vector<int*> vector2;
    vector2.push_back(std::make_shared<int>(4).get());
    vector2.push_back(std::make_shared<int>(5).get());
    vector2.push_back(std::make_shared<int>(6).get());

    std::cout << "vector1 values:" << std::endl;
    for(auto &value: vector1) { std::cout << *value << std::endl; }

    std::cout << "vector2 values:" << std::endl;
    for(auto &value: vector2) { std::cout << *value << std::endl; }

    return 0;
}

Salida

vector1 values:
1
2
3
vector2 values:
6
6
6

Pregunta

Me doy cuenta de que sería mucho más simple crear punteros sin formato para empezar y no tratar de convertirlos, pero me dio curiosidad saber por qué sucede esto. Además, ¿por qué cada pulsación cambia todos los valores en vector2?

Campo de golf

Aquí hay algunas preguntas que encontré en stackoverflow pero no contestaron mi pregunta o tal vez no entendí las respuestas ...

• shared_ptr para un argumento de puntero en bruto
• ¿Hay algún inconveniente con el uso de make_shared para crear un shared_ptr
• C ++ puntero crudo y std :: shared_ptr
• Extraer un puntero en bruto de un shared_ptr

Answer 1

Estás viendo un comportamiento indefinido . Cuando haces esto:

vector2.push_back(std::make_shared<int>(4).get());

Está creando un shared_ptr temporal y está copiando un puntero a su objeto gestionado en su vector . Esto se convierte inmediatamente en un puntero colgante.

Answer 2

La razón por la que usará shared_ptr es que desea que la memoria a la que apunta se libere cuando todas las instancias que apunten a ella queden fuera del alcance. El shared_ptr se destruye justo después de llamar a .get() , por lo que inmediatamente tiene un puntero colgante. El resultado de la operación de desreferenciación no está definido, lo que significa que puede o no devolver un valor que tenga sentido, o incluso podría hacer algo completamente no relacionado (como estrellarse).

Esta es una característica Quiere que esto suceda: de lo contrario, estaría perdiendo memoria. Imagina este código:

vector<int> integers;
integers.push_back(*make_shared<int>(6).get());

Si no se liberó la memoria, no habría forma de liberarla después, porque no hay forma de recuperar el puntero administrado shared_ptr.