puntero débil a este en el constructor

Question

entiendo que no es posible obtener una shared_ptr llamando shared_from_this() desde el constructor de una clase, como el objeto aún no está construido. ¿Es posible, sin embargo, obtener un weak_ptr para el objeto del constructor? Algunos comentarios en el foro sobre el método "weak_from_raw()" sugieren que puede ser posible.

Editar: Boost forma de discutir weak_from_raw http://lists.boost.org/boost-users/2010/08/61541.php

Answer 1

creo que lo que está haciendo referencia is this. Lo cual parece no haberse fusionado con la versión de refuerzo (puede estar equivocado al respecto).

Desde el boost docs:

Preguntas frecuentes

P. ¿Puede un objeto crear un weak_ptr a sí mismo en su constructor?

A. No. Un weak_ptr solo se puede crear desde un shared_ptr, y en el momento de la construcción del objeto aún no existe shared_ptr para el objeto. Incluso si pudieras crear un shared_ptr temporal para esto, saldría del alcance al final del constructor, y todas las instancias de weak_ptr caducarían instantáneamente.

La solución es hacer que el constructor privado, y suministrar una función fábrica que devuelve un shared_ptr:

class X 
{ 
private: 

    X(); 

public: 

    static shared_ptr<X> create() 
    { 
     shared_ptr<X> px(new X); 
     // create weak pointers from px here 
     return px; 
    } 
}; 

Answer 2

Ver: http://boost.org/doc/libs/1_42_0/libs/smart_ptr/sp_techniques.html#in_constructor

El problema no es que el objeto no se construye. El problema es que shared_ptr no se ha construido. Si todo lo que hiciera sería crear un shared_ptr y enviarlo a algún lado, todo estaría bien. Es cuando intentas crear un shared_ptr para contener el objeto que acabas de crear. No hay forma de conectar los dos y, por lo tanto, tienes un gran problema.

La forma en que shared_from_this funciona es que espera que pongas el objeto es un shared_ptr antes de llamar a shared_from_this para obtener acceso a él. Como todavía no lo ha hecho, dado que el constructor del objeto no ha terminado y, por lo tanto, shared_ptr no está conectado a él, no puede llamar a shared_from_this.

usted tendría exactamente el mismo problema con el weak_ptr.

tanto, en otras palabras, esta absurda construcción funcionaría:

struct absurd 
{ 
    absurd() 
    { 
    register(shared_ptr<absurd>(this)); 
    } 
}; 

... 
new absurd; // better not assign to a shared_ptr!!! 

Pero realmente no quiero hacer esto.