std:: allocate_shared, std:: allocate_shared_for_overwrite

Asigna memoria para un objeto utilizando una copia de alloc (reconfigurado para un value_type no especificado) e inicializa el objeto con los argumentos proporcionados. Retorna un objeto std::shared_ptr que gestiona el objeto recién creado.

Parámetros

Valor de retorno

std::shared_ptr a un objeto de tipo T o std:: remove_extent_t < T > [ N ] si T es un tipo de array sin límite (desde C++20) .

Para el std::shared_ptr r devuelto, r. get ( ) retorna un puntero no nulo y r. use_count ( ) retorna 1 .

Excepciones

Puede lanzar las excepciones lanzadas desde Alloc :: allocate ( ) o desde el constructor de T . Si se lanza una excepción, (1) no tiene efecto. Si se lanza una excepción durante la construcción del array, los elementos ya inicializados se destruyen en orden inverso (since C++20) .

Notas

Estas funciones normalmente asignarán más memoria que sizeof ( T ) para permitir estructuras internas de contabilidad como conteos de referencia.

Al igual que std::make_shared , esta función normalmente realiza solo una asignación, y coloca tanto el objeto T como el bloque de control en el bloque de memoria asignado (el estándar recomienda pero no requiere esto, todas las implementaciones conocidas lo hacen). Una copia de alloc se almacena como parte del bloque de control para que pueda usarse para desasignarlo una vez que tanto los contadores de referencia compartidos como débiles lleguen a cero.

A diferencia de los std::shared_ptr constructors , std::allocate_shared no acepta un deleter personalizado separado: el asignador proporcionado se utiliza para la destrucción del bloque de control y del objeto T , y para la desasignación de su bloque de memoria compartida.

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 concurrente potencial 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.

Ejemplo

#include <cstddef>
#include <iostream>
#include <memory>
#include <memory_resource>
#include <vector>
class Value
{
    int i;
public:
    Value(int i) : i(i) { std::cout << "Value(), i = " << i << '\n'; }
    ~Value() { std::cout << "~Value(), i = " << i << '\n'; }
    void print() const { std::cout << "i = " << i << '\n'; }
};
int main()
{
    // Crear un asignador polimórfico usando el recurso de búfer monótono
    std::byte buffer[sizeof(Value) * 8];
    std::pmr::monotonic_buffer_resource resource(buffer, sizeof(buffer));
    std::pmr::polymorphic_allocator<Value> allocator(&resource);
    std::vector<std::shared_ptr<Value>> v;
    for (int i{}; i != 4; ++i)
        // Usar std::allocate_shared con el asignador personalizado
        v.emplace_back(std::allocate_shared<Value>(allocator, i));
    for (const auto& sp : v)
        sp->print();
} //< Todos los shared pointers limpiarán automáticamente cuando salgan del ámbito.

Value(), i = 0
Value(), i = 1
Value(), i = 2
Value(), i = 3
i = 0
i = 1
i = 2
i = 3
~Value(), i = 0
~Value(), i = 1
~Value(), i = 2
~Value(), i = 3

Informes de defectos

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

Véase también