Question

我的课程定义如下：

Class A
{
public:
    int num;
    A *parent;
    vector<A *> children;
    ...

    // constructor without parameters
    A(void)
    {
        this->num = 3;
        this->parent = 0;
        for (int i=0;i<num;++i)
            children.push_back(new A(this,num-1));
    }

    // constructor with parameters
    A(A *a,int n)
    {
        this->num = n;
        this->children->parent = a;
        for (int i=0;i<num;++i)
            this->children.push_back(new A(this,this->num-1));
    }
};

现在，构造函数工作正常。析构函数存在一些问题。目前，析构函数定义为：

A::~A(void)
{
    if (this->parent!=0) this->parent = 0;
    for (int i=0;i<(int)children.size();++i)
        this->children[i]->~A();
    vector <A *> ().swap(this->children);
}

但是每当我调试它时，它都会破坏：

void deallocate(pointer _Ptr, size_type)
    {    // deallocate object at _Ptr, ignore size
    ::operator delete(_Ptr);
    }

看起来我无法删除this-＆gt;孩子的向量中的指针，有没有办法可以成功地解构该类？

Answer 1

你的析构函数应该是：

A::~A(void)
{
    for (size_t i=0; i < children.size(); ++i)
        delete children[i];
}

您可能还应该查看复制构造函数。否则，这样的代码将失败：

{
    A foo;
    B bar = foo;
}

因为你会删除两次相同的指针。

这两篇文章中的一篇可以帮助您理解：1和2

Answer 2

在A的析构函数中，您不应该显式调用子项的析构函数，而只是删除向量的元素。这应该足以满足您的目的：

A::~A(void)
{
    for (size_t i=0; i<children.size(); ++i)delete children[i];
}

Answer 3

带参数的构造函数中有一个拼写错误 - this->children->parent不会编译，因为children不是指针，vector也没有parent成员。我怀疑你打算改用this->parent。

你的析构函数直接调用每个子对象的析构函数，这会破坏孩子但不释放它的记忆。您使用new运算符分配子对象，因此您需要使用delete运算符来调用析构函数并正确释放内存。

在旁注中，您的num成员是多余的。您可以在需要children.size()的任何地方使用num。

请改为尝试：

class A 
{ 
private:
  static const int default_num = 3;

public: 
    A *parent; 
    vector<A *> children; 
    ... 

    // default constructor
    A() 
    { 
        parent = 0; 
        for (int i = 0; i < default_num; ++i) 
            children.push_back(new A(this, default_num-1)); 
    } 

    // constructor with parameters 
    A(A *a, int n) 
    { 
        parent = a; 
        for (int i = 0; i < n; ++i) 
            children.push_back(new A(this, n-1)); 
    } 

    ~A()  
    {  
        parent = 0;  

        for (vector<A *>::size_type i = 0; i < children.size(); ++i)  
            delete children[i];  
        /*
        alternatively:
        for (vector<A *>::iterator i = children.begin(); i != children.end(); ++i)  
            delete *i;  
        */

        children.clear(); // optional, will be handled when vector is implicitally destructed
    }  
};

vector <t * =“”>析构函数</t>

3 个答案: