C++ 向量<；T*>；析构函数

我有一个类定义如下：

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::~A(void)
{
    for (size_t i=0; i<children.size(); ++i)delete children[i];
}

A:：~A（无效）
{
对于（size_t i=0；i您的析构函数应该是：

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

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

这两篇文章中的一篇可能会帮助你理解：并且你的带参数的构造函数中有一个打字错误-
这个->子->父-/code>不会编译，因为
子-/code>不是指针，
向量-/code>也没有
父-/code>成员。我怀疑你是想使用
这个->父-/code>插件蒂德

析构函数直接调用每个子对象的析构函数，这将销毁子对象，但不会释放其内存。您使用
new
操作符分配子对象，因此需要使用
delete
操作符调用析构函数并正确释放内存

另一方面，您的
num
成员是多余的。您可以在需要
num
的任何位置使用
children.size（）

请尝试以下方法：

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

A类
{ 
私人：
静态常量int默认值_num=3；
公众：
A*父母；
媒介儿童；
... 
//默认构造函数
()
{ 
父项=0；
对于（int i=0；i
旁白：你为什么要选
children.size（）
到
int
，当你可以将循环变量声明为
size\u t
时？如果你使用
向量
，你将不需要这些代码，你的程序将更加健壮。这是一个选项吗？它被称为析构函数，而不是解构函数。我很确定这一行不会编译：
this->children->parent=a；
@larsman：根据您使用的STL实现，
vector:：size\u type
可能没有使用默认分配器的
size\u type
，但可能直接使用
size\t
，或者完全使用其他东西。
A::~A(void)
{
    for (size_t i=0; i < children.size(); ++i)
        delete children[i];
}

{
    A foo;
    B bar = foo;
}

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