【C++】类与对象（二）

「前言」

🌈个人主页： 代码探秘者
🌈C语言专栏：C语言
🌈C++专栏： C++
🌈喜欢的诗句:天行健,君子以自强不息.

目录

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

二、构造函数

2.1 构造函数概念

2.2 构造函数的特性

三、析构函数

3.1 析构函数的概念

3.2 析构函数的特性

四、拷贝构造函数

4.1 拷贝构造函数概念

4.2 拷贝构造函数的特性

五、赋值运算符重载

5.1 运算符重载

5.2 赋值运算符重载

六、const 成员

七、取地址及const取地址操作符重载

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

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

class Date {};

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

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

其中，构造函数、析构函数，拷贝构造函数、赋值重载 重点学，最后两个关于取地址重载不重要，简单了解即可

这些函数都不是普通函数，不能以普通函数的定义和调用规则去理解它们

二、构造函数

2.1 构造函数概念

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该函数方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

Date类代码如下：

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(2022, 9, 29);
	d1.Print();
	Date d2;
	d2.Init(2022, 9, 30);
	d2.Print();
	return 0;
}

上面的初始化每次都要调用 Init 进行初始化，这样很不方便，接下来构造函数就要登场了

构造函数的概念：

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

如何创建构造函数，请看构造函数的特性，方便说构造函数的特性

2.2 构造函数的特性

（1）

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

• 构造函数可以有参数，可以重载
• 函数名与类名相同
• 无返回值也不写void
• 对象实例化时编译器自动调用对应的构造函数，无需手动调动，而且只调用一次

注：构造函数是可以有多个的，有多个构造函数也说明可以有多种初始化方式，其他情况下面有解释

class Date
{
public:
	//1、无参构造函数
	Date()
	{}
	
	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;// 自动调用无参构造函数
	Date d2(2022, 9, 30);// 自动调用带参的构造函数
	return 0;
}

（3）
写了没有参数的构造函数（如上代码注释的第一点），创建类类型无参，如d1，则自动调用无参的构造函数进行初始化；
写了有参数的构造函数（如上代码注释的第二点），创建类类型有参，如d2，则自动调用有参的构造函数进行初始化

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

// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
Date d3（）；

（4）
简单说就是创建对象是无参的，构造函数也是无参的，对象后不用加 （），这是语法规定的，否则就会报出警告

（5）
构造函数可以重载

如上面代码中的 Date ，参数个数不同

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

测试代码：

class Date
{
public:
	如果用户显式定义了构造函数，编译器将不再生成
	//Date()
	//{}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	//如果将上面定义的构造函数放开，则调用自己创建的构造函数
    Date d3;
	return 0;
}

（7）关于编译器生成的默认成员函数，我们很多会有疑惑：

• 不实现构造函数的情况下，编译器会生成默认的构造函数
• 但是看起来默认构造函数又没什么用？d 对象调用了编译器生成的默认构造函数，但是 d对象 _year/_month/_day，依旧是随机值
• 也就说在这里编译器生成的默认构造函数并没有什么用？

测试代码：

class Date
{
public:
	//没有定义构造函数，编译器默认调用自动生成的构造函数

private:
	int _year;
	int _month;
	int _day;
};

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

解答：

• C++把类型分成内置类型(基本类型)和自定义类型
• 内置类型就是语言提供的数据类型，如：int/char…还包括所有类型的指针，
• 自定义类型就是我们使用class/struct/union 等自己定义的类型，如栈、队列…

C++ 对内置类型不作处理，也就是不调用构造函数，自定义类型则自动调用它的默认构造函数

看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员 _t 调用的它的默认成员函数

测试代码：

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

_t 自动调用它的默认成员函数

对内置类型不作处理，是 C++ 在早期设计时的语法缺陷，后面也发现了这个问题，因为 C++ 要向前兼容，对内置类型就不作处理了，而是打了个补丁

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值

测试代码：

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 2022;//不是定义，依旧是声明，给的值是缺省值
	int _month = 9;
	int _day = 30;
};
int main()
{
	Date d;
	return 0;
}

注意：这里给的默认值是缺省值，不是定义，依旧是声明（这个补丁雀实会给很多初学者造成困扰，很多人会认为它是初始化，其实它是缺省值）

