std::make_shared, std::make_shared_for_overwrite

En cada caso, el objeto (o elementos individuales si T es un tipo array) (desde C++20) se destruirá por p->~X(), donde p es un puntero al objeto y X es su tipo.

[editar] Parámetros

[editar] Valor de retorno

std::shared_ptr de una instancia de tipo T.

[editar] Excepciones

Puede lanzar std::bad_alloc o cualquier excepción lanzada por el constructor de T. Si se lanza una excepción, las funciones no tienen efecto. Si se lanza una excepción durante la construcción de del array, los elementos ya inicializados se destruyen en orden inverso. (desde C++20)

[editar] Notas

Esta función se puede utilizar como alternativa a std::shared_ptr<T>(new T(args...)). Las compensaciones son:

• std::shared_ptr<T>(new T(args...)) realiza al menos dos asignaciones de memoria (uno para el objeto T y otra para el bloque de control del puntero compartido), mientras que std::make_shared<T> generalmente realiza solo una asignación (el estándar recomienda, pero no requiere esto; todas las implementaciones conocidas hacen esto).
• Si algún std::weak_ptr hace referencia al bloque de control creado por std::make_shared después de que finalizó el tiempo de vida de todos los propietarios compartidos, la memoria ocupada por T persiste hasta todos los propietarios débiles también son destruidos, lo que puede ser indeseable si sizeof(T) es grande.
• std::shared_ptr<T>(new T(args...)) puede llamar a un constructor no público de T si se ejecuta en un contexto donde es accesible, mientras que std::make_shared requiere acceso público al constructor seleccionado.
• A diferencia de los constructores de std::shared_ptr, std::make_shared no permite un eliminador personalizado.
• std::make_shared usa ::new, por lo que si se ha configurado algún comportamiento especial usando un operator new específico de la clase, diferirá de std::shared_ptr<T>(new T(args...)).

Cuando se dice que un constructor habilita shared_from_this con un puntero ptr de tipo U*, significa que determina si U tiene una clase base no ambigua y accesible (desde C++17) que es una especialización de std::enable_shared_from_this, y si es así, el constructor evalúa la declaración:

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));

Donde weak_this es el miembro std::weak_ptr mutable oculto de std::enable_shared_from_this. La asignación al miembro weak_this no es atómica y entra en conflicto con cualquier acceso potencialmente concurrente al mismo objeto. Esto garantiza que las llamadas futuras a shared_from_this() compartirán la posesión con el std::shared_ptr creado por este constructor de puntero sin formato.

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

[editar] Ejemplo

#include <memory>
#include <vector>
#include <iostream>
#include <type_traits>
 
struct C
{
    // constructores necesarios (hasta C++20)
    C(int i) : i(i) {}
    C(int i, float f) : i(i), f(f) {}
    int i;
    float f{};
};
 
int main()
{
    // usando `auto` para el tipo de `sp1`
    auto sp1 = std::make_shared<C>(1); // sobrecarga (1)
    static_assert(std::is_same_v<decltype(sp1), std::shared_ptr<C>>);
    std::cout << "sp1->{ i:" << sp1->i << ", f:" << sp1->f << " }\n";
 
    // siendo explícito con el tipo de `sp2`
    std::shared_ptr<C> sp2 = std::make_shared<C>(2, 3.0f); // sobrecarga (1)
    static_assert(std::is_same_v<decltype(sp2), std::shared_ptr<C>>);
    static_assert(std::is_same_v<decltype(sp1), decltype(sp2)>);
    std::cout << "sp2->{ i:" << sp2->i << ", f:" << sp2->f << " }\n";
 
 
    // véase https://wandbox.org/permlink/wVZT5Gl2omZrhxte
 
    // shared_ptr a un float[64] inicializado por valor; sobrecarga (2):
    std::shared_ptr<float[]> sp3 = std::make_shared<float[]>(64);
 
    // shared_ptr a un long[5][3][4] inicializado por valor; sobrecarga (2):
    std::shared_ptr<long[][3][4]> sp4 = std::make_shared<long[][3][4]>(5);
 
    // shared_ptr a un short[128] inicializado por valor; sobrecarga (3):
    std::shared_ptr<short[128]> sp5 = std::make_shared<short[128]>();
 
    // shared_ptr a un int[7][6][5] inicializado por valor; sobrecarga (3):
    std::shared_ptr<int[7][6][5]> sp6 = std::make_shared<int[7][6][5]>();
 
    // shared_ptr a un double[256], donde cada elemento es 2.0; sobrecarga (4):
    std::shared_ptr<double[]> sp7 = std::make_shared<double[]>(256, 2.0);
 
    // shared_ptr a un double[7][2], donde cada elemento double[2] es {3.0, 4.0}; sobrecarga (4):
    std::shared_ptr<double[][2]> sp8 = std::make_shared<double[][2]>(7, {3.0, 4.0});
 
    // shared_ptr a un vector<int>[4], donde cada vector tiene el contenido {5, 6}; sobrecarga (4):
    std::shared_ptr<std::vector<int>[]> sp9 = std::make_shared<std::vector<int>[]>(4, {5, 6});
 
    // shared_ptr a un float[512], donde cada elemento es 1.0; sobrecarga (5):
    std::shared_ptr<float[512]> spA = std::make_shared<float[512]>(1.0);
 
    // shared_ptr a un double[6][2], donde cada elemento double[2] es {1.0, 2.0}; sobrecarga (5):
    std::shared_ptr<double[6][2]> spB = std::make_shared<double[6][2]>({1.0, 2.0});
 
    // shared_ptr a un vector<int>[4], donde cada vector tiene el contenido {5, 6}; sobrecarga (5):
    std::shared_ptr<std::vector<int>[4]> spC = std::make_shared<std::vector<int>[4]>({5, 6});
}

sp1->{ i:1, f:0 }
sp2->{ i:2, f:3 }

[editar] Véase también