c++ - std:: shared_ptr de esto

this shared-ptr

Question

Actualmente estoy tratando de aprender a usar punteros inteligentes. Sin embargo, mientras realizaba algunos experimentos, descubrí la siguiente situación para la que no pude encontrar una solución satificante:

Imagina que tienes un objeto de clase A como padre de un objeto de clase B (el hijo), pero ambos deben conocerse:

class A;
class B;
class A
{
public:
void addChild(std::shared_ptr<B> child)
{
children->push_back(child);
// How to do pass the pointer correctly?
// child->setParent(this); // wrong
// ^^^^
}
private:
std::list<std::shared_ptr<B>> children;
};
class B
{
public:
setParent(std::shared_ptr<A> parent)
{
this->parent = parent;
};
private:
std::shared_ptr<A> parent;
};

La pregunta es ¿cómo puede un objeto de la clase A pasar un std::shared_ptr de sí mismo ( this ) a su hijo?

Existen soluciones para los punteros compartidos de Boost ( Obtención de un boost::shared_ptr para this ), pero ¿cómo manejar esto utilizando los punteros std:: smart?

Answer 1

Hay here solo para este propósito. .shared_from_this() de él y puede llamar a .shared_from_this() desde dentro de la clase. También está creando dependencias circulares aquí que pueden conducir a fugas de recursos. Eso se puede resolver con el uso de std::weak_ptr . Por lo tanto, su código podría tener este aspecto (asumiendo que los niños dependen de la existencia del padre y no al revés):

class A;
class B;
class A
: public std::enable_shared_from_this<A>
{
public:
void addChild(std::shared_ptr<B> child)
{
children.push_back(child);
// like this
child->setParent(shared_from_this()); // ok
// ^^^^^^^^^^^^^^^^^^
}
private:
// note weak_ptr
std::list<std::weak_ptr<B>> children;
// ^^^^^^^^
};
class B
{
public:
void setParent(std::shared_ptr<A> parent)
{
this->parent = parent;
}
private:
std::shared_ptr<A> parent;
};

Sin embargo, .shared_from_this() cuenta que llamar a .shared_from_this() requiere que this sea ​​propiedad de std::shared_ptr en el punto de la llamada. Esto significa que ya no puede crear dicho objeto en la pila y, por lo general , no puede llamar a .shared_from_this() desde un constructor o destructor.

Answer 2

Tiene varios problemas en su diseño, que parecen derivarse de su malentendido de los punteros inteligentes.

Los punteros inteligentes se utilizan para declarar la propiedad. Usted está rompiendo esto al declarar que ambos padres son dueños de todos los hijos, pero también que cada niño es su padre. Ambos no pueden ser verdad.

Además, está devolviendo un puntero débil en getChild() . Al hacerlo, está declarando que la persona que llama no debería preocuparse por la propiedad. Ahora esto puede ser muy limitante, pero al hacerlo, debe asegurarse de que el niño en cuestión no se destruya mientras se mantienen los punteros débiles. Si usara un puntero inteligente, se solucionaría solo. .

Y lo último. Por lo general, cuando acepta nuevas entidades, debe aceptar los punteros sin procesar. El puntero inteligente puede tener su propio significado para intercambiar hijos entre padres, pero para uso general, debe aceptar punteros en bruto.