¿Por qué un puntero inteligente no puede llamar a new() para mí en su constructor?

Question

¿Es posible escribir un puntero inteligente que asigne el objeto en sí mismo en su constructor, en lugar de que el desarrollador tenga que llamar al new? En otras palabras, en lugar de escribir:

std::unique_ptr<myClass> my_ptr(new myClass(arg1, arg2))

... uno podría escribir:

std::smarter_ptr<myClass> my_ptr(arg1, arg2)

Es la sintaxis del lenguaje capaz de expresar esto? ¿Sería esto deseable? ¿Horrible? Estoy pensando en particular en la protección contra este error (que me he hecho a mí mismo, por supuesto):

myFunction(std::unique_ptr<myClass>(new myClass()), std::unique_ptr<myClass>(new myClass()))

... que corre el riesgo fugas que sea objeto se asigna en primer lugar si la segunda asignación pasa y lanza antes de que el primer objeto esté instalado de forma segura en su puntero inteligente. Pero, ¿un puntero más inteligente realmente lo haría seguro?

Answer 1

Mire la implementación de make_shared(). Esto asigna un nuevo objeto y crea un shared_ptr.

Answer 2

Esto es nuevamente posible con C++ 11 que agregó perfect forwarding y plantillas variadic.

Answer 3

Es esencialmente el mismo problema que necesita std::find y std::find_if. No puede distinguir este cursor de los ctors existentes de shared_ptr en el caso new myClass(arg1). La cantidad de argumentos es igual, y arg1 puede tener cualquier tipo.

Por lo tanto, se necesita otro nombre, y eso es make_shared

Answer 4

En general, esto no se puede hacer con el constructor de un puntero inteligente; habría una ambigüedad sobre si un argumento de puntero debería usarse para inicializar el puntero inteligente, o reenviarse para crear un nuevo objeto.

Se puede hacer con una función de fábrica, por ejemplo:

template <typename T, typename... Args> 
std::unique_ptr<T> make_unique(Args&&... args) { 
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); 
} 

Si está utilizando std::shared_ptr, entonces se puede utilizar std::make_shared. Esto también ofrece la ventaja de que solo requiere una asignación de memoria, donde std::shared_ptr<T>(new T) requerirá una para el objeto y una segunda para el recuento de referencia compartida.