C++之析构函数

1.定义

/*
* 构造函数开辟空间
*         构造函数--自动调用--构造对象--默认的构造函数（无参，无返回类型）
* 析构函数释放空间
*         析构函数--释放对象--对象退出时--自动调用（程序员可以调用）
*         当前类中有析构函数，来在对象退出的时候收尾
* 编译器会提供一个默认的析构函数，函数名为~类名,析构函数无参（只为了释放空间，无论有多少数据成员），不能重载，有且只有一个
* 一个类有且只有一个析构函数
*/

class A//大小为8字节
{
public:
	A(int i=4, int j=8) :m_i(i), m_j(j)
	{
		cout << "A" << m_i << " " << m_j << endl;
	}
	~A()
	{
		cout << "~A" << endl;
	}
private:
	//栈上开辟的空间，不需要程序员来释放
	const int m_i;
	int m_j;
};

void main()
{
	A a(3,6);//局部对象，在当前这个大括号，
	A b(2, 7);//先析构b再析构a，构造几次，析构几次，且相对相反（同一个作用域中）
	cout << "main" << endl;
}

2.为什么有系统有析构函数，程序员还需要自己写？

/*
* 既然每个类都回提供一个默认的析构函数，而且析构函数只能有一个，而且是无参，那么程序员为什么还需要自己写？
* 什么时候程序员就需要自己写析构函数？
* 当有指针作为数据成员时，就需要程序员写析构函数，将构造函数中的new的空间释放
*/

（1）new

/*
* new
* malloc,free,realloc
* 1.new和delete是运算符，malloc和free是库函数
* 2.new和delete可以调用构造和析构（即就是构造对象和释放对象、随时new,随时delete）；
    malloc和free只能分配空间和释放空间
*/

/*
* 一个合法的对象--调用构造函数--开辟空间和赋合法值（初始化）
*/

class A
{
public:
	A(int i=0):m_i(i)
	{
		cout << "A" << endl;
	}
	~A()
	{
		cout << "~A" << endl;
	}
	void print()
	{
		cout << m_i << endl;
	}
private:
	int m_i;
};

void main()
{
	A* p = new A[5];//new了五个A类类型对象
	//delete p;//析构一次
	delete []p;//析构5次,delete 必须是数组
	//char* p = new char[20];
	//delete p;
}

delete p;//析构一次

delete []p;//析构5次,delete 必须是数组

 （2）malloc

 /*
* malloc和free是库函数
*  malloc和free只能分配空间和释放空间
*/

class A
{
public:
	A(int i=0):m_i(i)
	{
		cout << "A" << endl;
	}
	~A()
	{
		//cout << "~A" << endl;
	}
	void print()
	{
		cout << m_i << endl;
	}
private:
	int m_i;
};

void main()
{
	/*A* p = NULL;//Al类类型的指针变量为P，占4字节（无论类型），直接赋空（野指针）
	p = (A*)malloc(sizeof(A));//只是开辟空间没有调用构造函数不是对象，没有赋合法值.一个指针变量，
	p->print();//随机值
	free(p);//只是释放空间
	p = NULL;*/
	A* p = new A(6);
	delete []p;
	//char* p = new char;//开辟了一个字节的空间
	char* q = new char[20];//new了一个20个连续的内存空间，让p指针指向
	strcpy(q, "asdfghjk");
	cout << q << endl;
	delete []q;
}

调用了构造函数