如何使用智能指针防止双重对象删除？

Question

我有一个类拥有它的孩子的所有权：

class Child
{
public:
    Child() {}
    ~Child() {}
};

class Parent : public QObject
{
    Q_OBJECT
public:
    explicit Parent(QObject *parent = 0): QObject(parent) {}
    ~Parent()
    {
        qDeleteAll(m_children);
    }
    void addChild(Child *ch)
    {
        m_children.append(ch);
    }    
private:
    QList<Child *> m_children;    
};

当Parent 被删除时，使用addChild 方法添加到Parent 类的Child 实例将被删除。

以下用法会导致双子销毁：

int main()
{
    {
        Parent father;
        Child child;
        father.addChild( &child );
    }
    //child is out of scope now and gets destroyed
    //father gets destroyed too
    //father's destructor deletes child AGAIN!
    //crash!
    return 0;
}

如何通过使用智能指针来防止这种情况？ QPointer 可用于 QObject 继承的类，这使得它在这种情况下毫无用处。我还能如何防止这种情况发生？

Answer 1

这不是双重破坏。你不能删除堆栈对象。 相反，您应该在堆中分配它：

Parent father;
Child* child = new Child();
father.addChild( child );

Answer 2

如果您查看constructor of QObject，您会注意到它需要一个 QObject 作为父对象，因此不要重新发明轮子，除非您已经在使用它（看起来您没有使用它），您可以使用 Qt 的父子层次结构：-

Parent* parent = new Parent;
Child* Child1 = new Child(parent);

然后您可以根据需要检索父级的children 列表，而不必担心管理子级，因为删除父级时它们会被删除。

如果要在创建后设置孩子的父母，可以调用孩子的setParent函数。

Answer 3

你可以使用std::tr1::shared_pointer here 是一个教程。如果您的编译器中没有该功能，您可以使用boost::shared_pointer，描述为here 您也可以使用implement 您自己的智能指针。

Answer 4

我猜你的第一个问题是关于子元素的所有权。 如果你想让 Parent 类处理 Child 的生命周期，你可以使用智能指针来解决它。

class Parent : public QObject
{
    using ptr = std::shared_ptr<Child>;
    Q_OBJECT
public:
    explicit Parent(QObject *parent = 0): QObject(parent) {}

    void addChild(const ptr& ch)
    {
        m_children.append(ch);
    }    
private:
    QList<ptr> m_children;    
};

然后：

{
    Parent father;
    auto child = std::make_shared<Child>();
    father.addChild( child );
}

如果您想保留实际使用情况，则必须制作副本并存储这些副本。

Answer 5

Parent 拥有 Child 的所有权，而它不应该出现在您的示例中。

可能的解决方案包括：

• Child 应在其析构函数中将其自身从其父级中移除，以防止错误删除。
• 修改Parent接口，明确强制所有权转让：void addChild(std::share_ptr<Child> ch)或void addChild(std::unique_ptr<Child> ch)。
• 在 Parent 中维护 2 个容器，一个有所有权，一个没有所有权。

Answer 6

这是使用 std::shared_ptr 的可能解决方案：

    #include <iostream>
    #include <memory>
    #include <vector>

    class Child
    {
        public:
            Child(std::string name) 
            {
                name_ = name;
            }
            ~Child() 
            {
                std::cout << "~Child: " << name_ << std::endl;  
            }
        private:
            std::string name_;
    };

    class Parent 
    {
        public:

            ~Parent()
            {
                std::cout << "~Parent" << std::endl;    
            }

            void addChild(std::shared_ptr<Child> ch)
            {
                m_children.push_back(ch);
            }    
        private:
            std::vector <std::shared_ptr<Child> >  m_children;    
    };



    int main()
    {

        std::shared_ptr<Child> john (new Child("John")); 
        std::cout << "John created" << std::endl;

        {
            Parent father;

            {
                std::shared_ptr<Child> jack ( new Child("Jack")); 
                std::cout << "Jack created" << std::endl;
                father.addChild( john );
                father.addChild( jack );
                std::cout << "added John and Jack to father" << std::endl;
            }
            std::cout << "jack left scope" << std::endl;
            // jack is out of scope now but since it's a smart pointer 
            // and father still holds a reference to the memory it 
            // referred to that memory is still allocated.
        }
        std::cout << "father left scope" << std::endl;
        // father gets destroyed here and with it its m_children.  
        // As the list goes so does the last reference to the memory 
        // allocated for child and the child gets destroyed.  
        // Note that jack doesn't get destroyed here. Even though it was 
        // one of the children.  The reason is that the orphan smart 
        // pointer is still in scope.

        return 0;

}

注意：这不会让父级控制其子级的生命周期。 Parent 对象可以与 Child 对象相关联，但 Child 对象现在只有在对它的最后一个引用被销毁时才会被销毁。如果其他东西持有指向它的智能指针，就像上面显示的 john 一样，孩子就有可能“存活”其所有父母。如果您的意图是让 Child 只属于一个 Parent 并被其 Parent 破坏，则应将 Child 创建逻辑封装在 Parent 中，以便 Child 对象只能由 Parent 对象创建。