C++入门必须知道的知识☞类的默认成员函数，一文讲透+运用

目录

1.类的默认成员函数

2.构造函数

2.1 构造函数定义：

2.2 构造函数特点：

2.3 编译器自动生成的默认构造函数的行为：

3.析构函数

3.1 析构函数

3.2 析构函数的特点

3.3 编译器自动生成的析构函数的行为：

4.拷贝构造函数

4.1 拷贝构造函数

4.2 传值传参时的拷贝

4.3 拷贝构造函数的特点：

4.4 编译器默认生成的拷贝构造函数的行为

4.5 传值返回时的拷贝

5. 赋值重载

5.1 运算符重载

5.2 赋值重载

5.2.1 赋值重载特点

5.2.2 赋值运算符重载格式

---

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

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

1.类的默认成员函数

默认成员函数就是用户没有显示实现，编译器会在类中自动生成的成员函数称为默认成员函数

 ⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可

第⼀：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求

第⼆：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

带着这两个方向往下学习： 

2.构造函数

2.1 构造函数定义：

类里完成初始化工作的函数，自己不写时，编译器会自动生成，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象的整个生命周期内只调用一次

注：构造函数是特殊的成员函数，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是在对象实例化时初始化对象，通常可以理解为给其成员变量进行赋值，同时它会自动调用，也就是在实例化对象同时自动帮我们初始化

2.2 构造函数特点：

结构特性：

1. 构造函数的 函数名与类名相同

