¿Cuál es la utilidad de `enable_shared_from_this`?

Question

Me encontré con enable_shared_from_this mientras leía los ejemplos de Boost.Asio y después de leer la documentación todavía estoy perdido por cómo debería usarse correctamente. ¿Puede alguien darme un ejemplo y/o una explicación de cuando usar esta clase tiene sentido?

Answer 1

Le permite obtener una instancia shared_ptr válida a this, cuando todo lo que tiene es this. Sin él, no habría manera de obtener un shared_ptr a this, a menos que ya tenga uno como miembro. Este ejemplo de la boost documentation for enable_shared_from_this:

class Y: public enable_shared_from_this<Y> 
{ 
public: 

    shared_ptr<Y> f() 
    { 
     return shared_from_this(); 
    } 
} 

int main() 
{ 
    shared_ptr<Y> p(new Y); 
    shared_ptr<Y> q = p->f(); 
    assert(p == q); 
    assert(!(p < q || q < p)); // p and q must share ownership 
} 

El método f() devuelve un válido shared_ptr, a pesar de que no tenía ejemplo miembro. Tenga en cuenta que no se puede simplemente hacer esto:

class Y: public enable_shared_from_this<Y> 
{ 
public: 

    shared_ptr<Y> f() 
    { 
     return shared_ptr<Y>(this); 
    } 
} 

El puntero compartida que esta vuelto tendrá un contador de referencia diferente de la "correcta" uno, y uno de ellos va a terminar perdiendo y la celebración de una referencia colgando cuando el objeto esta borrado.

enable_shared_from_this va a formar parte del nuevo estándar C++ 0x también, por lo que también puede obtenerlo desde allí o desde el impulso.

Answer 2

Otra forma es agregar un miembro weak_ptr<Y> m_stub en class Y. A continuación, escriba:

shared_ptr<Y> Y::f() 
{ 
    return m_stub.lock(); 
} 

útil cuando no se puede cambiar la clase va a derivar a partir de (por ejemplo, extender la biblioteca de otras personas). No olvide inicializar al miembro, p. por m_stub = shared_ptr<Y>(this), es válido incluso durante un constructor.

Está bien si hay más trozos como este en la jerarquía de herencia, no impedirá la destrucción del objeto.

Editar: Como señala correctamente el usuario nobar, el código destruiría el objeto Y cuando se termine la asignación y se destruyan las variables temporales. Por lo tanto, mi respuesta es incorrecta.

Answer 3

del artículo Dr. Dobbs sobre los punteros débiles, creo que este ejemplo es más fácil de entender (fuente: http://drdobbs.com/cpp/184402026):

... código como este no funcionará correctamente:

int *ip = new int; 
shared_ptr<int> sp1(ip); 
shared_ptr<int> sp2(ip); 

Ni de los dos objetos shared_ptr sabe sobre el otro, por lo que ambos intentarán liberar el recurso cuando se destruyan. Eso usualmente lleva a problemas.

Del mismo modo, si una función miembro necesita un objeto shared_ptr que posee el objeto que está siendo llamado en adelante, puede no sólo crear un objeto sobre la marcha:

struct S 
{ 
    shared_ptr<S> dangerous() 
    { 
    return shared_ptr<S>(this); // don't do this! 
    } 
}; 

int main() 
{ 
    shared_ptr<S> sp1(new S); 
    shared_ptr<S> sp2 = sp1->dangerous(); 
    return 0; 
} 

Este código tiene el mismo problema que el ejemplo anterior, aunque en una forma más sutil. Cuando se construye, el objeto shared_pt r sp1 posee el recurso recientemente asignado. El código dentro de la función de miembro S::dangerous no conoce el objeto shared_ptr, por lo que el objeto shared_ptr que devuelve es distinto de sp1.Copiar el nuevo objeto shared_ptr al sp2 no ayuda; cuando sp2 sale del alcance, liberará el recurso, y cuando sp1 quede fuera del alcance, liberará el recurso nuevamente.

La forma de evitar este problema es utilizar la plantilla de clase enable_shared_from_this. La plantilla toma un argumento de tipo de plantilla, que es el nombre de la clase que define el recurso administrado. Esa clase debe, a su vez, derivarse públicamente de la plantilla; de esta manera:

struct S : enable_shared_from_this<S> 
{ 
    shared_ptr<S> not_dangerous() 
    { 
    return shared_from_this(); 
    } 
}; 

int main() 
{ 
    shared_ptr<S> sp1(new S); 
    shared_ptr<S> sp2 = sp1->not_dangerous(); 
    return 0; 
} 

Al hacer esto, tenga en cuenta que el objeto sobre el que se llama a shared_from_this debe ser propiedad de un objeto shared_ptr. Esto no funcionará:

int main() 
{ 
    S *p = new S; 
    shared_ptr<S> sp2 = p->not_dangerous();  // don't do this 
} 

Answer 4

Tenga en cuenta que el uso de boost :: intrusive_ptr no presenta este problema. Esta es a menudo una forma más conveniente de evitar este problema.

Answer 5

Aquí está mi explicación, desde una perspectiva de tuercas y tornillos (la respuesta superior no hizo 'clic' conmigo). * Tenga en cuenta que este es el resultado de la investigación de la fuente de shared_ptr y enable_shared_from_this que viene con Visual Studio 2012. Tal vez otros compiladores implementan enable_shared_from_this diferente ... *

enable_shared_from_this<T> añade un weak_ptr<T> instancia privada a T que mantiene el 'uno verdadero recuento de referencia 'para la instancia de T.

Por lo tanto, cuando se crea un shared_ptr<T> en una nueva T *, que weak_ptr interna T * 's se inicializa con un refcount de 1. El nuevo shared_ptr respalda básicamente en este weak_ptr.

T puede entonces, en sus métodos, llamar shared_from_this para obtener una instancia de shared_ptr<T> que mete hacia el mismo número de referencia almacenada internamente. De esta manera, siempre tiene un lugar donde se almacena el ref-count de T* en lugar de tener múltiples instancias de shared_ptr que no se conocen entre sí, y cada una cree que son shared_ptr que se encargan del conteo de ref T y borran cuando su recuento de ref llega a cero.

Answer 6

Es exactamente lo mismo en C++ 11 y posterior: es para habilitar la capacidad de devolver this como un puntero compartido ya que this le da un puntero sin formato.

en otras palabras, que le permita activar un código como éste

class Node { 
public: 
    Node* getParent const() { 
     if (m_parent) { 
      return m_parent; 
     } else { 
      return this; 
     } 
    } 

private: 

    Node * m_parent = nullptr; 
};   

en esto:

class Node : std::enable_shared_from_this<Node> { 
public: 
    std::shared_ptr<Node> getParent const() { 
     std::shared_ptr<Node> parent = m_parent.lock(); 
     if (parent) { 
      return parent; 
     } else { 
      return shared_from_this(); 
     } 
    } 

private: 

    std::weak_ptr<Node> m_parent; 
};