std::shared_ptr de cette

Je suis en train d'essayer d'apprendre à utiliser des pointeurs intelligents. Cependant, tout en faisant quelques expériences, j'ai découvert la situation suivante pour laquelle je ne pouvais pas trouver un satisfait de la solution:

Imaginez que vous avez un objet de la classe Un être parent d'un objet de la classe B (l'enfant), mais les deux devraient connaître les uns les autres: 

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 la classe A passer un std::shared_ptr de lui-même (this) à son enfant?

Il existe des solutions pour Stimuler partagé pointeurs (L'obtention d'un boost::shared_ptr par this), mais comment gérer cette aide de la std:: pointeurs intelligents?

  • Comme avec tout autre outil que vous devez utiliser lorsque cela est approprié. À l'aide de pointeurs intelligents pour ce que vous faites n'est pas
  • De même pour la poussée. Voir ici.
  • C'est un problème à ce niveau d'abstraction. Vous ne savez même pas que "ce" indique la mémoire sur le tas.
  • Eh bien, la langue n'a pas, mais vous ne. Tant que vous gardez une trace de ce qui est là, vous serez très bien.
InformationsquelleAutor Icarus | 2012-07-29
  1. 146

    Il est std::enable_shared_from_this juste pour ce but. Vous héritent de celui-ci et vous pouvez appeler .shared_from_this() de l'intérieur de la classe. Vous êtes également à la création de dépendances circulaires ici qui peut conduire à des fuites de ressource. Qui peut être résolu avec l'utilisation de std::weak. Ainsi, votre code peut ressembler à ceci (en supposant que les enfants reposent sur l'existence de la mère 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;
};

    Noter, cependant, que l'appel .shared_from_this() exige que this est détenue par std::shared_ptr au moment de l'appel. Cela signifie que vous ne pouvez pas créer un tel objet sur la pile, et de plus, généralement ne peut pas appeler .shared_from_this() à partir de l'intérieur d'un constructeur ou un destructeur.

    • Merci pour votre explication et pour préciser ma circulaire problème de dépendance.
    • que voulez-vous dire?
    • Essayez de construire une shared_ptr fondée sur un défaut construit shared_ptr et tout ce que vous voulez de point sur le...
    • c'est un, pardon pour mon mauvais jeu de mots, plutôt inutile pointeur partagé. Que le constructeur est destiné à être utilisé avec des pointeurs vers les membres de l'objet géré ou de ses bases. En tout cas, ce qui est votre point de vue (je suis désolé)? Ces non-propriétaire shared_ptrs sont ne sont pas pertinents à cette question. shared_from_this's conditions préalables clairement que l'objet doit être la propriété (pas juste fait) par certains shared_ptr au moment de l'appel.
    • Pourriez-vous donner des précisions sur exactement pourquoi il est impossible d'appeler .shared_from_this() dans le constructeur? Est-ce parce que l'objet n'est pas encore créé au cours de constructeur de l'exécution et de la non-valeur déterminée de this pointeur?
    • La propriété d'une shared_ptrest requis au moment de l'appel, mais dans un schéma d'utilisation standard, c'est à dire quelque chose comme shared_ptr<Foo> p(new Foo());, shared_ptr suppose la possession de l'objet qu'après il est entièrement construit. Il est possible de contourner cette difficulté en créant shared_ptr dans le constructeur d'initialisation avec this et de les stocker quelque part non-locales (par exemple, dans une référence argument) afin de ne pas mourir lorsque constructeur se termine. Mais ce alambiqué scénario est peu probable d'être nécessaire.
    • étant donné que le Parent normalement devrait être la propriété d'Enfants, n'est-il pas source de confusion pour déclarer un weak des enfants dans la classe parent, tandis que les enfants possèdent la propriété(shared_ptr) de la maison mère? alors, à qui appartiennent les enfants?

    InformationsquelleAutor yuri kilochek
  2. 8

    Vous avez plusieurs problèmes dans la conception de, qui semblent provenir de vous incompréhension de pointeurs intelligents.

    Pointeurs intelligents sont utilisés pour déclarer la propriété. Vous êtes à la rupture en déclarant que les deux parents possède tous les enfants, mais aussi que chaque enfant possède ses parents. Les deux ne peut pas être vrai.

    Aussi, vous êtes de retour d'une faible pointeur dans getChild(). Ce faisant, vous déclarez que l'appelant ne se soucient pas de la propriété. Maintenant, cela peut être très limitant, mais aussi en faisant ainsi, vous devez vous assurer que l'enfant en question ne sera pas de la destruction de tout en toute des pointeurs faibles sont toujours détenus, si vous utilisez un pointeur intelligent, il allait rentrer dans l'ordre par lui-même.

    Et la dernière chose. Habituellement, lorsque vous êtes à accepter de nouvelles entités, vous devez généralement accepter raw pointeurs. Pointeur intelligent peuvent avoir leur propre sens de la permutation des enfants entre les parents, mais pour l'usage général, vous devez accepter le fait brut de pointeurs.

    • On dirait que je vraiment besoin de préciser ma compréhension des pointeurs intelligents. Je vous remercie pour cela.
    InformationsquelleAutor Let_Me_Be