考虑以下代码：
class Foo
{
Monster* monsters[6];
Foo()
{
for (int i = 0; i < 6; i++)
{
monsters[i] = new Monster();
}
}
virtual ~Foo();
}
正确的析构函数是什么？
这个：
Foo::~Foo()
{
delete [] monsters;
}
或者这样：
Foo::~Foo()
{
for (int i = 0; i < 6; i++)
{
delete monsters[i];
}
}
目前我有最上层的构造函数，一切都运行良好，但是当然我看不到是否会有泄漏发生...
个人认为第二个版本更加符合我的需求。无论如何，这个操作的“正确”方式是什么？
delete[] monsters;
monsters不是指向动态分配数组的指针，而是一个指针数组。作为类成员，它将在类实例被销毁时自动销毁。Monster对象。对于 new，应使用 delete。对于 new[]，应使用 delete[]。你的第二个变量是正确的。
#include "stdafx.h"
#include <iostream>
using namespace std;
class A
{
private:
int m_id;
static int count;
public:
A() {count++; m_id = count;}
A(int id) { m_id = id; }
~A() {cout<< "Destructor A " <<m_id<<endl; }
};
int A::count = 0;
void f1()
{
A* arr = new A[10];
//delete operate only one constructor, and crash!
delete arr;
//delete[] arr;
}
int main()
{
f1();
system("PAUSE");
return 0;
}
输出结果为： 析构函数 A 1 然后程序崩溃了（表达式：_BLOCK_TYPE_IS_VALID(phead- nBlockUse)）。
我们需要使用delete[] arr;，因为它删除的是整个数组而不仅仅是一个单元格！
尝试使用delete[] arr; ，输出结果为： 析构函数 A 10 析构函数 A 9 析构函数 A 8 析构函数 A 7 析构函数 A 6 析构函数 A 5 析构函数 A 4 析构函数 A 3 析构函数 A 2 析构函数 A 1
对于指针数组也是同样的原理：
void f2()
{
A** arr = new A*[10];
for(int i = 0; i < 10; i++)
{
arr[i] = new A(i);
}
for(int i = 0; i < 10; i++)
{
delete arr[i];//delete the A object allocations.
}
delete[] arr;//delete the array of pointers
}
如果我们使用 delete arr 而不是 delete[] arr，它将不会删除数组中的所有指针 => 指针对象的内存泄漏！
new或delete，所以你应该只使用：std::vector<Monster> monsters;
delete[] monsters是绝对错误的。我的堆调试器显示以下输出:
allocated non-array memory at 0x3e38f0 (20 bytes)
allocated non-array memory at 0x3e3920 (20 bytes)
allocated non-array memory at 0x3e3950 (20 bytes)
allocated non-array memory at 0x3e3980 (20 bytes)
allocated non-array memory at 0x3e39b0 (20 bytes)
allocated non-array memory at 0x3e39e0 (20 bytes)
releasing array memory at 0x22ff38
如您所见，您试图使用错误的删除形式（非数组 vs. 数组），并且指针0x22ff38从未由new调用返回。第二个版本显示了正确的输出：
[allocations omitted for brevity]
releasing non-array memory at 0x3e38f0
releasing non-array memory at 0x3e3920
releasing non-array memory at 0x3e3950
releasing non-array memory at 0x3e3980
releasing non-array memory at 0x3e39b0
releasing non-array memory at 0x3e39e0
总之，我更喜欢一种设计，在这种设计中，不需要手动实现析构函数。
#include <array>
#include <memory>
class Foo
{
std::array<std::shared_ptr<Monster>, 6> monsters;
Foo()
{
for (int i = 0; i < 6; ++i)
{
monsters[i].reset(new Monster());
}
}
virtual ~Foo()
{
// nothing to do manually
}
};
monsters数组本身，只需删除您创建的各个对象即可。如果你的代码像这样写，那就更合理：
#include <iostream>
using namespace std;
class Monster
{
public:
Monster() { cout << "Monster!" << endl; }
virtual ~Monster() { cout << "Monster Died" << endl; }
};
int main(int argc, const char* argv[])
{
Monster *mon = new Monster[6];
delete [] mon;
return 0;
}