我應該如何構建一個用std :: shared_ptr進行管理的實例？

Question

考慮以下父/子對象模型。父母和孩子的意圖是使用shared_ptr來管理他們的一生。父母應保留shared_ptr（保留）其子女，並且子女將保留weak_ptr給父母。

鑑於這些對象的意圖總是由std::shared_ptr來管理，構建它們的最佳方式是什麼？我想到的方法（到目前爲止）感覺有點笨拙：我使用工廠（朋友）函數和一個私有構造函數來減少指向這些對象的原始指針「逃逸」的可能性。然後，孩子在ctor中創建shared_ptr和this，並將其放入父母的vector兒童中。當ctor將原始指針返回到工廠函數時，工廠函數使用shared_from_this()來獲得shared_ptr，該shared_ptr與子級的父代向量中的shared_ptr「掛鉤到」（即共享引用計數）。

下面是我想出迄今：

class Child; // Forward decl 

class Parent : std::enable_shared_from_this<Parent> { 
public:     
    int value() const { return _value; }; 
    void set_value(int newValue) { _value = newValue; }; 

    std::vector<std::shared_ptr<const Child>> children() const { 
     // propagate const-ness to the child pointers we hand back. 
     return std::vector<std::shared_ptr<const Child>>(begin(_children), end(_children)); 
    }; 

    std::vector<std::shared_ptr<Child>> children() { 
     return _children; 
    }; 

private: 

    Parent(int value) : _value(value) {}; 

    friend class Child; // So it can add itself to the _children vector 
    friend class std::shared_ptr<Parent>; // So that I don't have to inherit public from enable_shared_from_this 
    friend std::shared_ptr<Parent> CreateParent(int value); // So it can call the private ctor 

    std::vector<std::shared_ptr<Child>> _children; 
    int _value; 
}; 

class Child : std::enable_shared_from_this<Child> 
{ 
public: 
    int value() const { return _value; }; 
    void set_value(int newValue) { _value = newValue; }; 

private: 
    Child(const std::shared_ptr<Parent>& parent, int value) : _parent(parent), _value(value) { 
     std::shared_ptr<Child> sp(this); // This feels wrong, but the existence of the shared_ptr in the parent's vector of children ensures that the precondition for calling shared_from_this() is met 
     parent->_children.push_back(sp); 
    }; 

    friend std::shared_ptr<Child> CreateChild(const std::shared_ptr<Parent>& parent, int value); // So it cal call the private ctor 
    friend class std::shared_ptr<Child>; // So that I don't have to inherit public from enable_shared_from_this 

    std::weak_ptr<Parent> _parent; 
    int _value; 
}; 

std::shared_ptr<Parent> CreateParent(int value) { 
    return std::shared_ptr<Parent>(new Parent(value)); 
}; 

std::shared_ptr<Child> CreateChild(const std::shared_ptr<Parent>& parent, int value) { 
    std::shared_ptr<Child> rv = (new Child(parent, value))->shared_from_this(); 
    return rv; 
}; 

這似乎是工作，而人，是什麼感覺笨重。有沒有更好的辦法？

Answer 1

我會做這種方式：

class Child; 

class Parent { 
public: 
    std::vector<const Child*> children() const { 
     // propagate const-ness to the child pointers we hand back. 
     // ... 
    } 

    const std::vector<std::unique_ptr<Child>>& children() { 
     return _children; 
    } 

    std::shared_ptr<Parent> create() { 
     // I'd rather use std::make_shared() here but it needs public ctor 
     return std::shared_ptr<Parent>(new Parent()); 
    } 

    std::unique_ptr<Child>& createChild() { 
     _children.emplace_back(new Child(this)); 
     return _children.back(); 
    } 

private:  
    Parent(); 

    std::vector<std::unique_ptr<Child>> _children; 
}; 

class Child 
{ 
private: 
    Child(Parent* parent) : _parent(parent) {} 

    friend class Parent; 

    Parent* _parent; 
}; 

我剝出爲清楚起見，「價值」的樣板。我也嘗試使用智能指針的最低級複雜程度，似乎可行的完成工作。我可能沒有把它完全用於你的具體用例，但你應該考慮更明確定義的生命週期/所有權語義。讓所有東西分享一切都是一團糟，導致缺乏清晰度......擁有清晰的所有權可以讓事情變得更簡單。而且由於Parent類仍然管理着每個Child的生命週期，所以不需要從Child返回到Parent的奇特指針 - 原始指針將起作用，因爲Child不會超過Parent。

Answer 2

鑑於你的父母/子女管理的不舒服分裂的描述，可以簡化如下，

class Child; 

class Parent { 
private: 
    Parent() {}; 
    friend std::shared_ptr<Child> CreateChild(const std::shared_ptr<Parent>& parent); 
    std::vector<std::shared_ptr<Child>> _children; 
}; 

class Child { 
private: 
    Child(const std::shared_ptr<Parent>& parent) : _parent(parent) {}; 
    friend std::shared_ptr<Child> CreateChild(const std::shared_ptr<Parent>& parent); 
    std::weak_ptr<Parent> _parent; 
}; 

std::shared_ptr<Child> CreateChild(const std::shared_ptr<Parent>& parent) { 
    auto child = std::shared_ptr<Child>(new Child(parent)); 
    parent->_children.push_back(child); 
    return child; 
} 

還要注意，這裏沒有shared_from_this，也許有必要對您的其他用途，但沒有必要管理親子關係。