std::shared_ptr<T>:: shared_ptr

Construye un nuevo shared_ptr a partir de varios tipos de punteros que referencian un objeto a gestionar.

Cuando T no es un tipo de arreglo, las sobrecargas (3,4,6) habilitan shared_from_this con ptr , y la sobrecarga (13) habilita shared_from_this con el puntero devuelto por r. release ( ) .

Parámetros

Postcondiciones

Excepciones

Notas

Un constructor habilita shared_from_this con un puntero ptr de tipo U* significa que determina si U tiene una clase base inequívoca y accesible (desde C++17) que sea una especialización de std::enable_shared_from_this , y si es así, el constructor evalúa if ( ptr ! = nullptr && ptr - > weak_this  . expired ( ) )
ptr - > weak_this = std:: shared_ptr < std:: remove_cv_t < U >>
( * this, const_cast < std:: remove_cv_t < U > * > ( ptr ) ) ; .

La asignación a weak_this no es atómica y entra en conflicto con cualquier acceso potencialmente concurrente al mismo objeto. Esto garantiza que futuras llamadas a shared_from_this() compartirían la propiedad con el std::shared_ptr creado por este constructor de puntero en bruto.

La prueba ptr - > weak_this  . expired ( ) en el código anterior asegura que weak_this no sea reasignado si ya indica un propietario. Esta prueba es requerida a partir de C++17.

Las sobrecargas de puntero crudo asumen la propiedad del objeto apuntado. Por lo tanto, construir un shared_ptr usando la sobrecarga de puntero crudo para un objeto que ya está gestionado por un shared_ptr , como por shared_ptr ( ptr. get ( ) ) probablemente conducirá a comportamiento indefinido, incluso si el objeto es de un tipo derivado de std::enable_shared_from_this .

Debido a que el constructor por defecto es constexpr , los shared_ptrs estáticos se inicializan como parte de la inicialización no-local estática , antes de que comience cualquier inicialización no-local dinámica. Esto hace seguro usar un shared_ptr en el constructor de cualquier objeto estático.

En C++11 y C++14 es válido construir un std:: shared_ptr < T > a partir de un std:: unique_ptr < T [ ] > :

std::unique_ptr<int[]> arr(new int[1]);
std::shared_ptr<int> ptr(std::move(arr));

Dado que el shared_ptr obtiene su eliminador (un objeto std:: default_delete < T [ ] > ) del std::unique_ptr , el array será correctamente desasignado.

Esto ya no está permitido en C++17. En su lugar, debería usarse la forma de array std:: shared_ptr < T [ ] > .

Ejemplo

#include <iostream>
#include <memory>
struct Foo
{
    int id{0};
    Foo(int i = 0) : id{i} { std::cout << "Foo::Foo(" << i <<  ")\n"; }
    ~Foo() { std::cout << "Foo::~Foo(), id=" << id << '\n'; }
};
struct D
{
    void operator()(Foo* p) const
    {
        std::cout << "Call delete from function object. Foo::id=" << p->id << '\n';
        delete p;
    }
};
int main()
{
    {
        std::cout << "1) constructor with no managed object\n";
        std::shared_ptr<Foo> sh1;
    }
    {
        std::cout << "2) constructor with object\n";
        std::shared_ptr<Foo> sh2(new Foo{10});
        std::cout << "sh2.use_count(): " << sh2.use_count() << '\n';
        std::shared_ptr<Foo> sh3(sh2);
        std::cout << "sh2.use_count(): " << sh2.use_count() << '\n';
        std::cout << "sh3.use_count(): " << sh3.use_count() << '\n';
    }
    {
        std::cout << "3) constructor with object and deleter\n";
        std::shared_ptr<Foo> sh4(new Foo{11}, D());
        std::shared_ptr<Foo> sh5(new Foo{12}, [](auto p)
        {
            std::cout << "Call delete from lambda... p->id=" << p->id << '\n';
            delete p;
        });
    }
}

1) constructor with no managed object
2) constructor with object
Foo::Foo(10)
sh2.use_count(): 1
sh2.use_count(): 2
sh3.use_count(): 2
Foo::~Foo(), id=10
3) constructor with object and deleter
Foo::Foo(11)
Foo::Foo(12)
Call delete from lambda... p->id=12
Foo::~Foo(), id=12
Call delete from function object. Foo::id=11
Foo::~Foo(), id=11

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también