C++类和对象的进一步认识

类的6个默认函数

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

特殊性：我们不写，编译器会自动生成；我们写了，编译器就不会再生成。所以有些类需要我们写，有些不需要。

用于初始化和资源清理的：

构造函数

析构函数

使用同类对象初始化创建对象的：

拷贝构造函数

把一个对象赋值给另一个对象的：

赋值重载

普通对象和const对象取地址的：

取地址重载

构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

不能显式地去调用构造函数。

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。

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

class Date
{
private:
	int _year;
	int _month;
	int _day;

public:
	Date()
	{

	}

	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Show()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
};

int main()
{
	Date d1{ 1560,10,28 };
	Date d2(2022, 9, 25);
	Date d3;

	d1.Show();
	d2.Show();
	d3.Show();
	return 0;
}

6. 关于编译器生成的默认成员函数，很多人会有疑惑：不实现构造函数的情况下，编译器会 生成默认的构造函数。但是看起来默认构造函数又没什么用，因为它什么也不做。

解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类 型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型。

系统自动生成的默认构造函数对内置类型不做处理，对于自定义类型则调用它自身的默认构造函数，如果没有默认构造函数就报错。

#include <iostream>
using namespace std;

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	int _year;
	int _month;
	int _day;
	Time t;
};

int main()
{
	Date d;
	return 0;
}

在调试模式下可以看到，当Date类型的d被创建后，d的成员变量中的内置类型，包括_year,_month,_day都是随机值，而自定义类型的成员t中的值则由于time类型默认构造函数被调用而全变为0。

这确实是一种很奇怪的做法，也受到了不少的诟病，于是在C++11中，这里就被打了补丁：

类定义时，可以指定成员变量的缺省值。

 

 默认构造函数

所谓默认构造函数，总结起来说，其实就是不需要传参，系统可以自动调用的函数。包括以下三种：

1. 系统自动生成的构造函数，里面是空实现。

2. 自己实现的参数为空的构造函数。

3. 自己实现的参数为全缺省的构造函数。

注意：默认构造函数必须有且只能有一个。

析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

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

1. 析构函数名是在类名前加上字符 ~。

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

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

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

5. 析构函数的调用顺序和构造函数调用顺序相反。

6. 如果我们不写，系统默认生成的析构函数和构造函数类似，对于内置类型不做处理，对于自定义类型会去调对应类型的析构函数。

拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。

特征：

1. 拷贝构造函数是构造函数的一个重载形式，但它不是默认构造函数。

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

class Date
{
public:
	Date(Date d)// error C2652: “Date”: 非法的复制构造函数: 第一个参数不应是“Date”  
    Date(Date& d)//正确写法，d是实参的别名，不发生拷贝构造
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

 3. 若未显式定义，编译器会生成默认的拷贝构造函数。 

        a. 对于内置类型，按字节序拷贝，也叫浅拷贝，或者值拷贝，系统默认生成的即可。

        b. 对于自定义类型，会调用变量自己的拷贝构造函数，可能需要自己实现深拷贝。

为什么需要自己实现深拷贝，比如成员变量里面有指向在堆里申请资源的指针，浅拷贝会让两个对象里面的指针成员变量指向同一块内存，这是不符合我们本意的，而且将来释放内存时这段内存会被释放两次而出错。

4. 形参类型前面最好加上const，防止在函数内改变原变量。

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

        使用已存在对象创建新对象

        函数参数类型为类类型对象 （传参）

        函数返回值类型为类类型对象 （返回值）

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

运算符重载

C++默认不支持自定义类型使用运算符，为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：
不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐 藏的this

.*，::， sizeof ，?: ，. 注意以上5个运算符不能重载。

运算符重载函数大多写在类里面，因为类的成员变量一般是私有，写在类外面的话需要破坏类的封装性。写在类里面要注意，形参的第一个被隐藏的this指针所占用，所以参数少一个。对于双操作数的运算符来说，左边的参数地址会被传给this指针，右边的参数会被传给显式的形参。

赋值运算符重载

两个已经创建好的自定义同类型对象，如果想把一个对象的值直接赋值给另一个，就可以用赋值运算符重载。

1. 赋值运算符重载格式

        参数类型：const T&，传递引用可以提高传参效率

        返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

        检测是否自己给自己赋值

        返回*this ：要复合连续赋值的含义

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

        原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现         一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
        运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注 意：内置类型成员变量是直接赋值的，跟拷贝构造类似，自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

总之，构造和析构的处理方式类似，拷贝构造和赋值运算符重载的处理方式类似。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "构造" << endl;
	}

	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "拷贝构造" << endl;
	}
	Date& operator=(const Date& d)
	{
		cout << "赋值" << endl;
		if (this == &d)
		{
			return *this;
		}
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

int main()
{
	Date d1(2022, 2, 22);
	Date d2 = d1;
	Date d3;
	d3 = d2;
	return 0;
}