虚析构函数

一、构造函数和析构函数

     1、构造函数：进行初始化成员变量的函数

     2、析构函数：在对象声明周期结束的时候，完成资源的回收和清理

     3、如果我们在设计一个类的时候，没有显示声明定义构造函数，析构函数，则编译器会自动生成。

二、虚析构函数：

       1、只有当一个类被定义为基类的时候，才会把析构函数写成虚析构函数。

       2、如果我们不需要使用基类对派生类的队形进行操作时，我们也不必去定义虚析构函数，这样会增加系统的内存开销，当类里面有虚析构函数时，系统会为当前类分配一个虚函数表，里面存放虚函数指针，这样就会增加类的存储空间。

       3、对于虚析构，就是在析构函数前加virtual关键字，那么到底有什么作用呢？

           防止内存泄露，定义一个基类的指针p，在delete p时，如果基类的析构函数是虚函数，这时只会看p所赋值的对象，如果p赋值的对象是派生类的对象，就会调用派生类的析构函数（毫无疑问，在这之前也会先调用基类的构造函数，在调用派生类的构造函数，然后调用派生类的析构函数，基类的析构函数，所谓先构造的后释放）；如果p赋值的对象是基类的对象，就会调用基类的析构函数，这样就不会造成内存泄露。

          如果基类的析构函数不是虚函数，在delete p时，调用析构函数时，只会看指针的数据类型，而不会去看赋值的对象，这样就会造成内存泄露。

三、代码，当析构函数中没有增加 visual 开头的时候：

#include<iostream>
using namespace std;

class A{
public:
	A(){                 //构造函数
		p=new char[20];
		strcpy(p,"obja");
		printf("A();\n");
	}
	~A(){                 //析构函数
		delete []p;
		printf("~A();\n");
	}
private:
	char *p;
};

class B : public A{
public:
	B(){                 //构造函数
		p=new char[20];
		strcpy(p,"objb");
		printf("B();\n");
	}
	~B(){                 //析构函数
		delete []p;
		printf("~B();\n");
	}
private:
	char *p;
};

class C : public B{
public:
	C(){                 //构造函数
		p=new char[20];
		strcpy(p,"objc");
		printf("C();\n");
	}
	~C(){                 //析构函数
		delete []p;
		printf("~C();\n");
	}
private:
	char *p;
};

void howtodelete(A *base){
	delete base;
}

void main(){
	C *myC = new C;       // 会进行析构函数
	howtodelete(myC);

	cout<<"\n there is end \n"<<endl;

}

输出的结果：

      上述代码中，只执行了类的析构函数，不会变现出多态的这种属性。想通过父类指针把所有子类对象的析构函数都执行一遍（即想通过父类指针，释放所有的资源）。但是只有父类执行了析构函数 ，只有   ~A（）； ，所以上述代码中发生了内存泄露。

四、代码：当在析构函数前面增加 virtual 时候

#include<iostream>
using namespace std;

class A{
public:
	A(){                 //构造函数
		p=new char[20];
		strcpy(p,"obja");
		printf("A();\n");
	}
	virtual ~A(){                 //析构函数
		delete []p;
		printf("~A();\n");
	}
private:
	char *p;
};

class B : public A{
public:
	B(){                 //构造函数
		p=new char[20];
		strcpy(p,"objb");
		printf("B();\n");
	}
	virtual ~B(){                 //析构函数
		delete []p;
		printf("~B();\n");
	}
private:
	char *p;
};

class C : public B{
public:
	C(){                 //构造函数
		p=new char[20];
		strcpy(p,"objc");
		printf("C();\n");
	}
	virtual ~C(){                 //析构函数
		delete []p;
		printf("~C();\n");
	}
private:
	char *p;
};

void howtodelete(A *base){
	delete base;
}

void main(){
	C *myC = new C;       // 会进行析构函数
	howtodelete(myC);

	cout<<"\n there is end \n"<<endl;

}

上诉代码中在析构函数前面增加了 virtual 。从而使析构函数发生了多态。