• lesson-2C++类与对象(中)

    个人主页：Lei宝啊 

    愿所有美好如期而遇

    目录

    类的6个默认成员函数

    构造函数

    概念

    特性

    析构函数

    概念

    特性

    拷贝构造函数

    概念

    特性

    赋值运算符重载

    运算符重载

    赋值运算符重载

    前置++和后置++重载

    日期类的实现

    类的6个默认成员函数

    如果一个类中什么成员都没有，简称为空类。 
    1. class null   //null是类名
    2. {
    3.  
    4. };
    空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员
    函数。

    构造函数

    概念

    我们可以先通过一个对象的初始化函数引入。

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. class Date
    5. {
    6.  
    7. public:
    8. 	void Init(int year, int month, int day)
    9. 	{
    10. 		_year = year;
    11. 		_month = month;
    12. 		_day = day;
    13. 	}
    14.  
    15. 	void Print()
    16. 	{
    17. 		cout << _year << "-";
    18. 		cout << _month << "-";
    19. 		cout << _day << endl;
    20. 	}
    21.  
    22. private:
    23. 	int _year;
    24. 	int _month;
    25. 	int _day;
    26. };
    27.  
    28. int main()
    29. {
    30. 	Date a;
    31.  
    32. 	a.Init(2023, 10, 20);
    33. 	a.Print();
    34.  
    35. 	return 0;
    36. }

    每一次我们创建出一个对象都要手动为其初始化，如果忘了的话，轻点是随机值，重点程序就崩了，所以我们的构造函数就解决了这个问题。

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

    看代码。 

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. class Date
    5. {
    6.  
    7. public:
    8. 	
    9.     //构造函数支持重载
    10. 	Date()
    11. 	{
    12. 		_year = 1;
    13. 		_month = 1;
    14. 		_day = 1;
    15. 	}
    16.  
    17. 	Date(int year, int month, int day)
    18. 	{
    19. 		_year = year;
    20. 		_month = month;
    21. 		_day = day;
    22. 	}
    23.  
    24.  
    25. 	void Print()
    26. 	{
    27. 		cout << _year << "-";
    28. 		cout << _month << "-";
    29. 		cout << _day << endl;
    30. 	}
    31.  
    32. private:
    33. 	int _year;
    34. 	int _month;
    35. 	int _day;
    36. };
    37.  
    38. int main()
    39. {
    40. 	Date a;
    41. 	a.Print();
    42. 	
    43. 	return 0;
    44. }

     我们可以看到我们a对象里的年月日确实有值了，被我们所写的的默认构造函数所调用，并全部赋值为1.

    接下来我们试试有参数的构造函数。

    1. int main()
    2. {
    3.  
    4. 	Date a(2023,10,21);
    5. 	a.Print();
    6. 	
    7. 	return 0;
    8. }

    我们发现编译器调用的是我们有参数的构造函数。

    特性

    构造函数 是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
    务 并不是开空间创建对象，而是初始化对象 。
    其 特征 如下：
    1. 函数名与类名相同。
    2. 无返回值。
    3. 对象实例化时编译器 自动调用 对应的构造函数。
    4. 构造函数可以重载。

     在上述代码中，也体现出了构造函数的这四个特性。

    但是有几点我们要注意

    1：没有参数的构造函数，系统默认的构造函数，全缺省的构造函数，都叫做默认构造函数，而这三个构造函数不可同时写出，任意二者不可同时存在，我们看代码解释。

    1. class Date
    2. {
    3. public:
    4.  
    5. 	Date()
    6. 	{
    7. 		_year = 1;
    8. 		_month = 1;
    9. 		_day = 1;
    10. 	}
    11.  
    12. 	Date(int year = 10, int month = 10, int day = 10)
    13. 	{
    14. 		_year = year;
    15. 		_month = month;
    16. 		_day = day;
    17. 	}
    18.  
    19.  
    20. private:
    21. 	int _year;
    22. 	int _month;
    23. 	int _day;
    24. };
    25.  
    26. int main()
    27. {
    28.  
    29. 	Date a;
    30.  
    31. 	return 0;
    32. }

    因为编译器无法区分到要调用哪个构造函数，所以就报错了。

    2：当我们定义了构造函数后，编译器不会再生成默认构造函数，但这样也会出现一个小问题需要我们去掌控。

    1. class Date
    2. {
    3. public:
    4.  
    5. 	Date(int year, int month, int day)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10. 	}
    11.  
    12. private:
    13. 	int _year;
    14. 	int _month;
    15. 	int _day;
    16. };
    17.  
    18. int main()
    19. {
    20.  
    21. 	Date a;
    22.  
    23. 	return 0;
    24. }

    因为我们自定义了一个构造函数，所以系统不会再生成默认构造函数，而我们实例化的对象要调用无参的构造函数，但是我们又没有无参的构造函数，所以编译器就只能报错，我们后面会讲到有解决方法。

    3.如果说我们没有写构造函数，内置类型的成员变量使用系统的默认构造函数，不会做处理，自定义类型的成员变量会去调用他自己的默认构造函数。

    解释：内置类型就是系统自带的，比如int，double之类的，像类和结构体等就是自定义类型。

    1. class Stack
    2. {
    3.  
    4. public:
    5. 	Stack(int capacity = 4)
    6. 	{
    7. 		_capacity = capacity;
    8. 		int top = 0;
    9. 		int* a = (int*)malloc(sizeof(int) * capacity);
    10. 	}
    11.  
    12. 	~Stack()
    13. 	{
    14. 		free(_a);
    15. 		_top = 0;
    16. 		_capacity = 0;
    17. 	}
    18.  
    19. private :
    20. 	int* _a;
    21. 	int _top;
    22. 	int _capacity;
    23.  
    24. };
    25.  
    26. class Queue
    27. {
    28. 	Stack _a;
    29. 	Stack _b;
    30. 	int size;
    31. };
    32.  
    33. int main()
    34. {
    35.  
    36. 	Stack a;
    37. 	Queue b;
    38.  
    39. 	return 0;
    40. }

    细心的朋友们可能会发现size被初始化为0了，你不是说内置类型的变量不初始化吗？是的，但是不同的编译器处理结果不同，我这个是Visual Studio 2022 ，在2013下是不会给初始化的，我们想要我们写出的代码具有跨平台性，就不要寄希望于编译器会给优化，所以我们就当做他不会给优化处理，写出优质代码。

    4：C++11新特性，允许声明成员变量时给默认值。

    1. class Date
    2. {
    3.  
    4. public:
    5. 	void Print()
    6. 	{
    7. 		cout << _year << _month << _day;
    8. 	}
    9.  
    10. private:
    11. 	int _year = 1;
    12. 	int _month = 1;
    13. 	int _day = 1;
    14. };
    15.  
    16. int main()
    17. {
    18.  
    19. 	Date a;
    20. 	a.Print();
    21.  
    22. 	return 0;
    23. }

    析构函数

    概念

    通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
    析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
    编译器完成的。而 对象在销毁时会自动调用析构函数，完成对象中资源的清理工作 。
    像我们上面有代码~Stack就是析构函数。

    特性

    析构函数 是特殊的成员函数，其 特征 如下：
    1. 析构函数名是在类名前加上字符 ~ 。
    2. 无参数无返回值类型。
    3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
        注意：析构函数不能重载
    4. 对象生命周期结束时， C++ 编译系统系统自动调用析构函数

     我们来测试一下。

    1. class Stack
    2. {
    3.  
    4. public:
    5. 	Stack(int capacity = 4)
    6. 	{
    7. 		_capacity = capacity;
    8. 		int top = 0;
    9. 		int* a = (int*)malloc(sizeof(int) * capacity);
    10. 	}
    11.  
    12. 	~Stack()
    13. 	{
    14. 		free(_a);
    15. 		_top = 0;
    16. 		_capacity = 0;
    17. 		cout << "haha" << endl;
    18. 	}
    19.  
    20. private :
    21. 	int* _a;
    22. 	int _top;
    23. 	int _capacity;
    24.  
    25. };
    26.  
    27. class Queue
    28. {
    29. 	Stack _a;
    30. 	Stack _b;
    31. 	int size;
    32. };
    33.  
    34. int main()
    35. {
    36.  
    37. 	Queue b;
    38.  
    39. 	return 0;
    40. }

    结果显而易见，我们的确是调用了析构函数。

    拷贝构造函数

    概念

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

    特性

    我们先来写一段代码证明拷贝构造函数的必要性

    首先是日期类的测试

    1. class Date
    2. {
    3.  
    4. public:
    5. 	Date(int year = 2023, int month = 10, int day = 22)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10.  
    11. 		cout << "Date的构造" << endl;
    12. 	}
    13. 	
    14. private:
    15. 	int _year;
    16. 	int _month;
    17. 	int _day;
    18.  
    19. };
    20.  
    21. void func1(Date a)
    22. {
    23. 	cout << "func1(Date a)" << endl;
    24. }
    25.  
    26. int main()
    27. {
    28.  
    29. 	Date d1(2023, 10, 22);
    30. 	func1(d1);	
    31.  
    32. 	return 0;
    33.  
    34. }
    注意日期类函数调用的析构函数是系统默认的，而且也没什么需要释放的。
    所以在我们将d1这个对象传给func1这个函数的时候时值传递，当fun1结束时，a这个对象要销毁，会去调用析构函数。
    接下来我们来看栈这个类 
    1. class Stack
    2. {
    3.  
    4. public:
    5. 	Stack(int capacity)
    6. 	{
    7. 		_capacity = capacity;
    8.  
    9. 		int top = 0;
    10. 		_a = (int*)malloc(sizeof(int) * _capacity);
    11. 		if (_a == nullptr)
    12. 		{
    13. 			perror("malloc");
    14. 		}
    15.  
    16. 		cout << "Stack的构造" << endl;
    17. 	}
    18.  
    19. 	~Stack()
    20. 	{
    21. 		free(_a);
    22. 		_a = nullptr;
    23.  
    24. 		_top = 0;
    25. 		_capacity = 0;
    26.  
    27. 		cout << "Stack的析构" << endl;
    28. 	}
    29. 	
    30. private:
    31. 	int* _a;
    32. 	int _top;
    33. 	int _capacity;
    34.  
    35. };
    36.  
    37. void func2(Stack st)
    38. {
    39. 	//...
    40. }
    41.  
    42. int main()
    43. {
    44. 	
    45. 	Stack st1(4);
    46. 	func2(st1);
    47.  
    48. 	return 0;
    49.  
    50. }

    这个栈类再这么调用就会出问题，当st销毁时，去调用我们所写的析构函数，在func2函数结束时会释放一次_a，当主函数中的对象st1销毁时，会对已经释放的那块空间再释放一次，这样程序就崩溃了，因为此时的_a就是野指针了，别忘了我们是传值，空间释放后_a就成了野指针，释放野指针指向的空间是不合法的，所以就崩了。

    那也许有人会说，我传引用不就好了吗，但是假设我们有一个需求，不改变对象本身，就是要拷贝一份去实现，那么拷贝构造就凸显出作用来了。(如果还有人说栈这个类我用系统默认的析构函数不好吗？那您可真是昏了头了)

    拷贝构造函数也是特殊的成员函数，其 特征 如下：
    1. 拷贝构造函数 是构造函数的一个重载形式 。 
    1. Stack(int capacity)
    2. {
    3. 	_capacity = capacity;
    4.  
    5. 	int top = 0;
    6. 	_a = (int*)malloc(sizeof(int) * _capacity);
    7. 	if (_a == nullptr)
    8. 	{
    9. 		perror("malloc");
    10. 	}
    11.  
    12. 	cout << "Stack的构造" << endl;
    13. }
    14.  
    15. //拷贝构造
    16. Stack(const Stack& st)
    17. {
    18. 	_top = st._top;
    19. 	_capacity = st._capacity;
    20. 	_a = (int*)malloc(sizeof(int) * _capacity);
    21. 	if (_a == nullptr)
    22. 	{
    23. 		perror("malloc");
    24. 	}
    25. }

    2. 拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 ，使用 传值方式编译器直接报错 ，
    因为会引发无穷递归调用。
    拷贝构造参数不引用为什么会引发无穷递归呢？
    首先要明白在传值拷贝自定义类型定义出的对象时，编译器会去调用他的拷贝构造，我们传值传参Stack类型的对象，也就是要拷贝一份给参数，所以编译器会去调这个对象的拷贝构造，我们去掉引用后的拷贝构造是这个样子的 
    1. Stack(const Stack st)
    2. {
    3. 	_top = st._top;
    4. 	_capacity = st._capacity;
    5. 	_a = (int*)malloc(sizeof(int) * _capacity);
    6. 	if (_a == nullptr)
    7. 	{
    8. 		perror("malloc");
    9. 	}
    10. }

    接下来我们通过图解来看一看无穷递归的出现原因。

    所以我们要加上&。

    3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
    字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
    我们的日期类是不用我们再去单独写拷贝构造函数的，因为系统默认的拷贝构造函数就是值拷贝。
    4 拷贝构造函数典型调用场景：
    使用已存在对象创建新对象 
    Stack st2(st1);
    函数参数类型为类类型对象
    当然，一般来说，没有特别要求，我们还是推荐使用引用的，效率会高些。 
    1. void func2(Stack st)
    2. {
    3. 	//...
    4. }
    函数返回值类型为类类型对象 
    1. Date func3(Date d)
    2. {
    3. 	//如果出了作用域，传值给d的对象还存在，
    4. 	//那么引用返回更好，这里我们只是为了举例子
    5. 	//而且我们是推荐传引用的
    6. 	return d;
    7. }

    返回的时候，d已然销毁，所以我们返回的其实是d的拷贝。

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

    赋值运算符重载

    这里我们还是会通过一些例子来引入这个概念。

    我们打算写个日期类来解释，在此之前，我们需要先明白，日期和日期的相加减有没有意义，比如

    2023-10-23 + 2023-10-24，显然是没有意义的，但是他们之间相减就有了意义；两个日期相差多少天，那么日期间的乘除也是没有意义的；再看2023-10-23 + 50天，这个显然也是有意义的，计算50天日期是多少；这么说的话，其实日期的比较也是有意义的，相等和大小。

    那么我们如何去实现日期间的比较和日期加减天数呢？

    但是这些成员变量都是私有的，在类外我们不能直接用，当然，我们可以在类里写上GetYear函数等来取得他们的值进行比较，我们这里只是测试，就先将他们公开，当然这样的代码是不健康的，但是我们也说了，只是测试。

    1. class Date
    2. {
    3.  
    4. public:
    5. 	Date(int year = 2023, int month = 10, int day = 22)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10.  
    11. 		cout << "Date的构造" << endl;
    12. 	}
    13.  
    14. 	int _year;
    15. 	int _month;
    16. 	int _day;
    17.  
    18. };
    19.  
    20. bool equal(Date d1, Date d2)
    21. {
    22. 	if (d1._year == d2._year && d1._month == d2._month && d1._day == d2._day)
    23. 		return true;
    24. 	else
    25. 		return false;
    26. }
    27.  
    28. int main()
    29. {
    30.  
    31. 	Date d1;
    32. 	Date d2(2023, 2, 13);
    33.  
    34. 	bool ret = equal(d1, d2);
    35. 	cout << ret << endl;
    36.  
    37. 	return 0;
    38. }

    当然，这样会更好些

    1. bool equal(const Date& d1, const Date& d2)
    2. {
    3. 	if (d1._year == d2._year && d1._month == d2._month && d1._day == d2._day)
    4. 		return true;
    5. 	else
    6. 		return false;
    7. }

     接下来进行大小比较函数，起个什么名字好呢？compare？比大还是比小？我怎么知道，compare_large? 当下，我们先随便起名字。

    1. class Date
    2. {
    3.  
    4. public:
    5. 	Date(int year = 2023, int month = 10, int day = 22)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10.  
    11. 		cout << "Date的构造" << endl;
    12. 	}
    13.  
    14. 	int _year;
    15. 	int _month;
    16. 	int _day;
    17.  
    18. };
    19.  
    20. bool equal(const Date& d1, const Date& d2)
    21. {
    22. 	if (d1._year == d2._year && d1._month == d2._month && d1._day == d2._day)
    23. 		return true;
    24. 	else
    25. 		return false;
    26. }
    27.  
    28. bool compare(const Date& d1, const Date& d2)
    29. {
    30.  
    31. 	if (d1._year > d2._year)
    32. 	{
    33. 		return true;
    34. 	}
    35. 	else if (d1._year == d2._year && d1._month > d2._month)
    36. 	{
    37. 		return true;
    38. 	}
    39. 	else if (d1._year == d2._year && d1._month == d2._month && d1._day > d2._day)
    40. 	{
    41. 		return true;
    42. 	}
    43.  
    44. 	return false;
    45. }
    46.  
    47. int main()
    48. {
    49.  
    50. 	Date d1;
    51. 	Date d2(2023, 2, 13);
    52.  
    53. 	bool ret1 = equal(d1, d2);
    54. 	bool ret2 = compare(d1, d2);
    55.  
    56. 	cout << ret1 << endl;
    57. 	cout << ret2 << endl;
    58.  
    59. 	return 0;
    60. }

     

    我们可以想想内置类型定义出的变量，都是可以直接比较和相加减的，那么我自定义类型定义的对象能不能也直接比较相加减呢？答案是不能，编译器无法理解对象如何比较，比如我们的d1和d2，怎么确定大小呢？年月日都大于才算大于吗？由此，我们引入一个新的概念，运算符重载，不进解决了函数名不便于理解的问题，还可以进行对象的比较。

    运算符重载

    C++ 为了增强代码的可读性引入了运算符重载 ， 运算符重载是具有特殊函数名的函数 ，也具有其
    返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
    函数名字为：关键字 operator 后面接需要重载的运算符符号 。
    函数原型： 返回值类型  operator 操作符 ( 参数列表 )
    看代码前别忘了六个成员函数每个函数都有一个隐含的this指针。 
    1. class Date
    2. {
    3.  
    4. public:
    5. 	Date(int year = 2023, int month = 10, int day = 22)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10.  
    11. 		cout << "Date的构造" << endl;
    12. 	}
    13.     
    14.     //比较相等
    15. 	bool operator==(const Date& d2)
    16. 	{
    17. 		if (_year == d2._year &&_month == d2._month && _day == d2._day)
    18. 			return true;
    19. 		else
    20. 			return false;
    21. 	}
    22.  
    23.     //比较大于
    24. 	bool operator>(const Date& d2)
    25. 	{
    26.  
    27. 		if (_year > d2._year)
    28. 		{
    29. 			return true;
    30. 		}
    31. 		else if (_year == d2._year && _month > _month)
    32. 		{
    33. 			return true;
    34. 		}
    35. 		else if (_year == d2._year && _month == d2._month && _day > d2._day)
    36. 		{
    37. 			return true;
    38. 		}
    39.  
    40. 		return false;
    41. 	}
    42.  
    43. private:
    44. 	int _year;
    45. 	int _month;
    46. 	int _day;
    47.  
    48. };
    49.  
    50. int main()
    51. {
    52.  
    53. 	Date d1;
    54. 	Date d2(2023, 2, 13);
    55.  
    56. 	//bool ret1 = equal(d1, d2);
    57. 	//bool ret2 = compare(d1, d2);
    58.  
    59. 	bool ret1 = d1 == d2; //d1.operator==(d2);
    60. 	bool ret2 = d1 > d2;  //d1.operator>(d2);
    61.  
    62. 	cout << ret1 << endl;
    63. 	cout << ret2 << endl;
    64.  
    65. 	bool ret3 = d1.operator==(d2);
    66. 	bool ret4 = d1.operator>(d2);
    67.  
    68. 	cout << ret1 << endl;
    69. 	cout << ret2 << endl;
    70.  
    71. 	return 0;
    72. }
    注意：
    1. 不能通过连接其他符号来创建新的操作符：比如operator@
    2. 重载操作符必须有一个类类型参数
    3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
    4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
    5.    .*   ::   sizeof   ?:   .   注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

    写在类外面：

    1. class Date
    2. {
    3.  
    4. public:
    5. 	Date(int year = 2023, int month = 10, int day = 22)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10.  
    11. 		cout << "Date的构造" << endl;
    12. 	}
    13.  
    14. 	//比较相等
    15. 	bool operator==(const Date& d2)
    16. 	{
    17. 		if (_year == d2._year && _month == d2._month && _day == d2._day)
    18. 			return true;
    19. 		else
    20. 			return false;
    21. 	}
    22.  
    23. 	bool operator>(const Date& d2);
    24. 	
    25. private:
    26. 	int _year;
    27. 	int _month;
    28. 	int _day;
    29.  
    30. };
    31.  
    32. //比较大于
    33. bool Date::operator>(const Date& d2)
    34. {
    35.  
    36. 	if (_year > d2._year)
    37. 	{
    38. 		return true;
    39. 	}
    40. 	else if (_year == d2._year && _month > _month)
    41. 	{
    42. 		return true;
    43. 	}
    44. 	else if (_year == d2._year && _month == d2._month && _day > d2._day)
    45. 	{
    46. 		return true;
    47. 	}
    48.  
    49. 	return false;
    50. }

    接下来是日期加上一个数。

    1. class Date
    2. {
    3.  
    4. public:
    5. 	Date(int year = 2023, int month = 10, int day = 22)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10.  
    11. 		cout << "Date的构造" << endl;
    12. 	}
    13.  
    14. 	int GetMonthday(int year, int month)
    15. 	{
    16. 		int month_day[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    17.  
    18. 		if (month == 2 && (year % 4 == 0 && year % 100 == 0 || year % 400 == 0))
    19. 		{
    20. 			return 29;
    21. 		}
    22.  
    23. 		return month_day[month];
    24. 	}
    25.  
    26. 	Date& operator+=(int day)
    27. 	{
    28. 		_day += day;
    29.  
    30. 		while (_day > GetMonthday(_year,_month))
    31. 		{
    32. 			_day -= GetMonthday(_year, _month);
    33. 			_month++;
    34.  
    35. 			if (_month == 13)
    36. 			{
    37. 				_year++;
    38. 				_month = 1;
    39. 			}
    40. 		}
    41.  
    42. 		return *this;
    43. 	}
    44.  
    45. 	void Print()
    46. 	{
    47. 		cout << _year << "-" << _month << "-" << _day << endl;
    48. 	}
    49.  
    50. private:
    51. 	int _year;
    52. 	int _month;
    53. 	int _day;
    54.  
    55. };
    56.  
    57. int main()
    58. {
    59.  
    60. 	Date d1;
    61. 	d1 += 50;
    62.  
    63. 	d1.Print();
    64.  
    65. 	return 0;
    66. }

    但是这样我们把对象d1就做了修改，我们不想修改，只想＋然后返回来一个值怎么办？

    将下面这个代码加入类中

    1. 	Date operator+(int day)
    2. 	{
    3.         //实例化一个对象tmp拷贝*this
    4. 		Date tmp(*this);
    5.  
    6.         //复用operator+=
    7. 		tmp += 50;
    8. 	
    9. 		return tmp;
    10. 	}
    1.  
    2. int main()
    3. {
    4.  
    5. 	Date d1;
    6.  
    7. 	Date d2 = d1 + 50;
    8. 	d2.Print();
    9.  
    10. 	return 0;
    11. }

     

    接下来就是我们的赋值运算符重载了。

    1. Date& Date::operator=(const Date& d)
    2. {
    3. 	_year = d._year;
    4. 	_month = d._month;
    5. 	_day = d._day;
    6.  
    7. 	return *this;
    8. }

    前置++和后置++重载

    前置和后置++，最难以区分的其实是他们的名字，尽管返回值不同，但参数相同，不构成重载，于是就有了一个特殊规定，看代码

    C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
    自动传递 
    1. //前置++复用operator+=
    2. Date& Date::operator++()
    3. {
    4. 	*this += 1;
    5. 	return *this;
    6. }
    7.  
    8. //后置++复用operator+=
    9. Date Date::operator++(int)
    10. {
    11. 	Date tmp(*this);
    12. 	*this += 1;
    13.  
    14. 	return tmp;
    15. }

    于是我们用参数类型来区分，一个不传，一个传int类型，编译器就可以区分了。

    一般情况下我们最好还是用前置++，是引用返回，而且没有拷贝，后置++就有一次拷贝，也许一次调用差距不大，但是如果调用10万次就有差别了。

    日期类的实现

    接下来我们将使用各种运算符重载实现各种有意义的日期比较和加减，

    头文件 

    1. #pragma once
    2. #include <iostream>
    3. using namespace std;
    4.  
    5. class Date
    6. {
    7.  
    8. public:
    9.  
    10. 	Date(int year = 2023, int month = 10, int day = 24);
    11. 	
    12. 	int GetMonthday(int year, int month);
    13. 	
    14. 	//operator+复用opreator+=，优于operator+=复用operator+
    15. 	Date operator+(int day);
    16. 	Date operator-(int day);        //计算日期减天数
    17. 	int operator-(const Date& d);   //计算日期和日期间差几天
    18. 	Date& operator+=(int day);
    19. 	Date& operator-=(int day);
    20. 	Date& operator=(const Date& d);
    21. 	
    22. 	bool operator==(const Date& d);
    23. 	bool operator!=(const Date& d);
    24. 	bool operator>(const Date& d);
    25. 	bool operator<(const Date& d);
    26. 	bool operator>=(const Date& d);
    27. 	bool operator<=(const Date& d);
    28. 	
    29. 	//前置++复用operator+=
    30. 	Date& operator++();
    31. 	//后置++复用operator+=
    32. 	Date operator++(int);
    33. 	
    34. 	void Print()
    35. 	{
    36. 		cout << _year << "-" << _month << "-" << _day << endl;
    37. 	}
    38.  
    39. private:
    40. 	int _year;
    41. 	int _month;
    42. 	int _day;
    43.  
    44. };

    日期类的实现 

    1. #include "Date.h"
    2.  
    3. Date::Date(int year, int month, int day)
    4. {
    5. 	_year = year;
    6. 	_month = month;
    7. 	_day = day;
    8. }
    9.  
    10. int Date::GetMonthday(int year, int month)
    11. {
    12. 	int month_day[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    13.  
    14. 	if (month == 2 && (year % 4 == 0 && year % 100 == 0 || year % 400 == 0))
    15. 	{
    16. 		return 29;
    17. 	}
    18.  
    19. 	return month_day[month];
    20. }
    21.  
    22. Date& Date::operator+=(int day)
    23. {
    24. 	_day += day;
    25.  
    26. 	while (_day > GetMonthday(_year, _month))
    27. 	{
    28. 		_day -= GetMonthday(_year, _month);
    29. 		_month++;
    30.  
    31. 		if (_month == 13)
    32. 		{
    33. 			_year++;
    34. 			_month = 1;
    35. 		}
    36. 	}
    37.  
    38. 	return *this;
    39. }
    40.  
    41. Date Date::operator+(int day)
    42. {
    43. 	Date tmp(*this);
    44. 	tmp += 50;
    45.  
    46. 	return tmp;
    47. }
    48.  
    49. Date  Date::operator-(int day)
    50. {
    51. 	Date tmp(*this);
    52. 	tmp -= day;
    53.  
    54. 	return tmp;
    55. }
    56.  
    57. Date& Date::operator-=(int day)
    58. {
    59. 	if (day < 0)
    60. 	{
    61. 		return *this += -day;
    62. 	}
    63.  
    64. 	_day -= day;
    65. 	while (_day <= 0)
    66. 	{
    67. 		--_month;
    68. 		if (_month == 0)
    69. 		{
    70. 			--_year;
    71. 			_month = 12;
    72. 		}
    73.  
    74. 		_day += GetMonthday(_year, _month);
    75.  
    76. 	}
    77. }
    78.  
    79.  
    80. Date& Date::operator=(const Date& d)
    81. {
    82. 	_year = d._year;
    83. 	_month = d._month;
    84. 	_day = d._day;
    85.  
    86. 	return *this;
    87. }
    88.  
    89. //前置++复用operator+=
    90. Date& Date::operator++()
    91. {
    92. 	*this += 1;
    93. 	return *this;
    94. }
    95.  
    96. //后置++复用operator+=
    97. Date Date::operator++(int)
    98. {
    99. 	Date tmp(*this);
    100. 	*this += 1;
    101.  
    102. 	return tmp;
    103. }
    104.  
    105. bool Date::operator>(const Date& d)
    106. {
    107.  
    108. 	if (_year > d._year)
    109. 	{
    110. 		return true;
    111. 	}
    112. 	else if (_year == d._year && _month > _month)
    113. 	{
    114. 		return true;
    115. 	}
    116. 	else if (_year == d._year && _month == d._month && _day > d._day)
    117. 	{
    118. 		return true;
    119. 	}
    120.  
    121. 	return false;
    122. }
    123.  
    124. bool Date::operator==(const Date& d)
    125. {
    126. 	if (_year == d._year && _month == d._month && _day == d._day)
    127. 		return true;
    128. 	else
    129. 		return false;
    130. }
    131.  
    132. bool Date::operator!=(const Date& d)
    133. {
    134. 	return !(*this == d);
    135. }
    136.  
    137. bool Date::operator<(const Date& d)
    138. {
    139. 	return !(*this >= d);
    140. }
    141.  
    142. bool Date::operator>=(const Date& d)
    143. {
    144. 	return *this > d || *this == d;
    145. }
    146.  
    147. bool Date::operator<=(const Date& d)
    148. {
    149. 	return !(*this <= d);
    150. }
    151.  
    152.  
    153. int Date::operator-(const Date& d)
    154. {
    155. 	int flag = 1;
    156. 	Date max = *this;
    157. 	Date min = d;
    158.  
    159. 	if (max < min)
    160. 	{
    161. 		max = d;
    162. 		min = *this;
    163. 		flag = -1;
    164. 	}
    165.  
    166. 	int n = 0;
    167. 	while (min != max)
    168. 	{
    169. 		++min;
    170. 		++n;
    171. 	}
    172.  
    173. 	return n * flag;
    174. }

    测试 

    1. #include "Date.h"
    2.  
    3. int main()
    4. {
    5. 	
    6. 	Date d1;
    7.  
    8. 	//测试赋值运算符重载
    9. 	Date d2 = d1;
    10. 	cout << "测试d2赋值运算符重载" << endl;
    11. 	d2.Print();
    12.  
    13. 	//测试+运算符重载
    14. 	Date d3(2023, 10, 25);
    15. 	d3 = d3 + 50;
    16. 	cout << "测试d3+运算符重载" << endl;
    17. 	d3.Print();
    18.  
    19. 	//测试-运算符重载
    20. 	Date d4(2023, 10, 25);
    21. 	d4 = d4 - 50;
    22. 	cout << "测试d4-运算符重载" << endl;
    23. 	d4.Print();
    24.  
    25. 	//测试==运算符重载
    26. 	Date d5(2023, 10, 25);
    27. 	d5 = d5 - 50;
    28. 	cout << "测试d5==运算符重载" << endl;
    29. 	cout << (d4 == d5) << endl;
    30.  
    31. 	//测试!=运算符重载
    32. 	Date d6(2023, 10, 25);
    33. 	cout << "测试d6!=运算符重载" << endl;
    34. 	cout << (d4 == d6) << endl;
    35.  
    36. 	//测试++运算符重载
    37. 	Date d7(2023, 10, 25);
    38. 	cout << "测试d7++运算符重载" << endl;
    39. 	++d7;
    40. 	d7.Print();
    41.  
    42. 	//测试>=运算符重载
    43. 	Date d8(2023, 10, 25);
    44. 	cout << "测试d8>=运算符重载" << endl;
    45. 	cout << (d7 >= d8) << endl;
    46. 	
    47. 	cout << endl << "全部通过" << endl;
    48. 	return 0;
    49. }
    50.

    测试结果 

  • 相关阅读:
    程序员基本功的代码
    C++指针和地址偏移在HotSpot VM中的应用
    探索OpenCV中直方图的神奇之处：应用与实现
    基于Springboot图书馆管理系统、Springboot图书借阅系统设计与实现 毕业设计开题报告
    探索arkui（2）--- 布局（列表）--- 2（支持分组/实现响应滚动位置）
    【vite】vite.defineConfig is not a function/npm无法安装第三方包问题
    开发者，你对云计算可能有些误解
    矩阵分析与应用+张贤达
    管理RMAN备份_维护RMAN备份和仓库记录
    Makefile入门（一）
  • 原文地址：https://blog.csdn.net/m0_74824254/article/details/133955394