（7）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数

总结：不传参数就可以调用的构造函数，就叫默认函数

以下测试代码能通过编译吗

class Date
{
public:
	//无参构造函数
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	//全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
// 以下测试函数能通过编译吗？
int main()
{
	Date d;
	return 0;
}

答案是不能，因为默认构造函数只能有一个，有多个调用是会造成歧义，编译器不知道调用哪一个

2.3 构造函数调用规则

重要两点：

（1）

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Person
{
public:
	//无参构造函数（默认构造）
	Person()
	{
		cout << "无参（默认）构造函数调用" << endl;
	}
	//有参构造函数
	Person(int a)
	{
		_age = a;
		cout << "有参构造函数调用" << endl;
	}

	int _age;
};
int main()
{
	Person p;
	p._age = 19;
	//默认有拷贝构造
	Person p2(p);
	cout << p2._age << endl;
	return 0;
}

运行结果：

理解：写有参构造函数，提供默认拷贝构造（只是值拷贝的）

（2）
不提供默认无参构造：
我把刚刚的自己写的默认（无参）构造注释掉

运行：

理解：

• 写有参构造函数，c++不通过默认无参构造了
• 默认构造必须要有一个
• 所以要写自己写一个，不要注释掉了

（3）通过拷贝构造函数

理解：写构造函数，上面我们提的默认无参构造函数，有参构造都不提供。自然报错！

三、析构函数

3.1 析构函数的概念

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

析构函数的功能与之前数据结构中使用的顺序表、栈销毁函数Destory 功能相似。

3.2 析构函数的特性

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

1. 析构函数名是在类名前加上字符 ~
2. 无返回值类型也不写void
3. 不可以有参数，因此不可以发生重载（构造函数可以）
4. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
5. 对象生命周期结束时，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 = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

 int main()
{
	 Stack s;
	 s.Push(1);
	 s.Push(2);
	return 0;
}

对象生命周期结束时，自动调用析构函数，对空间资源进行释放清理

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

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

测试代码：

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

运行结果打印了 ~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）如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类

我怎么知道要不要写析构函数和构造函数？

• 看面向需求：编译器默认生成就可以满足，就不用自己写，不满足就需要自己写
• 比如，Date Stack的构造函数需要自己写，不写就会调用编译器默认生成的构造函数，初始化成随机数，这随机数不是我们想要的初始数据，所以需要自己写
• 比如，用栈实现队列，MyQueue 构造函数就不需要自己写，默认生成就可以用
• 比如，Stack栈的析构函数，需要我们自己写，不写就会造成内存泄漏
• 比如，MyQueue Date就不需要自己写析构函数，默认生成就可以用，没有需要清理的空间

构造函数和析构函数极大方便了我们，特别是有时候忘记初始化数据和忘记释放空间， 构造函数和析构函数就帮我们擦屁股了，很方便

3.3 析构的陷阱（浅拷贝和深拷贝）

• 浅拷贝：简单的赋值拷贝操作（连名带抄）
• 深拷贝：在堆区重新申请空间，进行拷贝操作

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "无参（默认）构造函数调用" << endl;
	}
	//有参构造
	Person(int age, int height)
	{
		cout << "有参构造函数调用" << endl;
		_age = age;
		_height = new int(height);	//这里要开辟哦
	}
	//拷贝构造函数
	Person(const Person& p)
	{
		cout << "拷贝构造函数调用" << endl;
		_age =p._age;
		_height = p._height;				//编译器默认生成是这样的
		//_height = new int(*p._height);		//深拷贝改浅拷贝
	}
	//析构函数
	~Person()
	{
		cout << "析构函数调用" << endl;
		if (_height != nullptr)
		{
			delete _height;
			_height = nullptr;
		}
	}
	int _age;		//年龄
	int* _height;	//身高
};
int main()
{
	Person p1(18,163);
	//拷贝构造
	Person p2(p1);
	cout<<"p1:"<< p1._age << *(p1._height) << endl;

	cout << "p2:"<<p2._age << *(p2._height) << endl;
	return 0;
}

运行为什么报错：

• 拷贝构造默认生成是值拷贝（浅拷贝）
• 浅拷贝就是简单赋值，但我有一个指针，意思说这样会导致p2拷贝p1（连指针部分都和p1的指针指向同一个地方）
• 析构函数调用，同样的指针析构两次，报错！

