Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::make_shared — crear un objeto con propiedad compartida

std::make_shared crea un objeto y devuelve un std::shared_ptr que lo administra. Si el tipo no es un array, reenvía los argumentos para inicializar el objeto. Las copias del puntero comparten el mismo objeto y la responsabilidad de su ciclo de vida.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <memory>

// Non-array overload in C++23:
template<class T, class... Args>
std::shared_ptr<T> make_shared(Args&&... args);

// Usage:
auto p = std::make_shared<T>(args...);

std::make_shared<T>(args...), declarado en <memory>, crea un objeto y devuelve un std::shared_ptr<T>. Si el tipo no es un array, la función inicializa directamente un objeto de tipo T mediante T(std::forward<Args>(args)...). En C++23, esto no implica necesariamente llamar a un constructor: también permite inicializar escalares y, cuando es válido, inicializar agregados con paréntesis. Tras una llamada correcta, use_count() vale 1. También existen sobrecargas para arrays: por ejemplo, std::make_shared<int[]>(3) crea tres elementos con valor 0.

Al copiar un std::shared_ptr, se comparte el objeto en lugar de copiarlo. Destruir una copia reduce el número de propietarios; el objeto se destruye cuando el último propietario renuncia a la propiedad. En el ejemplo, second modifica el mismo Counter al que apunta first. Cuando termina el bloque interno, el número de propietarios baja de 2 a 1.

El estándar recomienda como máximo una asignación de memoria, pero no la garantiza. Si la asignación de memoria o un constructor lanza una excepción, no se produce una fuga de memoria asociada al objeto que se estaba creando. La función no acepta un eliminador personalizado. Si la inicialización llama a un constructor, este debe ser accesible desde el contexto de la biblioteca, no solo desde el punto de llamada.

Esta entrada se refiere a C++23. El documento enlazado es un borrador de trabajo en evolución y puede incluir cambios posteriores; la sintaxis mostrada omite constexpr deliberadamente. Una opción del compilador en el repositorio no acredita el entorno de producción.

Ejemplos

#include <iostream>
#include <memory>

struct Counter {
    int value;
    explicit Counter(int initial) : value(initial) {}
};

int main() {
    auto first = std::make_shared<Counter>(7);
    {
        auto second = first;
        ++second->value;
        std::cout << first->value << ' ' << first.use_count() << '\n';
    }
    std::cout << first->value << ' ' << first.use_count() << '\n';
}

Resultado

8 2
8 1

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes