2

我有一个定义如下的类：

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->children 向量中的指针，有什么方法可以成功解构类吗？

4

3 回答 3

5

你的析构函数应该是：

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

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

{
    A foo;
    B bar = foo;
}

因为您将两次删除相同的指针。

这两个帖子之一可以帮助您理解：1和2

于 2012-06-01T15:28:17.900 回答
1

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

A::~A(void)
{
    for (size_t i=0; i<children.size(); ++i)delete children[i];
}
于 2012-06-01T15:27:39.777 回答
0

您的带参数的构造函数中有一个错字错误 -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
    }  
};
于 2012-06-01T19:10:51.317 回答