15~C++析构函数与变量生命周期

构造函数负责初始化对象 并分配资源，析构函数用于抹除数据并释放资源

栈对象的析构

#include <iostream>
#include <cstdlib>

using namespace std;

class Store
{
public:
	size_t const bytes = 100;
	Store(void)
	{
		p_mem = (char *)malloc(bytes);
		cout << "我是构造函数，负责分配100字节内存" << endl;
	}
	~Store(void)
	{
		cout << "我是析构函数，负责销毁为对象分配的内存" << endl;
		free(p_mem);
	}
char *p_mem;
};

int main(void)
{
	cout << "main函数入口" << endl;
	{
		Store();
		/*析构函数是在花括号结束位置调用的*/
	}

	cout << "main函数出口" << endl;
	return 0;
}

匿名对象的构造与析构

函数传参为对象

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

class Store
{
public:
	size_t const bytes = 100;
	Store(int num)
	{
	    mem_int = num;
		p_mem = (char *)malloc(bytes);
		cout << "我是构造函数，负责分配100字节内存, n = " << mem_int << endl;
	}
	
	Store(Store const& that)
	{
	    mem_int = 0;
		cout << "我是拷贝构造函数，负责资源拷贝, n = " << mem_int << endl;
		p_mem = (char *)malloc(bytes);
		memcpy(p_mem,that.p_mem,bytes);
		
	}
	~Store(void)
	{
		cout << "我是析构函数，负责销毁为对象分配的内存, n = "<<mem_int << endl;
		free(p_mem);
	}
char *p_mem;
int mem_int;
};

void fool(Store st)
{
	cout << "fool 函数 执行" << endl;
}

Store barn(void)
{
	Store st1(99);
	cout << "barn 函数 执行" <<endl;
	return st1;
}
int main(void)
{
	Store st1(1);
	cout << "main函数入口" << endl;
	/*fool函数被调用前，由main函数负责分配栈对象，并调用拷贝构造函数*/
	fool(st1);
	/*fool函数返回后，main函数负责调用析构函数，并回收栈对象*/
	cout << "main函数出口" << endl;

	/*返回值 即不用构造也不必去析构,返回的是一个浅拷贝*/
	barn();
	
	cout << "-----------------" << endl;
	Store tmp = barn(); //这里很特别，barn中构造的对象，延迟到main结束才析构
	cout << "The end" << endl;
	return 0;
}

类型转换 匿名对象的构造与析构

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

class Store
{
public:
	size_t const bytes = 100;
	Store(void)
	{
		p_mem = (char *)malloc(bytes);
	}
	
	Store& operator=(Store const& that)
	{
		cout << "赋值函数" << endl;
		return *this;
	}
	
	Store (size_t size)
	{
		p_mem = (char *)malloc(size);
		cout << "类型转换函数int -> Store" << endl;
	}

	Store(Store const& that)
	{
		cout << "我是拷贝构造函数，负责资源拷贝" << endl;
		p_mem = (char *)malloc(bytes);
		memcpy(p_mem,that.p_mem,bytes);
		
	}
	~Store(void)
	{
		cout << "我是析构函数，负责销毁为对象分配的内存" << endl;
		free(p_mem);
	}
char *p_mem;
};

int main(void)
{
	cout << "main函数入口" << endl;
	Store st1;
	Store st2;
	cout << "-------" << endl;
	st2 = st1 = 100;
	/*st2 = st1 = 100,匿名构造的对象在赋值语句结束后，进行析构*/
	cout << "main函数出口" << endl;
	return 0;
}

静态对象的构造与析构

具有静态生命周期的对象在main函数执行前被构造，在main函数结束后析构

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

class Store
{
public:
	size_t const bytes = 100;
	Store(void)
	{
		cout <<  "我是构造函数，负责分配100字节内存" <<endl;
		p_mem = (char *)malloc(bytes);
	}
	
	~Store(void)
	{
		cout << "我是析构函数，负责销毁为对象分配的内存" << endl;
		free(p_mem);
	}

	Store& operator=(Store const& that)
	{
		cout << "我是赋值函数，其实我什么都不干" << endl;
		return *this;
	}

	Store (Store const& that)
	{
		cout << "我是拷贝构造函数，用于资源复制" << endl;
	}
char *p_mem;
};

Store st1;
Store st2 = st1;
Store st3(st1);

int main(void)
{
	cout << "main函数入口" << endl;
	return 0;
}

/* Log:
我是构造函数，负责分配100字节内存
我是拷贝构造函数，用于资源复制
我是拷贝构造函数，用于资源复制
main函数入口
我是析构函数，负责销毁为对象分配的内存
我是析构函数，负责销毁�对象分配的内存
我是析构函数，负责销毁为对象分配的内存
*/

动态对象的构造与析构

• new 运算符自动调用构造函数
• delete 运算符自动调用析构函数