【c++】——类和对象(中)——默认成员函数(上)

• 1. 类的6个默认成员函数
• 2. 构造函数
• 3. 析构函数
• 4. 拷贝构造函数

目录

一.类的6个默认成员函数

二. 构造函数

2.1 概念

2.2.特性

三.析构函数

3.1.概念

3.2 特性

四.拷贝构造函数

4.1.概念

4.2.特性

一.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？

并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date {};

二. 构造函数

2.1 概念

class Date
{
public:
	void init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.init(2023, 11, 05);
	d1.print();
 
	return 0;
}

构造函数是一个特殊的成员函数，

1.名字与类名相同,

2.创建类类型对象时由编译器自动调用，以保证每个数据成 员都有 一个合适的初始值

3.在对象整个生命周期内只调用一次。  

2.2.特性

构造函数 是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造

构造函数的主要任务 并不是开 空间创建对象，而是 初始化对象。

特征如下：

• 1. 函数名与类名相同。
• 2. 无返回值。
• 3. 对象实例化时编译器自动调用对应的构造函数。
• 4. 构造函数可以重载。
• 5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

构造函数可以分成2类——无参构造函数和有参构造函数

class Date
{
public:
	/*void init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
	// 1.无参构造函数
	Date()
	{}
	// 2.有参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; // 调用无参构造函数
	Date d2(2015, 1, 1); // 调用带参的构造函数
	d1.print();
	d2.print();
	return 0;
}

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则

就成了函数声明 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象

Date d3()不是很惯用的函数声明，我换种形式 int func(),这样看是不是更清楚了，这就是相当于无参函数的声明。int func(void).

特性5：

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

• 类中显式定义构造函数，就是显示上面的代码段，编译器就不用给出帮助，因为自己传参了。

• 类中没有显示定义构造函数，C++编译器会自动生成一个无参的默认构造函数。然后给出的成员变量的值都是随机值。

---

我们看一下这下面的代码段，为什么显示“没有合适的默认构造函数可用”？？

错误原因：在Date类中定义了其他构造函数，那么，编译器不会为你创建默认构造函数；然而，在编译器调用Date的默认构造函数时，就会找不到，d1是无参的对象，而上面的默认构造函数是存在参数的，所以编译器显示没有合适的默认构造函数可用。

解决方法：加入默认构造函数，与之匹配。

如果Date创建的对象d1传参和上面的构造函数参数个数类型匹配，就说明找到合适的默认构造函数可用，否则都得创建一个与之对应参数个数类型的默认构造函数即可。

特性6: 

特性7： 

这里我们要特别区分俩个名词：默认成员函数和默认构造函数

• 默认成员函数：任何类在什么都不写时，编译器会自动生成以下6个默认成函数。
• 默认构造函数：类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数。

3.2 特性

析构函数 是特殊的成员函数，其 特征如下：

• 1. 析构函数名是在类名前加上字符 ~。(~就相当于运算符里面的按位取反操作符)

• 2. 无参数无返回值类型。

• 3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

注意：析构函数不能重载

• 4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
				perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack s;
	s.Push(1);
	s.Push(2);
return 0;
}

特性5：

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？

下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
		int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

这里我们没有给Date显式定义析构函数，那d声明周期结束时，就会调用编译器自己生成的默认析构函数，那里面的内置类型不做处理，当然也不用处理，关键在于自定义类Time _t;申请的资源需要清理，那我们看编译器自己生成的默认析构函数会不会调用Time _t类的析构函数：

这是上面代码的运行结果。显然是调用了。

这时候我们就应该想一个问题了？

——在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；

而_t是Time类对象，所以在 d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁，main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数。

注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数。

特性6：

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类 。

4.2.特性

拷贝构造函数也是特殊的成员函数， 其特征如下：

• 1. 拷贝构造函数是构造函数的一个重载形式。

因为我们刚才上面说了嘛，它的作用其实也是用来初始化对象的，只不过参数类型指定了是我们当前类的类型嘛。所以它算是构造函数的一种重载形式。

• 2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

我们按照上面形式传参，会导致显示一个错误编译，没有运行就错了。

那相信大家刚才也注意到上面的概念了，在拷贝构造函数的概念中其实就指明了说它的参数类型应该是类对象的引用。

确实，我们这样修改之后就可以了。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

结合下面这张图给大家解释一下：
ps：图中还在形参前加了const，大家可以先不管，后面会解释。

大家想一下，首先我们这里是用已有的类对象去创建一个相同的新对象（类对象的拷贝），所以会调用拷贝构造函数，那要调用函数是不是要先传参啊，而传值调用传的是啥（形参是实参的一份临时拷贝），是不是传的实参的拷贝，那要拷贝实参，是不是又是一个类对象的拷贝啊，那既然是类对象的拷贝，就又要调用拷贝构造函数，那就又需要传参，一传参就会再次调用拷贝构造函数，那这样是不是就陷入一个死递归了。

直接用“=”也可以，这样也是拷贝构造。

上面一开始拷贝构造函数的概念中说它的形参一般用const修饰：

为什么要加个const呢？
其实很容易理解，大家想形参d是用来干嘛的， 是用来初始化我们新创建的对象的，那我们肯定不希望形参d被修改，所以加个const修饰：

这样我们如果不小心写反了啥的是不是就直接报错了。

另外，加const还有什么好处呢？

大家想，如果我们不加const，但传过来的参数是const修饰的，这样的话是不是根本就接收不了啊，这个问题我们之前也讲了，是不是属于权限放大了，是不行的。但是如果我们加了const，传过来的不管是否加const，是不是都可以接收啊。

特性4：

那为了解决这个问题，我们再来看这样一个类：

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期 类这样的类是没必要的。那么下面的类呢？验证一下试试？

typedef int DataType;
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
	~Stack()
	{
		cout << "~Stack" << endl;
		free(_array);
		_array = NULL;
		_capacity = 0;
		_size = 0;
		
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

还是我们之前用过的这个栈Stack类，大家看它的成员变量是不是也都是内置类型啊，前面提到过指针也属于内置类型嘛。

那对于Stack这个类，我们也是没写拷贝构造函数的，那编译器自动生成的能不能完成下面这样的拷贝呢？

int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
 
	Stack s2(s1);
	return 0;
}

为什么会这样呢，刚才Date类不也都是内置类型，为啥就没事呢？ 

首先对于Date类来说，进行这样的浅拷贝有没有问题啊。

是不是没问题啊，一共12个字节的内容，直接拷贝过去就行了嘛

特性5：

5. 拷贝构造函数典型调用场景：

• 使用已存在对象创建新对象
• 函数参数类型为类类型对象
• 函数返回值类型为类类型对象

为了提高程序效率，一般对象传参时，尽量使用引用类型(减少拷贝)，返回时根据实际场景，能用引用尽量使用引用。

考研，还是就业？