对于同一个类进行两次析构一般情况不会出现问题，但是当在析构函数中调用了delete对于类中的成员变量进行销毁则会出现问题，如果进行两次析构函数，则会对同一个变量进行两次销毁，则第二次销毁就会出现问题，会出现_BLOCK_TYPE_IS_VALID(pHead->nBlockUse的问题。
出现这个问题的原因有：
1.内存泄漏：所以当程序退出是，系统会收回分配的内存，于是调析构函数，由于内存已被错误地释放，于是就会出现“Debug Assertion Failed”的错误。
2.这个assert说明什么问题，说明有一块内存在被释放的时候，它的头部里面的信息已经被改掉了，和预期的不一样，内存分配的程序往往在被分配出的内存块头部放上一些校验信息，这个信息内存的用户是不知道也不应该修改的。这样，在内存被释放的时候，内存分配程序就可以校验出这个头部信息是否被改过了，若被改过，就说明发生了内存的corruption。
这种corruption有两种可能：
1.说明有人在内存越界写东西；
2.这块内存已经被释放了，又被重复释放了一次。
 3.pHead->nBlockUse已经是空指针了。或者它指向的东西已经消失了。
下列是一个例子：
class A
{
public:
	A()
	{
		use = new int[5];
	}
	~A()
	{
		delete[] use;
	}
private:
	int *use;
};

class B
{
public:
	B(A &obj) :a(obj)
	{

	}
	~B()
	{}
private:
	A a;
};

int main()
{
    A a;
    B b(a);
    return 0;
}

这个例子会发生错误，因为在B进行析构的时候会对成员A进行析构，会销毁a的变量use，之后会再对A进行一次析构，这样同一个类对象a就进行了两次析构，要消除这种错误，只有对B的成员变量a定义为A的引用，如下面的例子所所示。

class A
{
public:
	A()
	{
		use = new int[5];
	}
	~A()
	{
		delete[] use;
	}
private:
	int *use;
};

class B
{
public:
	B(A &obj) :a(obj)
	{

	}
	~B()
	{}
private:
	A& a;
};

首先，我们来看一段代码：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A's constructor." << endl;
	}
	~A()
	{
		cout << "A's destructor." << endl;
	}
};

class B
{
public:
	B()
	{
		cout << "B's constructor." << endl;
	}
	~B()
	{
		cout << "B's destructor." << endl;
	}
};

class C
{
private:
	B bInC;
public:
	C()
	{
		cout << "C's constructor." << endl;
	}
	~C()
	{
		cout << "C's destructor." << endl;
	}
	A aInC;
};

class D:public C
{
public:
	D()
	{
		cout << "D's constructor." << endl;
	}
	~D()
	{
		cout << "D's destructor." << endl;
	}
	A aInD;
private:
	B bInD;
};

int main(void) {
	D d;
	return 0;
}


那么，这段程序执行后，输出什么呢？


B's constructor.
A's constructor.
C's constructor.
A's constructor.
B's constructor.
D's constructor.
D's destructor.
B's destructor.
A's destructor.
C's destructor.
A's destructor.
B's destructor.


分析如下：

（1）存在继承关系时，先执行父类的构造函数，再执行子类的构造函数；
（2）当一个类中含有对象成员时，在启动本类的构造函数之前，先分配对象空间，按对象成员的声明顺序执行他们各自的构造函数，再继续执行本类的构造函数；
（3）对于非静态的局部对象，他们的析构函数的执行顺序与构造函数相反。
在本程序中：
（1）执行main()，需要创建一个对象d，所以，需要执行D的构造函数。而D继承自C，所以先要执行C的构造函数；
（2）而在C中存在对象成员bInC和aInC，所以，在C的构造函数执行之前，先按声明顺序执行B和A的构造函数，然后执行C的构造函数；
（3）轮到构造d了，但是D中有对象成员aInD和bInD，所以，在D的构造函数执行之前，先按声明顺序执行A和B的构造函数，最后，执行D的构造函数；
（4）以上所有对象的析构函数以与构造函数的执行顺序相反的顺序执行。
最终的执行结果就不言而喻了。


学无止境，共同学习。若本文所述存在错误或不妥之处，欢迎指正~

把所有的资源释放的工作放在析构里面是危险的，除非你的类是个生命期局部的类。

对于全局变量或静态变量，在析构函数里面释放资源有的时候会确实有点不好，万一你的析构里面的代码依赖外部的某些资源，而这些资源优先于你的资源被释放了，那么当你的资源呗释放的时候就会崩溃了。。。呵呵。

今天遇到了 在析构里 delete fnt；出现的问题即是如此。hge引擎已经被事先释放了。
看来，为全局、静态、单件实例的类提供一个Release接口是非常必要的。让其在析构里面什么也不做。

引用百度用户：jeny_man的回答

你提出这个问题，说明你已经对c++有所思考了。

从语法上来讲，一个函数被声明为protected或者private，那么这个函数就不能从“外部”直接被调用了。

对于protected的函数，子类的“内部”的其他函数可以调用之。 而对于private的函数，只能被本类“内部”的其他函数说调用。

语法上就是这么规定的，你肯定也知道的咯。 那么为什么有时候将构造函数或者析构函数声明为protected的或者private的？

通常使用的场景如下：

1。如果你不想让外面的用户直接构造一个类（假设这个类的名字为A）的对象，而希望用户只能构造这个类A的子类，那你就可以将类A的构造函数/析构函数声明为protected，而将类A的子类的构造函数/析构函数声明为public。例如：

class A { protected: A(){} public: … }; calss B : public A {

public: B(){} … }; A a; // error B b; // ok

2. 如果将构造函数/析构函数声明为private，那只能这个类的“内部”的函数才能构造这个类的对象了。这里所说的“内部”不知道你是否能明白，下面举个例子吧。

class A { private: A(){ } ~A(){ } public: void Instance()//类A的内部的一个函数

{ A a; } };

上面的代码是能通过编译的。上面代码里的Instance函数就是类A的内部的一个函数。Instance函数体里就构建了一个A的对象。

但是，这个Instance函数还是不能够被外面调用的。为什么呢？

如果要调用Instance函数，必须有一个对象被构造出来。但是构造函数被声明为private的了。外部不能直接构造一个对象出来。 A

aObj; // 编译通不过 aObj.Instance();

但是，如果Instance是一个static静态函数的话，就可以不需要通过一个对象，而可以直接被调用。如下：class A {

private: A():data(10){ cout << “A” << endl; } ~A(){ cout << “~A” <<

endl; } public: static A& Instance() { static A a; return a; } void

Print() { cout << data << endl; } private: int data; }; A& ra =

A::Instance(); ra.Print(); 上面的代码其实是设计模式singleton模式的一个简单的C++代码实现。

还有一个情况是：通常将拷贝构造函数和operator=(赋值操作符重载)声明成private，但是没有实现体。

这个的目的是禁止一个类的外部用户对这个类的对象进行复制动作。 细节请看《effective

C++》里面的一个条款。具体哪个条款不记得了。你自己去找吧。