把拷贝构造的浅拷贝变深拷贝(就是new一下),解决了

• 深拷贝（开辟新的），再拷贝
• 析构（你析构你的，我析构我的），并没有一个指针析构两次
  

3.3 析构函数调用顺序

例题：

析构函数是在对象的生命周期到了之后 才会调用清理资源
所以我们就看哪些对象生命周期先到

• a b是main函数调用结束 其次就是先定义后析构的原则（先定义a,后定义b ，所以先析构b后析构a）
• 全局对象 和静态局部对象 都是在程序结束之前(再main函数结束后面) （再按定义顺序，先定义c，后d，所以先析构d后c）

---

• 动态开辟的，析构函数的调用发生在delete或delete[]操作时（在main函数结束之前）（所以先pa后 b）

• 总结： 四种同时出现，注意看delete，定义先后顺序，以及是什么类型的等等

四、拷贝构造函数

4.1 拷贝构造函数概念

已经创建的对象初始化一个新对象
在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

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

4.2 拷贝构造函数的特性

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

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

测试代码：

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d) // 正确写法
	//Date(Date d) // 错误写法：编译报错，会引发无穷递归
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

运行结果，d2 拷贝了 d1

• 如果是传值传参的方式，编译器直接报错
• 因为使用传值传参的过程中，编译器会自动调用拷贝构造函数，使用拷贝构造函数就必须得先传参，传参又会调用拷贝构造函数，一直调用下去就会造成无穷递归（图中的const 先无视，下面讲，有没有const都差不多）

（2）值传递给函数参数
先以传值的方式（值传递给函数参数）会自动调用拷贝构造函数
原因：值传递是拷贝出一个副本，不影响实参

测试代码：

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 1)
		{
			_year = year;
			_month = month;
			_day = day;
		}

	Date(Date& d) 
	{
		cout << "测试谁自动调用了拷贝构造函数" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
//值传递
void Func1(Date d)
{
	//预测：传值传参会调用拷贝构造函数
	cout << "Func1()" << endl;
}

void Func2(Date& d)
{
	//预测：引用传参不会调用拷贝构造函数
	cout << "Func2()" << endl;
}

int main()
{
	Date d1(2022, 9, 22); // 构造 - 初始化
	Func1(d1);
	cout << "------我是分割线------" << endl;
	Func2(d1);
	return 0;
}

运行结果说明传值方式会自动调用拷贝构造函数

说一下 对类类型对象的引用一般常用const修饰的原因

就是为了防止有些人头脑发热把代码写反了，比如把_day = d._day 写成 d._day = _day;

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d) 
	{
		_year = d._year;
		_month = d._month;
		d._day = _day;//错误，写反了
		//_day = d._day;//正确
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

运行结果，d2 反而把 d1的值改掉了

加上 const ，编译器直接检测报错

（3）

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 2022;
	int _month = 10;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1;
	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
	//Date类里面的自定义类型 _t 则调用它自己拷贝构造函数
	Date d2(d1);
	return 0;
}

运行结果说明了自定义类型是调用其拷贝构造函数完成拷贝的

（4）

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

测试代码：

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
		free(_array);
		_array = nullptr;
		_capacity = 0;
		_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	
	Stack s2(s1);
	return 0;
}

运行时崩溃的，因为这种默认生成的拷贝构造函数，拷贝都是浅拷贝，没有进行深拷贝，进行浅拷贝的结果就是两个栈共用同一块空间，进行析构清理的时候同一块空间被释放了两次，运行自然就崩溃了（深拷贝后面会用一个大章节去讲，这里先知道即可）

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝
（5）值方式返回局部对象
方便演示：假设有一个Person类
这里不是返回p1哦，因为它是局部对象，而是p1拷贝出一个对象返回 。

Person doWork
{
	Person p1;
	cout<<(int*)&p1<<endl;
	return p1;			//值方式返回局部对象
}
int main()
{
	Person p=doWork();
	cout<<(int*)&p<<endl;
}

所以p1的地址和p的地址不一样

总结两点：

1. 需要写析构函数的类，都需要写深拷贝的拷贝构造 如 Stack
2. 不需要写析构函数的类，默认生成的浅拷贝的拷贝构造就可以用 如Date/MyQueue

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

