C++规范说明默认析构函数会删除所有非静态成员。然而，我无法实现这一点。
下面是我的代码：
class N {
public:
~N() {
std::cout << "Destroying object of type N";
}
};
class M {
public:
M() {
n = new N;
}
// ~M() { //this should happen by default
// delete n;
// }
private:
N* n;
};
接下来这段代码本应该打印指定的消息，但实际上并没有：
M* m = new M();
delete m; //this should invoke the default destructor
{
Thing* t = new Thing;
// do some stuff here
// no "delete t;"
}
t指针被清理了，但它所指向的Thing没有被清理，这就是一个内存泄漏。在你的类中也发生了类似的事情。
Thing应该仍然被销毁吗？ - Raphaël Saint-Pierre想象一下这样的情况：
class M {
public:
M() { }
// ~M() { // If this happens by default
// delete n; // then this will delete an arbitrary pointer!
// }
private:
N* n;
};
在C++中，指针需要自行管理内存释放，没有任何自动的机制会帮你删除它们。
默认的析构函数将会销毁所有成员对象。但是在这种情况下成员对象是指针本身而不是指向的实际对象，这可能会让你感到困惑。
然而，如果你使用智能指针而不是简单的原始指针，这种“指针”（实际上是一个类）的销毁可能会触发指向的对象的销毁。
当指向的对象似乎属于包含的对象时，您为什么要使用指针？只需按值存储对象：
class M
{
N n;
public:
M() : n()
{
}
};
错误的说法是析构函数会 删除 成员。它会调用每个成员（和基类）的析构函数，而对于内置类型（如指针），这意味着什么也不做。
匹配 new 和 delete 是你的责任（可以手动完成，也可以使用智能指针协助完成）。
你的论点听起来很有道理，但对于指针来说并不是这样工作的。
n 实际上正在被销毁，但这意味着 N* 的析构函数被调用了，它并没有销毁 n 指向的任何对象。将 N* 的析构函数看作是一个 int 的析构函数。它删除其值，对于指针也是如此，它删除它所指向的地址，但不需要删除你刚刚删除的地址中存储的任何对象。
delete 的工作方式并非如此。考虑你的简单语句：delete n;
~M()
{
}
struct MyClass {
public:
MyClass() { .. } // doesn't matter what this does
int x;
int* p;
std::string s;
std::vector<int> v;
};
MyClass::~MyClass()
{
// Call destructor on member variables in reverse order
v.~std::vector<int>(); // frees memory
s.~std::string(); // frees memory
p.~int*(); // does nothing, no custom destructor
x.~int(); // does nothing, no custom destructor
}
尽量避免使用指针。它们是最后的手段。
class N {
public:
~N() {
std::cout << "Destroying object of type N";
}
};
class M {
public:
M() {
// n = new N; no need, default constructor by default
}
// ~M() { //this should happen by default
// delete n;
// }
private:
N n; // No pointer here
};
然后这样使用它
main(int, char**)
{
M m;
}
这将显示销毁类型为 N 的对象
我认为你可以从一个非常简单的例子中受益：
int main(int argc, char* argv[])
{
N* n = new N();
} // n is destructed here
这也不会打印任何东西。
为什么？因为指针（n）被销毁了，而不是指向的对象 *n。
当然，您不希望它销毁指向的对象：
int main(int argc, char* argv[])
{
N myObject;
{
N* n = &myObject;
} // n is destructed here, myObject is not
myObject.foo();
} // myObject is destructed here
你应该记住，与像 C# 或 Java 这样的语言不同，C++ 中有两种创建对象的方式：直接在堆栈上创建 N myObject，或者通过使用 new 创建，例如 new N()，此时对象被放置在堆上，您需要在稍后释放它。
因此，您的析构函数销毁指针，但不销毁指向的对象。如果要自动化，可以在不使用指针的情况下分配对象，或者使用 智能指针。
n是一个指针。该指针会被默认析构函数销毁。它所指向的内容不会被销毁，这是你的责任。 - nos