C++回顾（五）—— 构造函数和析构函数

5.1 构造和析构

5.1.1 构造函数

（1）定义

• 1）C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数；
• 2）构造函数在定义时可以有参数；
• 3）没有任何返回类型的声明。

（2）调用

• 自动调用：一般情况下C++编译器会自动调用构造函数；
• 手动调用：在一些情况下则需要手工调用构造函数。

5.1.2 析构函数

（1）定义

• 1）C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
  语法：~ClassName()
• 2）析构函数没有参数也没有任何返回类型的声明

（2）调用

• 析构函数在对象销毁时自动被调用

5.1.3 对象的构造和析构

（1）构造函数的分类

• 无参构造函数
• 有参构造函数
• 理解对象的初始化与对象赋值的不同

Test t1(4,5);
Test t2 = Test(5,6);  // 对象的初始化
t2 = t1;              // 对象的赋值

• 拷贝构造函数
• 默认构造函数
  二个特殊的构造函数
  1）默认无参构造函数
  当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空
  2）默认拷贝构造函数
  当类中没有定义拷贝构造函数时，编译器默认提供一个默认拷贝构造函数，简单的进行成员变量的值复制

（2）构造函数的规则

• 1）当类中没有定义任何一个构造函数时，c++编译器会提供默认无参构造函数和默认拷贝构造函数
• 2）当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数
• 3）当类中定义了任意的非拷贝构造函数（即：当类中提供了有参构造函数或无参构造函数），c++编译器不会提供默认无参构造函数
• 4 ）默认拷贝构造函数成员变量简单赋值

总结：只要你写了构造函数，那么你必须用。

#include <iostream>

using namespace std;

class Test1
{
public:
};

class Test2
{
public:
	Test2()
	{
		cout << "Test2无参构造函数" << endl;
	}
};

class Test3
{
public:
	Test3(int a)
	{
	}
};

class Test4
{
public:
	Test4(const Test4 &t)
	{
	}
};

int main()
{
	Test1 t1;   //编译器会默认提供无参构造函数
	Test1 tt(t1);  //编译器提供默认的拷贝构造函数（浅拷贝）
	Test2 t2;   //一旦提供了无参构造函数，编译器不再提供默认无参构造函数
	//Test3 t3;   //一旦提供了有参构造函数，编译器不再提供默认无参构造函数(所有这里会报错)
	//Test4 t4;    //一旦提供了拷贝构造函数，编译器不再提供无参构造函数(所有这里会报错)

	return 0;
}

运行结果：

（3）构造析构阶段性总结

• 1）构造函数是C++中用于初始化对象状态的特殊函数
• 2）构造函数在对象创建时自动被调用
• 3）构造函数和普通成员函数都遵循重载规则
• 4）拷贝构造函数是对象正确初始化的重要保证
• 5）必要的时候，必须手工编写拷贝构造函数

#include <iostream>
#include <cstdlib>

using namespace std;

class Array
{
private:
	int *data;   //数组的起始地址
	int size;    //数组的容量
public:
	Array();      //无参构造函数 函数名和类名一样  没有返回值  完成对象的初始化操作
	Array(int s); //有参构造函数
	Array(const Array &a);   //拷贝构造函数
	void setVal(int Index, int val);
	int getVal(int Index);
	~Array();     //析构函数 函数名是类名加~  没有参数 没有返回值
};

Array::Array()
{
	cout << "Array的无参构造函数" << endl;
	size = 5;
	data = (int *)malloc(sizeof(int) * size);
}

Array::Array(int s)
{
	cout << "Array的有参构造函数" << endl;
	size = s;
	data = (int *)malloc(sizeof(int) * size);
}

Array::Array(const Array &a)
{
	cout << "Array的拷贝构造函数" << endl;
}

void Array::setVal(int Index, int val)
{
	data[Index] = val;
}

int Array::getVal(int Index)
{	
	return data[Index];
}

Array::~Array()
{
	cout << "Array析构函数" << endl;
	if (data != NULL)
	{
		free(data);
	}
}

void f(Array a)
{
	
}

int main()
{
	Array a1;     //创建对象的时候，自动调用构造函数
	Array a2(10);//有参构造函数（这个用的最多）
	Array a3 = Array(10);
	Array a4 = (10);
	
	for (int i = 0; i < 5; i++)
	{
		a1.setVal(i, i + 1);
	}

	for (int i = 0; i < 5; i++)
	{
		cout << a1.getVal(i) << " ";
	}
	cout << endl;

	cout << "********" << endl;
	f(a1);      //函数传参，会调用拷贝构造函数
	//Array a5(a2);   //调用拷贝构造函数  用a2构造a5

	return 0;     //释放对象的时候，自动调用析构函数
}

运行结果：

5.2 深拷贝和浅拷贝

5.2.1 浅拷贝问题分析

完成数组类，主函数调用拷贝构造函数，观察代码会出现什么问题？

默认复制构造函数可以完成对象的数据成员值简单的复制
对象的数据资源是由指针指示的堆时，默认复制构造函数仅作指针值复制

注意：这样在析构的时候，会出现释放两次空间的情况，出现报错

5.2.2 浅拷贝问题解决：深拷贝

#include <iostream>
#include <stdlib.h>

using namespace std;

class Array
{
private:
	int *data;
	int size;
public:
	Array(int s)
	{
		cout << "有参构造函数" << endl;
		size = s;
		data = (int *)malloc(sizeof(int) * size);
	}
	Array(const Array &a)    //深拷贝
	{
		cout << "Array拷贝构造函数" << endl;
		size = a.size;
		data = (int *)malloc(sizeof(int) * size);
		for (int i = 0; i < size; i++)
		{
			data[i] = a.data[i];
		}
	}
	~Array()
	{
		cout << "析构函数" << endl;
		if (data != NULL)
		{
			free(data);
		}
	}
};

int main()
{
	Array a1(10);
	Array a2(a1);  //编译器为每个类提供默认的拷贝构造函数 只做简单的赋值（浅拷贝）

	return 0;
}

运行结果：

5.3 匿名对象

#include <iostream>

using namespace std;

class Test
{
public:
	Test()
	{
		cout << "Test无参构造函数" << endl;
	}
	~Test()
	{
		cout << "Test析构函数" << endl;
	}
};

int main()
{
	Test();   //匿名对象，本行代码执行完，立即被释放
	Test();

	return 0;
}

运行结果：