1. 使用已存在对象创建新对象
2. 函数参数类型为类类型对象
3. 函数返回值类型为类类型对象

五、运算符重载

为什么要？

• 两个int型知道怎么运算，那么两个自定义类型怎么运算

总结：

• 函数名字为：关键字operator后面接需要重载的运算符符号
• 函数原型：返回值类型 operator操作符(参数列表)
• 参数：操作符有几个操作数，它就有几个参数

注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义（1+1 不能改成=0）
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现

5.1 重载关系运算符（复用）

（1）==

比如要两个类日期 d1/d2 要进行比较是否相等， 必须要对 == 进行运算符重载，否则就无法比较，默认情况C++是不支持自定义类型对象使用运算符

测试代码：

// 全局的operator==
class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private://私有
	int _year;
	int _month;
	int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。

//关键字operator 后面接需要重载的运算符符号,如 operator==
bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}

int main()
{
	Date d1(2022, 10, 2);
	Date d2(2022, 10, 3);
	//cout << d1 == d2 << endl;//error,要加括号使 d1 == d2 优先进行运算
	cout << (d1 == d2) << endl;//d1 == d2 编译器自动转换成 operator==(d1, d2);
	return 0;
}

运行结果是 false，说明两个日期不相等

• 运算符重载成全局的就需要成员变量是公有的，破坏了类的封装。

• 可以用后面学习的友元函数解决，或者干脆重载成成员函数

这里可以把 operator== 放到类里面去，这样就可以直接使用类里面的私有成员了，没有破坏类的封装，但是放到类里面有一个问题，如下：

测试代码：

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& d1, const Date& d2)
	{
		return d1._year == d2._year
			&& d1._month == d2._month
			&& d1._day == d2._day;
	}

	private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 10, 2);
	Date d2(2022, 10, 3);
	//cout << d1 == d2 << endl;//error,要加括号使 d1 == d2 优先进行运算
	cout << (d1 == d2) << endl;
	return 0;
}

运行是无法运行的，会显示参数过多

这是为什么，代码也没有错，怎么解决？

• 别忘了，类成员函数还有一个默认的 this 指针，参数加起来有三个，而 = 只有两个操作数，参数明显超了，所以报错会显示参数太多
• 不要忘记了这句话，参数：操作符有几个操作数，它就有几个参数
• 修改后，默认隐藏的 this 指针可以当作第一个操作数，再补一个参数就可以了

修改后代码：

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    // bool operator==(Date* this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
	bool operator==(const Date& d2)
	{
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 10, 2);
	Date d2(2022, 10, 3);
	//cout << d1 == d2 << endl;//error,要加括号使 d1 == d2 优先进行运算
	cout << (d1 == d2) << endl;
	return 0;
}

运行就成功了

---

（2）!=（复用）

• “==”和“!=”也是可以实现一个，之后复用（两个是相反得）
• 

---

（3）进一步了解日期类（> < >= <=）

想要进一步了解关于日期类实现

• 这里有> < >= <=得重载（实现一个，之后三个依次复用）
• 比如：
  
  

5.2 =（赋值运算符）

（1）赋值运算符重载格式

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

测试代码：

class Date
{
public:
	Date(int year = 2022, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//赋值运算重载
	Date& operator=(const Date& d)
	{
		if (this != &d)//极端情况下自己给自己赋值
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 10, 2);
	Date d2(2022, 11, 3);
	
	// 拷贝构造：一个已经存在的对象拷贝初始化一个马上创建实例化的对象
	Date d3(d1);  // 拷贝构造
	Date d4 = d1; // 拷贝构造

	// 赋值运算符重载：两个已经存在的对象之间进行赋值拷贝
	d1 = d2; // 赋值运算符重载：编译器自动转换d1.operator=(d3)
	return 0;
}

运行结果，调试看 d1 = d2

注意区分拷贝构造和赋值运算重载，上面已经注释有了，不再多说。

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

意思就是说赋值运算符重载只能写在类里面，不能写到全局域里面

测试代码：

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//private:
	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;
}

编译失败

原因：

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

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

注意:内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值

• 编译器生成的默认赋值运算符重载函数只是进行了浅拷贝

