std :: shared_ptr de ceci

J'essaie actuellement d'apprendre à utiliser des pointeurs intelligents. Cependant, en faisant quelques expériences, j'ai découvert la situation suivante pour laquelle je ne pouvais pas trouver de solution satisfaisante:

Imaginez que vous ayez un objet de classe A étant parent d'un objet de classe B (l'enfant), mais que les deux devraient se connaître:

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 question est de savoir comment un objet de classe A peut-il passer un std::shared_ptrde lui-même ( this) à son enfant?

Il existe des solutions pour les pointeurs partagés Boost ( Obtenir un boost::shared_ptrforthis ), mais comment gérer cela en utilisant les std::pointeurs intelligents?

Il y a std::enable_shared_from_thisjuste pour cela. Vous en héritez et vous pouvez appeler .shared_from_this()depuis l'intérieur de la classe. De plus, vous créez ici des dépendances circulaires qui peuvent entraîner des fuites de ressources. Cela peut être résolu avec l'utilisation de std::weak_ptr. Donc, votre code pourrait ressembler à ceci (en supposant que les enfants dépendent de l'existence du parent et non l'inverse):

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;
};

Notez cependant que l'appel .shared_from_this()requiert qu'il thisappartienne std::shared_ptrau point d'appel. Cela signifie que vous ne pouvez plus créer un tel objet sur la pile et que vous ne pouvez généralement pas appeler .shared_from_this()depuis un constructeur ou un destructeur.

Vous avez plusieurs problèmes dans votre conception, qui semblent provenir de votre mauvaise compréhension des pointeurs intelligents.

Les pointeurs intelligents sont utilisés pour déclarer la propriété. Vous brisez cela en déclarant que les deux parents possèdent tous les enfants, mais aussi que chaque enfant possède son parent. Les deux ne peuvent pas être vrais.

En outre, vous renvoyez un pointeur faible dans getChild(). Ce faisant, vous déclarez que l'appelant ne devrait pas se soucier de la propriété. Maintenant, cela peut être très limitant, mais aussi ce faisant, vous devez vous assurer que l'enfant en question ne sera pas détruit tant que des pointeurs faibles sont toujours détenus, si vous utilisiez un pointeur intelligent, il serait trié par lui-même .

Et la dernière chose. Habituellement, lorsque vous acceptez de nouvelles entités, vous devez généralement accepter des pointeurs bruts. Le pointeur intelligent peut avoir sa propre signification pour échanger des enfants entre parents, mais pour un usage général, vous devez accepter les pointeurs bruts.