std :: shared_ptr di questo

Attualmente sto cercando di imparare a utilizzare i puntatori intelligenti. Tuttavia durante alcuni esperimenti ho scoperto la seguente situazione per la quale non sono riuscito a trovare una soluzione soddisfacente:

Immagina di avere un oggetto di classe A che è genitore di un oggetto di classe B (il bambino), ma entrambi dovrebbero conoscersi:

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 domanda è: come può un oggetto di classe A passare un std::shared_ptrdi se stesso ( this) a suo figlio?

Esistono soluzioni per Boost shared pointers ( Getting a boost::shared_ptrforthis ), ma come gestirlo utilizzando i std::puntatori intelligenti?

C'è std::enable_shared_from_thissolo per questo scopo. Tu erediti da esso e puoi chiamare .shared_from_this()dall'interno della classe. Inoltre, qui stai creando dipendenze circolari che possono portare a perdite di risorse. Questo può essere risolto con l'uso di std::weak_ptr. Quindi il tuo codice potrebbe assomigliare a questo (supponendo che i bambini si basino sull'esistenza del genitore e non il contrario):

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

Si noti tuttavia che la chiamata .shared_from_this()richiede che thissia di proprietà di std::shared_ptral punto di chiamata. Ciò significa che non è più possibile creare tale oggetto sullo stack e generalmente non è possibile chiamare .shared_from_this()dall'interno di un costruttore o distruttore.

Hai diversi problemi nella progettazione, che sembrano derivare da una tua incomprensione dei puntatori intelligenti.

I puntatori intelligenti vengono utilizzati per dichiarare la proprietà. Stai rompendo questo dichiarando che entrambi i genitori possiedono tutti i figli, ma anche che ogni bambino possiede il proprio genitore. Entrambi non possono essere veri.

Inoltre, stai restituendo un puntatore debole in getChild(). In questo modo, dichiari che il chiamante non dovrebbe preoccuparsi della proprietà. Ora questo può essere molto limitante, ma anche così facendo, devi assicurarti che il bambino in questione non venga distrutto mentre sono ancora presenti puntatori deboli, se usassi un puntatore intelligente, verrebbe risolto da solo .

E l'ultima cosa. Di solito, quando accetti nuove entità, di solito dovresti accettare puntatori non elaborati. Il puntatore intelligente può avere il proprio significato per lo scambio di figli tra genitori, ma per un utilizzo generale, dovresti accettare i puntatori non elaborati.