• 深拷贝需要自己实现

• 如果类中未涉及到资源管理，赋值运算符是否实现都可以，一旦涉及到资源管理则必须要实现

比如成员函数是这个

5.3 +（以及本质）

这里是两个类加
如果在类内用成员函数和类外全局函数分别实现

#include<iostream>
using namespace std;
class Person
{
public:
	//类内成员函数实现
	//包括this和p1，两个两个参数了
	//Person operator + (const Person& p1)
	//{
	//	Person tem;
	//	tem._age = this->_age + p1._age;
	//	tem._height = this->_age + p1._height;
	//	return tem;
	//}
	
	//这里类内实现：私有和公有都行
	//全局实现：需要公有
	int _age;
	int _height;
};
//类外全局函数实现
//没有this  所以写p1和p2
Person operator+(Person& p1,Person& p2)
{
	Person tem;
	tem._age = p1._age + p2._age;
	tem._height = p1._height + p2._height;
	return tem;
}
int main()
{
	Person p1;
	p1._age=18;
	p1._height = 58;
	Person p2;
	p2._age = 16;
	p2._height =48;

	Person p3 = p1 + p2;
	cout << "p3:" << p3._age<<" " << p3._height << endl;
	return 0;
}

运行：

Person p3=p1+p2;
//全局函数重载本质
Person p3=operator+(p1,p2);
//成员函数重载本质
Person p3=p1.operator+(p2);

当然也可以一个类加int

Person p3=p1+10;		//自己实现

---

5.4 前置++和后置++重载

• 前置++：返回+1之后的结果
• 后置++：后置++是先使用后+1，前置++和后置++都是一元运算符
• 返回引用：方便连续引用

---

为了让前置++与后置++形成能正确重载

• C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

测试代码：

class Date
{
public:
	Date(int year = 2021, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 前置++：返回+1之后的结果
	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
	Date operator++(int)		//多了一个int
	{
		Date temp(*this);		//先拷贝一个
		_day += 1;
		return temp;			//返回原来的值，自己再+1
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	Date d1(2022, 10, 1);
	d = d1++; // d:2022,10,1    d1:2022,10,2
	d = ++d1; // d:2022,10,3   d1:2022,10,3
	return 0;
}

只截了 d = d1++ 这一步完成的图，下一步 d = ++d1 自行调试查看

5.5 重载左移<<和右移>>运算符

代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Person
{
public:
	friend ostream& operator<<(ostream& cout, Person& p);
	friend istream& operator>>(istream& in, Person& p);
	Person() {};
	Person(int age,int height)
	{
		_age = age;
		_height = height;
	}
private:
	int _age;
	int _height;
};
//要写成全局
//<<  
ostream& operator<<(ostream& out,Person& p)
{
	out << "身高体重:" << p._age << " " << p._height << endl;
	return cout;			//写返回
}
//>>
istream& operator>>(istream& in, Person& p)
{
	cout << "请输入年龄和体重:>";
	in >>p._age>>p._height;
	return in;
}
int main()
{
	//测试<<
	Person p1(18,58);
	cout << p1 << endl;
	//测试>>
	Person p2;
	cin >> p2;
	cout << p2 << endl;
	return 0;
}

测试<< p1:

测试>> p2:

点击cin，转到定义：

• cin是istream 里的一个对象，处理标准输出
• cout是ostream里的一个对象，处理标准输入
  
• <<和>>一定要写在全局，得访问成员变量，所以加友元函数
  

关于返回值：

• 这里out也可以写cout，一个别名而已
  

• 如果不写返回值

//只能这么写
cin>>p1;
//本质cin.operator>>(p1);

• 如果写返回值istream&

//后面可以加一堆东西
cout<<p1<<"中国"<<endl；

• 因为先执行这里
• 
  然后返回一个istream，依次如下面所示：

//后面可以加一堆东西
cout<<p1<<"中国"<<endl；			//先输出p1
cout<"中国"<<endl；				//再输出中国
cout<<endl；					//再输出换行

5.6 重载（） -仿函数

• 重载operator() 的函数就是仿函数

#include<iostream>
using namespace std;
class Person
{
public:
	//仿函数
	void operator()(string s)
	{
		cout << "仿函数打印：" << s << endl;
	}
};
//普通函数
void Print(string s)
{
	cout << "普通函数打印：" << s << endl;
}
int main()
{
	//测试仿函数
	Person p1;
	p1("lan");

	//测试
	Print("huang");
	return 0;
}

运行：

总结一下：

• 默认生成的四个默认成员函数，构造函数和析构函数的处理机制是基本类似的

• 拷贝构造和赋值重载处理机制也是类似的（编译器默认生成的值拷贝（浅拷贝），所以要深拷贝就直接写）

-------------------我是分割线--------------------------------------------------

六、const 成员 （几个常错点）

将 const修饰的“成员函数”称之为 const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的 this指针，表明在该成员函数中不能对类的任何成员进行修改。

基本的修饰方法如下，在类成员函数的括号后加 const即可

void Print()const
{}

const 实际修饰的是该函数隐含的 this指针

this 指针本身是 类名* const 类型的，比如日期类的this指针类型是 Date* const，用 const修饰后变为 const 类名* const 类型，比如日期类的 this指针被const修饰后，类型变成了 const Date* const，该this指针是隐藏的，不显示。

测试代码：

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print1()//void Print(Date* this)
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 10, 3);
	d1.Print1();//ok

	
	return 0;
}

