podría alguien resumir en pocas palabras cómo se debe utilizar el puntero inteligente boost shared_from_this<>(), particularmente desde la perspectiva de registrar manejadores en el servicio io utilizando la función bind.boost shared_from_this <>()
EDITAR: Algunas de las respuestas han pedido más contexto. Básicamente, estoy buscando "trampas", comportamiento contraintuitivo que la gente ha observado usando este mecanismo.
La "sorpresa" más grande que me he encontrado es que es ilegal llamar shared_from_this del constructor. Esto se sigue directamente de la regla de que debe existir un shared_ptr para el objeto antes de que pueda llamar a shared_from_this.
+1 buen consejo, por lo general hago que mi constructor proporcione y proporcione un método estático 'shared_ptr
Creo que quisiste decir que haces que tu constructor sea privado. –
Según entiendo, algunas veces en su código desea que una clase ofrezca shared_ptr a sí misma para que otras partes de su código puedan obtener shared_ptr's a un objeto de su clase después de que se haya construido.
El problema es que si su clase solo tiene un shared_ptr<> como una variable miembro, nunca se destruirá automáticamente, ya que siempre hay "una última referencia" dando vueltas sobre sí misma. Heredar de enable_shared_from_this le da a su clase un método automático que no solo devuelve un shared_ptr, sino que solo contiene un puntero compartido débil como variable miembro para no afectar el recuento de referencias. De esta forma, su clase será liberada como de costumbre cuando la última referencia a la misma haya desaparecido.
Nunca lo he usado, pero esta es mi comprensión de cómo funciona.
shared_from_this<> se usa si un objeto desea obtener acceso a un shared_ptr<> apuntando a sí mismo.
Normalmente, un objeto solo conoce el puntero implícito this, pero no sobre shared_ptr<> que lo gestiona. Además, this no se puede convertir fácilmente en un shared_ptr<> que comparte la propiedad con otras instancias shared_ptr<> existentes, por lo que no hay una manera fácil para que un objeto obtenga un shared_ptr<> válido a sí mismo.
shared_from_this<> se puede utilizar para resolver este problema. Por ejemplo:
struct A : boost::enable_shared_from_this<A> {
server *io;
// ...
void register_self() {
io->add_client(shared_from_this());
}
};
la documentación boost::asio::io_servicedestructor lo explica bastante bien
La secuencia de destrucción descrita anteriormente permite programas para simplificar su gestión de recursos mediante el uso de shared_ptr <>. Donde curso de la vida de un objeto está ligada a la vida útil de una conexión (o alguna otra secuencia de operaciones asincrónicas), un shared_ptr al objeto se limita en los manipuladores para todos los operaciones asincrónicas asociados con ella. Este funciona como sigue:
- Cuando termina una única conexión, todas las operaciones asincrónicas asociado completa. Se destruyen los objetos correspondientes del manejador , y se destruyen todas las referencias shared_ptr a los objetos .
- Para apagar todo el programa, la función io_service stop() se llama para finalizar cualquier llamada run() tan pronto como sea posible.El destructor io_service definido anteriormente destruye todos los manejadores, causando todas las referencias shared_ptr a destruidos todos los objetos de conexión a .
Típicamente sus objetos serán operaciones asincrónicas de cadena donde los controladores están obligados a funciones miembro utilizando boost::bind y boost::shared_from_this(). Hay algunos examples que usan este concepto.
Su respuesta finalmente me lo explicó como ejemplos ... Particularmente, qué sucede si hay un error en la conexión y el ejemplo del servidor http de asio. – Coyote21
¿Qué es exactamente lo que no entiendes? Es difícil responder una pregunta no dirigida. – GManNickG
La única manera en que podría intentar ilustrar un ejemplo fue pegando en resmas de código, que, siendo código de refuerzo, es lo suficientemente denso como es. –