2. 无 返回值. (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

使用特性：

3. 对象实例化时系统会 自动调用 对应的构造函数

4. 构造函数可以 重载

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

6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数 ，都叫做默认构造函数。但是这 三个函数有且只有⼀个存在 ，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会 存在歧义 。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是 不传实参就可以调用的构造就叫默认构造

我们结合具体实例来看这些特点，

首先：如何定义构造函数

构造函数的 函数名与类名相同

无 返回值. (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

假设我们定义了一个日期类Date，我们在其内部实现一个构造函数Date()，按照构造函数特点，

函数名和类名相同且无返回值，此时我们就自己显示实现了一个构造函数

// 类名
class Date
{
public:
    // 构造函数，函数名和类名相同,无返回值
    Date()
    {
        _year = 1;
	    _month = 1;
	    _day = 1;
    }
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

我们再用Date类实例化一个对象d1 ，调用main函数，调试可以看到，d1里的成员变量自动全被初始化成了1，和我们在构造函数中的赋值一致，说明：在对象实例化时系统会自动调用其对应的默认构造函数，这里d1对象就自动调用了Date类对应的默认构造函数

构造函数还可以重载，也就是在类主体里可以实现与构造函数同名的但参数不同的构造函数

下方代码我们在原来的构造函数下方重载了一个新的构造函数，与原来的构造函数区别在于调用时需要传参，但此时这个重载的函数就不是默认构造函数了，而是构造函数，因为它不满足默认构造函数的特点（不传实参就可以调用的构造就叫默认构造，后面会详细说），但是它提供了一种在创建对象时可以自定义成员变量初始化值的方式，有时候我们在实例化对象的时候想要自己直接给值就需要这种带参的构造函数

class Date
{
public:
    // 默认构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//构造函数重载，带参构造函数
	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;
};

此时如果实例化两个对象d1,d2分别使用两种初始化方式

int main()
{
	Date d1;// 调用默认构造函数初始化
	Date d2(2024, 11, 28);// 自己给值初始化
	d1.Print();
	d2.Print();
	return 0;
}

 

运行查看结果，d1自动调用了默认构造函数初始化，d2则是由我们自己传的值进行初始化

但是需要注意，构造函数虽然没有参数，但是在调用时，不能出现d1( )这样的写法，因为这样会出现调用歧义，写成Date d1( )的形式会让编译器不知道是这是函数的声明还是定义,也就是编译器不知道这条语句是要声明一个函数还是调用一个函数，即出现调用歧义

但是上面那样写一个带参的构造函数和无参构造函数并不是常见的定义形式，我们一般将二者综合起来即定义全缺省构造函数

除了无参数的写法来显示实现默认构造函数，还可以使用缺省参数的形式实现默认构造函数，缺省函数就是在用户不输入参数的时候有一个默认值调用函数，这种方式的好处是结合了上面两种初始化方式，用户可以自己给值初始化成员变量，也可以不给值，使用默认值初始化，但是注意：这里一定要是全缺省，即所有变量都有一个默认值初始化，否则便不是默认构造函数（不需要手动传参就可以调用的构造函数），而是构造函数

class Date
{
public:
    // 全缺省函数形式的构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

前面的代码中看到，我们总共定义了三种构造函数，分别是

①Date( ){...} 

②Date(int year, int month, int day){....}

③Date(int year = 1, int month = 1, int day = 1){....}

发现只有②在调用时需要传参，而①和③在调用时可以不传参，我们把①和③这样不传参就可以调用的构造函数称为默认构造函数，还有一种默认构造函数是我们没有显示定义时由编译器自动生成的构造函数

上面因为我们自己显示定义了构造函数，所以编译器就直接调用我们写的构造函数，但如果我们在类里没有定义构造函数，C++编译器会自动生成一个无参的默认构造函数，一旦你显示定义，编译器就不会生成

总结

无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函 数

可以简单理解为不用传参数调用的构造为默认构造，但是三个函数有且只有一个存在，不能同时存在，即默认构造只能有一个

2.3 编译器自动生成的默认构造函数的行为：

编译器默认生成的构造函数对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。 

比如：这里Date类里没有自己显式定义的构造函数，调试可以看到编译器对实例化的对象d1的的成员变量是没有进行处理的

但有些时候编译器自动生成的默认构造函数就可以直接使用，比如下面这个MyQueue类就可以直接调用由编译器自动生成的默认构造函数，对于自定义类型成员变量，系统自动生成的默认构造函数会调用这个成员变量的默认构造函数初始化，也就是MyQueue类里的两个Stack类型的变量会去调用Stack类里的构造函数

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n=4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个栈实现一个队列
class MyQueue
{
public:
//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
    //两个自定义类型成员变量
	Stack _pushst;
	Stack _popst;
	int _size;
};
int main()
{
	MyQueue mq;// 这里初始化调用系统自动生成的默认构造函数
	return 0;
}

一般情况下，构造函数都需要自己显式定义，很少情况可以直接用，比如上述MyQueue类 

3.析构函数

知道了一个对象怎么来的，那么一个对象又是怎么没的呢？

3.1 析构函数

析构函数与构造函数功能相反，C++规定对象在 销毁 时会 自动调用析构函数 ， 完成对象中资源的清理释放工作

3.2 析构函数的特点

结构特点：

1. 析构函数名是在类名前加上字符 ~ （波浪号）

2. 无参数 无返回值  (这里和构造函数类似，也不需要加void)

使用特点：

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

4. 对象生命周期结束时，系统会自动调用析构函数

5. 跟构造函数类似，我们不写编译器自动生成的析构函数对 内置类型成员 不做处理， 自定义类型成员 会调用他的析构函数，和构造函数不同是我们显示写，对于自定义类型成员也会调用他的析构，也就是说 自定义类型成员无论什么情况都会自动调用析构函数

7. 如果类中 没有申请资源 时，析构函数可以不写，直接使⽤编译器生成的默认析构函数，如Date类；如果默认⽣成的析构就可以⽤，也不需要显示写析构函数，如MyQueue；但是 有资源申请 时， ⼀定 要自己写析构，否则会造成资源泄漏，如Stack类

8. 一个局部域的多个对象，C++规定后定义的先析构

注：有需要释放的资源的时候才需要析构函数

什么时候需要释放资源？比如malloc开辟的空间释放、关闭打开的文件等……

举例：定义一个Stack类实现栈，按照析构函数特点，显示实现一个析构函数，定义格式：

函数名为在类名前加上~，无参数无返回值

~Stack()

{

        函数体;
}

我们知道实现栈的时候需要内存的堆上malloc出一块空间来存储栈的数据结构

//栈这种类就需要析构函数
typedef int STDataType;
class Stack
{
public:
    // 构造函数
	Stack(int n = 4)
	{
        // malloc空间
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//析构函数
	~Stack()
	{
	    cout << "~Stack()" << endl;//正常不需要这句，只为了显示自动调用了析构函数打印观察
	    free(_a);
	    _a = nullptr;
	    _top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack st;//实例化对象
	return 0;
}

上述代码调用main函数的时候会建立一个栈帧，这个栈帧在开辟时会将内部代码运行所需要的空间开辟好，比如Stack类实例化出的对象st所需要的空间，因为Stack类里我们显示定义了构造函数，所以此时系统会调用构造函数初始化对象st，而在构造函数里使用了malloc开辟了空间，也就是整个代码开辟的空间如下图：

因为对象st的空间是随着main函数栈帧的创建而一同开辟的，所以st的空间也会随着main函数栈帧的销毁而销毁（也就是st的生命周期跟着main函数的结束而结束），但是st还malloc出了另一块空间，如果main函数结束导致st的空间被释放，那么就没办法找到malloc出的那块空间了，就会造成内存泄漏

所以为了避免这种情况，就需要在对象生命周期结束前将其申请的资源释放掉，这就是析构函数的作用，在对象生命周期结束时，系统会自动调用析构函数，将其申请的资源释放掉

和构造函数类似，析构函数如果我们不显示实现，系统会自动生成一个，比如下面的Myqueue类默认生成的析构函数是去调用Stack里的析构函数（因为它的成员变量是两个自定义类型），这里注意：如果我们不写析构函数系统自动生成的默认析构函数就可以直接使用，但是如果我们显示写了，对于自定义类型变量系统会调用我们自己写的析构函数，也会去调用两个自定义类型成员自己类里的析构函数，也就是，对于自定义类型成员无论如何编译器都会调用他的析构函数

class Myqueue
{
public:
    //编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
	//但如果这里写了，它会调用这里的析构但也会调用默认生成的析构
	~Myqueue()
	{
		//不需要 会自动调用Stack里的析构 不需要你自己写
	}

private:
	Stack _pushst;
	Stack _popst;
};

3.3 编译器自动生成的析构函数的行为：

对内置类型成员是不做处理，销毁时不需要资源清理，最后系统直接将其内存回收即可，对于自定义类型的成员变量会去调用该类型的析构函数进行资源清理释放，一般来说有需要的时候析构函数还是要自己写，只有少数情况可以直接使用系统自动生成的

但是并不是所有类都要需要析构函数，如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如前面例子中举过的Date类；如果默认生成的析构就可以用，也不需要显示写析构，如MyQueue；但是有资源申请时，⼀定要自己写析构，否则会造成资源泄漏，如上上面的Stack类

总结：一般情况下显示申请了资源的才需要自己写析构函数，其他情况基本上可以不写

4.拷贝构造函数

在创建对象时，有时候想创建一个与已存在对象一摸一样的新对象该怎么办呢？

4.1 拷贝构造函数

一个特殊的构造函数，用于拷贝（复制）对象，C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以当自定义类型传值传参和传值返回时都会调用拷贝构造完成

拷贝构造函数可以理解为构造函数的一个重载，定义格式:

无返回值，函数名为类名，第一个参数必须为自身类型的引用，如果后面有其他参数，其他参数必须有缺省值

定义格式：

类名(自身类型的引用，其他参数)

{

        函数体;
}

拷贝构造函数具体定义例子：

// Date类的拷贝构造函数，第一个参数为该类型的引用
Date(Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

4.2 传值传参时的拷贝

将自定义类型作为参数传给函数调用

举例：下面代码建立Date类，类里定义该类的拷贝构造函数，类外定义一个参数为Date类型的Func函数，在main函数内创建d1对象作为参数传给Func函数进行传值传参

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 拷贝构造
	Date(Date& d)
    {
        cout<<"拷贝构造"<<endl;// 方便观察拷贝构造调用
	    _year = d._year;
	    _month = d._month;
	    _day = d._day;
    }
private:
	int _year;
	int _month;
	int _day;
};
// 传值传参：定义需要传该类型的对象作为参数的值的函数
void Func(Date d)
{
    cout<<"Func()"<<endl;// 打印观察
}
int main()
{
    Date d1;
    Func(d1);//将d1作为参数传给Func函数
    return 0;
}

根据C++规定自定义类型的传值传参必须调用拷贝构造，也就是当我们把对象d1作为参数传给Func函数时候，代码运行时会先进入拷贝构造函数，拷贝一份d1，把d1的拷贝版作为参数传给Func函数运行

为了观察这点，在拷贝构造函数和Func函数里添加打印语句，从运行结果可以看到，在传值传参时，自动调用了拷贝构造函数

 传值返回时的拷贝：
假设在上方代码的基础上，增加一个新的函数f( )，这个函数将自定义类型Date作为返回值，此时也会自动进入拷贝构造函数

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

4.3 拷贝构造函数的特点：

1.拷贝构造函数的第⼀个参数必须是本类类型对象的引用，如果使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。 拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引用，后面的参数必须有缺省值；

2.若未显式定义拷贝构造函数，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造

先来看第一个特点为什么拷贝构造函数的第一个参数必须是本类类型对象的引用，不然会引发语法逻辑上的无穷递归引用这个点

假设现在定义一个拷贝构造函数如下，它的第一个参数不是引用

Date(Date d)
    {
	    _year = d._year;
	    _month = d._month;
	    _day = d._day;
    }

且已有一个创建好的该类型的对象d1， 假设将d1作为参数传给函数Func()，即Func(d1)，那么我们可以思考一下这个过程会如何？

首先我们知道，自定义类型的传值传参必须调用拷贝构造，那么此时d1作为一个自定义类型变量传给Func就会自动调用拷贝构造函数，拷贝一份d1传给Func，那么就会进入上方的拷贝构造函数，进入拷贝构造函数，发现拷贝构造函数也是传值传参，按照语法逻辑就会又去调用拷贝构造函数，然后再次进入拷贝构造函数，发现一样的问题就会又再次进入拷贝构造……，就此引发无穷递归

---

4.4 编译器默认生成的拷贝构造函数的行为

若未显式定义拷贝构造函数，编译器会自动生成拷贝构造函数。

自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造

 浅拷贝：

浅拷贝是指创建一个新对象，然后将当前对象的非静态成员变量的值逐个复制给新对象。如果成员变量是值类型（如int、double等基本数据类型），则复制其值；如果成员变量是指针，则复制指针的值，即新对象和原对象的指针指向同一块内存。

也就是说，对于内置类型则直接将其值拷贝给对象，像前面提到过的日期类（成员变量都是内置类型）就是直接使用自动生成的拷贝构造函数进行拷贝

 对于自定义类型的的成员变量则调用它自身的拷贝构造函数来拷贝，自身的拷贝构造函数有时系统自动生成的就可以用，有时候需要自己显示写一个拷贝构造函数

何时需要自己写拷贝构造函数呢？

当成员变量的拷贝涉及深拷贝时，就需要自己显示写拷贝构造函数

深拷贝：

深拷贝是指创建一个新对象，然后将当前对象的非静态成员变量的值逐个复制给新对象。如果成员变量是指针，则会先分配一块新的内存，然后将原对象指针所指向的内存中的数据复制到新分配的内存中，新对象的指针指向这块新内存。

深拷贝和浅拷贝的区别就在于，当变量是指针时，浅拷贝复制的是指针的值，被复制的的对象和复制好的对象都指向同一块空间，对于深拷贝， 会给复制好的对象分配一块新的空间来存取和被复制对象相同的值

 举例：

假设现在有一个Stack类，里面的成员变量的如下，其中有一个成员变量是指针类型

那么此时，假设有两个Stack类型的对象分别为st1和st2，想用st1的值来初始化st2的值，那么此时st1作为参数传给st2的构造函数，传值传参就要进行拷贝构造，但是因为Stack类型具有指针类型的成员变量，必须进行深拷贝，所以就需要自己显示写好拷贝构造函数

总结：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝 

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

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

---

4.5 传值返回时的拷贝

传值返回会产生⼀个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引⽤)，没有产生拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。 

如下面代码，Func函数的返回值是引用，用ret来接收返回的值，按照语法，此时返回给ret的对象是调用拷贝构造函数由st复制出的一个临时对象来返回给ret。但是因为st是Func函数这个局部域里局部变量，Func函数调用完毕后就会销毁建立的栈帧，也就将栈帧里的st一同销毁了，那么此时ret得到的引用就是一个野引用（因为空间已经被销毁释放了），所以此时应该将Stack st;语句改为static Stack st;这个时候st就不存在Func的栈里，而是在静态区，不会随着Func销毁，所以传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。 

Stack& Func()
{
 	Stack st;
	st.Push(1);
	st.Push(2);
	st.Push(3);
	//...
	return st;
}
int main()
{
	Stack ret = Func();
	cout << ret.Top() << endl;
	return 0;
}

5. 赋值重载

5.1 运算符重载

对于像int这样的内置类型，我们对其进行各种运算符（比如+、-、<运算符）进行运算的时候，对于系统来说它是系统直接定义的简单类型，使用运算符的时候会自动生成指令执行

但是自定义类型就不能用系统的指令直接支持，因为这个类型是你自己定义的，系统不认识，也不知道你的运算规则是什么，不能直接转换成指令，所以C++给出了一种解决办法，就是运算符重载 

当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。

同时C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。

运算符重载的格式：

返回值  operator 要重载的符号(参数)

{

        // 函数体....
}

运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。

重载运算符函数的参数个数和该运算符作用的运算对象数量⼀样多。⼀元运算符有⼀个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第二个参数。

假如现在要给日期类对象重载一个<号的函数，来比较日期之间的大小，那么重载的格式如下：

返回值为bool，函数名由operator < 构成，参数由两个日期类的对象构成，因为比较大小的运算符至少要两个运算对象

bool operator<(const Date& d1，const Date& d2)
{
    // 先比较年份
    if (d1._year < d2._year)
    {
        return true;
    }
    else if (d1._year == d2._year)// 年份相等
    {
        if (d1._month < d2._month)// 比较月份
        {
            return true;
        }
        else if (d1._month == d2._month)// 比较日数
        {
            return d1._day < d2._day;
        }
  
    return false;
}

需要注意：运算符重载必须要有一个类类型的形参，像下面的代码在编译时就会报错

// 编译报错：“operator +”必须至少有⼀个类类型的形参

int operator+(int x, int y)
{
        return x - y;
} 

除了上面提到的点，关于运算符重载还有一些要求如下：

①运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致

②不能通过连接语法中没有的符号来创建新的操作符：比如operator@
③ .*   ::   sizeof   ?:   . 注意以上5个运算符不能重载，第一个是.*不是*(选择题里面常考，着重记）
④重载操作符至少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义

*****************************************************************************************************

⑤如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个

⑥⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator/就没有意义
⑦重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分。
⑧重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性
⑨重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象

前面四个都很好理解，我们主要讲后面的几点

如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个

也就是说上面关于Date类比较运算符<的重载，写在Date类内作为成员函数的时候，它的第一个参数d1可以不写，因为成员函数默认第一个参数指向本类对象的this指针，也就是当一个对象调用该成员函数时，该对象就是函数的第一个参数，就相当于如果该运算符需要两个操作数，那么它的第一个操作数就设定死了，就为调用该运算符的对象

bool operator<const Date& d)
{
    // 先比较年份
    if (_year < d._year)// this._year<d._year
    {
        return true;
    }
    else if (_year == d._year)// 年份相等
    {
        if (_month < d._month)// 比较月份
        {
            return true;
        }
        else if (_month == d._month)// 比较日数
        {
            return _day < d._day;
        }
  
    return false;
}

关于哪些运算符应该重载，主要考虑该运算符重载对于该类型是否有意义，比如对于Date类，重载运算符' / '就没有意义，因为对于一个日期来说它没有/的需求的

在重载运算符时还有两个需要记住的点：

①重载++运算符时，前置++和后置++为了方便区分，在格式上有所区别，C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分

依旧以日期类举例若现在要实现前置++和后置++，那么声明时就会有所区别

// ++d1
Date& operator++();

// d1++
// 为了区分，构成重载，给后置++，强行增加了一个int形参
// 这个参数仅仅是为了和前置++构成重载区分，不需要写形参名
Date operator++(int);

在重载流插入<<和流提取>>符号的时候要重载为全局函数，因为成员函数会限制第一个参数为this指针，即this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧的运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性

// 重载
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

重载为全局函数，就可以自己设置第一个参数，重载时把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置为类类型对象

5.2 赋值重载

现在我们已经知道了运算符重载的基本规则，回到正题，如何进行赋值重载即赋值运算符重载？

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于⼀个对象拷贝初始化给另⼀个要创建的对象

5.2.1 赋值重载特点

1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const 当前类类型引用，否则会传值传参会有拷贝
2. 有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景
3. 没有显式实现时，编译器会自动生成⼀个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。

4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。这里还有一个技巧，如果⼀个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要

赋值重载也是一个不写编译器会自动生成的默认成员函数，但是编译器自动生成的只有在只需要浅拷贝时可以使用，如果我们的类型当中创建了资源，比如指针成员变量，拷贝时需要深拷贝，因为拷贝的过程需要再创建一个空间，然后再进行值拷贝 ，此时编译器自动生成的赋值运算符重载就不满足我们的需求，就必须自己定义实现赋值运算符重载

5.2.2 赋值运算符重载格式

• 参数类型：const T&，传递引用可以提高传参效率
• 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值
• 返回*this ：要符合连续赋值的含义

T表示重载该赋值运算符的类类型 

比如Date类的赋值运算符重载可以如下：

Date& operator=(const Date& d)
{
    // 防止自己给自己赋值
    if(this != &d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    return *this;
}

赋值运算符只能重载成类的成员函数不能重载为全局函数，如下方

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    int _year;
    int _month;
    int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
    if (&left != &right)
    {
        left._year = right._year;
        left._month = right._month;
        left._day = right._day;
    }
    return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

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

 5.2.3 默认生成的赋值运算符重载的行为

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝（浅拷贝）。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值

既然是浅拷贝，所以，如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

---

6. 取地址重载

6.1 取地址重载分类

取地址重载分为普通取地址符&重载，以及const取地址操作符&重载

一般情况下不需要我们手动实现，编译器自动生成的就可以使用，只有特殊情况，才需要重载除⾮⼀些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现⼀份，胡乱返回⼀个地址。

class Date
{ 
public :
    Date* operator&()
    {
        return this;
        // return nullptr;
    } 
    const Date* operator&()const
    {
        return this;
        // return nullptr;
    }
private:
    int _year ; // 年
    int _month ; // ⽉
    int _day ; // ⽇
};

上方的可以看到是const取地址操作符重载的函数的后面有一个const修饰

6.2 const修饰成员函数

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，将const修饰的成员函数称之为const成员函数，const修饰成员函数时放到成员函数参数列表的后面即右括号)的后面。
实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

小知识点：const在*的左边修饰指针指向的内容，const在*的右边修饰指针本身

下方代码：

普通对象d1调用被const修饰的成员函数Print没有问题，因为Print的this指针类型就变为

const Date* const this，即this指针指向的内容不能修改，指针本身也不能修改，对于普通对象d1来说这是一种权限的缩小，这是被允许的

但是d2就不能正常调用Print函数，因为d2的类型是const Date*，即没有权限修改指针指向的内容不能修改，但是，将d2的指针传给Print函数，Print函数接收的指针类型是Date* const，可以修改指针指向的内容，这就是一种权限的放大，不被允许，故会报错

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// void Print(const Date* const this) const
	void Print() const
	{
		//_year++;//函数加上const，无法再对成员变量进行修改
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	// 这里非const对象也可以调用const成员函数是一种权限的缩小
	Date d1(2024, 7, 5);
	// &d1->Date*
	d1.Print();

	const Date d2(2024, 7, 5);
	// &d2 -> const Date* 
	d2.Print();// 报错，将const Date* 传给Date* const

	return 0;
}

---

完