该段代码是可以正常运行的，如果再创建一个变量用 const修饰就不能运行了，因为权限被放大了，权限只能缩小和平行，不能被放大，这个在C++入门中引用讲过了，自行翻阅

const Date d2(2022, 10, 3);
	d2.Print1();//error，

这时候如果我们在函数后面加了const，就可以避免此种权限放大问题。这样不管是上面的 d1/d2 就都可以正常打印了！

-------------------我是分割线--------------------------------------------------
常函数（成员函数后面加const）

• 不可以修改成员属性
• 如果成员属性声明关键字mutable，在常函数依然可以修改

常对象（声明对象前前加const）

• 常对象只能调用常函数

-------------------我是分割线--------------------------------------------------
原因：

不能权限放大（以下犯上），可以权限缩小

1. const对象不可以调用非const成员函数（权限放大）
2. 非const对象可以调用const成员函数（权限缩小）
3. const成员函数内不可以调用其他非const成员函数（权限放大）
4. 非const成员函数可以独调用其他const成员函数（权限缩小）

-------------------我是分割线-------------------------------
const 修饰成员函数什么时候需要使用？

成员函数加 const，变成 const成员函数是有好处的，这样 const对象可以调用，非 const对象也可以调用

-------------------我是分割线-------------------------------
const修饰指针有下面两种形式（指针章节已经写有）

• 在*之前修饰，代表该指针指向对象的内容不能被修改（地址里的内容不能改）
• 在*之后修饰，代表该指针指向的对象不能被修改（指向的地址不能改）

-------------------我是分割线-------------------------------
注意

1. this指针本身就是 类型名* const 类型的，它本身不能被修改。
2. 加上 const之后，this指向的内容和类里面的成员变量都不能被修改了，知道了这一点后。
3. 我们可以合理的判断出：只要是需要修改类中成员变量的函数，就不需要在()后面加 const修饰，如果一个函数中不需要修改成员变量，就可以加const进行修饰

void Print1（）
{
		//this=NULL；  		this不能修改
		this->_age=10; 		//this指向的值可以修
}
void Print2（）const
{
		//this=NULL；  			this不能修改
		//this->_age=10;  		//加const，this指向的值也不能修改
}

注意

如果你用了声明和定义分离的写法，那么声明和定义的函数都需要加上 const修饰

-------------------我是分割线-------------------------------

七、取地址及const取地址操作符重载

最后两个默认成员函数，编译器会自动生成。这两个函数一般都不需要重载

测试代码：

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; 
	int _month; 
	int _day; 
};

int main()
{
	Date d1(2022, 10, 1);
	const Date d2(2022,10, 2);

	cout << &d1 << endl;
	cout << &d2 << endl;

	return 0;
}

说白了就是用来取类对象地址的

说明：

• 一般不需要写，编译器生成的就够用（上面写出来方便理解）
• 如果非要写，比如不想让别人获取对象的地址，就可以自己实现，返回 nullptr

--------------------- END ------------------------------------------------------

「 作者 」 代码探秘者
「 更新 」 2024.9.30