• 【C++】：类和对象（2）

    朋友们、伙计们，我们又见面了，本期来给大家解读一下有关C++的基础知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

    C 语 言 专 栏：C语言：从入门到精通

    数据结构专栏：数据结构

    个  人  主  页 ：stackY、

    C + + 专 栏   ：C++

    Linux 专 栏  ：Linux

     

    目录

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

    2. 构造函数

    2.1概念

    2.2特性 

    3. 析构函数

    3.1概念

    3.2特性

    4. 拷贝构造

    4.1概念

    4.2特性

    5. 赋值运算符重载

    5.1运算符重载

    5.2赋值运算符重载

    5.3前置++、后置++重载

    6. const成员

    7. 取地址及const取地址操作符重载

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

    如果一个类中什么成员都没有，简称为空类。
    空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
    默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。 
    1. //空类
    2. class Date {}；

    2. 构造函数

    2.1概念

    构造函数主要完成初始化工作

    对于下面这个日期类：

    1. class Date
    2. {
    3. public:
    4. 	//初始化
    5. 	void Init(int year, int month, int day)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10. 	}
    11. 	void Print()
    12. 	{
    13. 		cout << _year << "-" << _month << "-" << _day << endl;
    14. 	}
    15. private:
    16. 	int _year;
    17. 	int _month;
    18. 	int _day;
    19. };
    20.  
    21. int main()
    22. {
    23. 	Date d1, d2;
    24. 	d1.Init(2023, 10, 1);
    25. 	d1.Print();
    26.  
    27. 	d2.Init(2023, 10, 2);
    28. 	d2.Print();
    29. 	return 0;
    30. }

     

    对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
    构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

    2.2特性 

    构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
    其特征如下：
            1. 函数名与类名相同。
            2. 无返回值。
            3. 对象实例化时编译器自动调用对应的构造函数。
            4. 构造函数可以重载。 
    1. class Date
    2. {
    3. public:
    4.  
    5. 	//带参的构造函数
    6. 	Date(int year, int month, int day)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12.  
    13. 	//无参的构造函数
    14. 	Date(){}
    15.  
    16. 	void Print()
    17. 	{
    18. 		cout << _year << "-" << _month << "-" << _day << endl;
    19. 	}
    20. private:
    21. 	int _year;
    22. 	int _month;
    23. 	int _day;
    24. };
    25.  
    26. void TestDate()
    27. {
    28. 	Date d1;  //调用无参的构造函数
    29.  
    30. 	Date d2(2023, 10, 1);//调用带参的构造函数
    31.  
    32. 	//Date d3();    //调用无参的构造函数创建对象时不能带(),否则就变成了函数声明
    33. }
    5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。 
    1. class Date
    2. {
    3. public:
    4.  
    5. 	/*
    6. 	//带参的构造函数
    7. 	Date(int year, int month, int day)
    8. 	{
    9. 		_year = year;
    10. 		_month = month;
    11. 		_day = day;
    12. 	}
    14. 	//无参的构造函数
    15. 	Date(){}
    16. 	*/
    17.  
    18. 	void Print()
    19. 	{
    20. 		cout << _year << "-" << _month << "-" << _day << endl;
    21. 	}
    22.  
    23. private:
    24. 	int _year;
    25. 	int _month;
    26. 	int _day;
    27. };
    28.  
    29.  
    30. int main()
    31. {
    32. 	Date d1;
    33. 	return 0;
    34. }

    当我们屏蔽掉我们自己写两个构造函数之后，在创建对象时会使用编译器自动生成的构造函数来完成对应的初始化，如果我们自己已经写了构造函数，则不再会自动生成。

    1. class Date
    2. {
    3. public:
    4.  
    5. 	//带参的构造函数
    6. 	Date(int year, int month, int day)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12.  
    13. 	void Print()
    14. 	{
    15. 		cout << _year << "-" << _month << "-" << _day << endl;
    16. 	}
    17.  
    18. private:
    19. 	int _year;
    20. 	int _month;
    21. 	int _day;
    22. };
    23.  
    24.  
    25. int main()
    26. {
    27. 	Date d1;
    28. 	Date d2(2023, 10, 1);
    29. 	return 0;
    30. }

    6. 关于编译器生成的默认成员函数：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的 默认构造函数并没有什么用？？
    解答：由于C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char/int*/char*...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数： 
    1. class Time
    2. {
    3. public:
    4. 	Time()
    5. 	{
    6. 		_hour = 0;
    7. 		_minute = 0;
    8. 		_second = 0;
    9. 	}
    10. private:
    11. 	int _hour;
    12. 	int _minute;
    13. 	int _second;
    14. };
    15.  
    16. class Date
    17. {
    18. private:
    19.     //内置类型
    20. 	int _year;
    21. 	int _month;
    22. 	int _day;
    23.     
    24.     //自定义类型
    25. 	Time _t;
    26. };
    27.  
    28. int main()
    29. {
    30. 	Date d1;
    31. 	return 0;
    32. }

    注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
    类中声明时可以给默认值。 
    1. class Time
    2. {
    3. public:
    4. 	Time()
    5. 	{
    6. 		_hour = 0;
    7. 		_minute = 0;
    8. 		_second = 0;
    9. 	}
    10. private:
    11. 	int _hour;
    12. 	int _minute;
    13. 	int _second;
    14. };
    15.  
    16. class Date
    17. {
    18. private:
    19. 	//内置类型
    20.     //C++11支持在声明时给内置类型缺省值
    21. 	int _year = 1949;
    22. 	int _month = 10;
    23. 	int _day = 1;
    24.  
    25. 	//自定义类型
    26. 	Time _t;
    27. };
    为了代码的实用性。所以我们在写构造函数时写为全缺省是一种非常不错的选择，当我们进行无参创建时会自动使用我们给的缺省值，而并不是随机值。 
    1. class Date
    2. {
    3. public:
    4. 	//全缺省构造函数
    5. 	Date(int year = 0, int month = 0, int day = 0)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10. 	}
    11. private:
    12. 	//内置类型
    13. 	int _year;
    14. 	int _month;
    15. 	int _day;
    16. };
    17.  
    18. int main()
    19. {
    20. 	Date d1;
    21. 	Date d2(2023, 10, 1);
    22. 	return 0;
    23. }

    7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
    注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
    是默认构造函数。
    多个并存就会产生调用二义性，不传参调用的就是默认构造 
    1. class Date
    2. {
    3. public:
    4. 	//全缺省构造函数
    5. 	Date(int year = 0, int month = 0, int day = 0)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10. 	}
    11.  
    12. 	//无参构造函数
    13. 	Date()
    14. 	{
    15. 		_year = 0;
    16. 		_month = 0;
    17. 		_day = 0;
    18. 	}
    19. private:
    20. 	//内置类型
    21. 	int _year;
    22. 	int _month;
    23. 	int _day;
    24. };
    25.  
    26. int main()
    27. {
    28. 	Date d1;
    29. 	return 0;
    30. }

    这段代码首先全缺省的构造函数和无参的构造函数形成了函数重载，但是在定义对象时进行了一个无参的调用，这时就会出现一个函数调用出现冲突的问题，由于是无参，既可以调用全缺省的，也可以调用午无参的，那么编译器就陷入了困难，所以尽量避免无参和全缺省的构造函数同时出现。

    总结：

    编译器生成的默认构造：

    1. 我们不写，才会自动生成

    2. 不会对内置类型进行处理（C++11支持对内置类型声明时给缺省值）

    3. 自定义类型才会处理，会去调用这个成员的默认构造函数

    当成员变量都是自定义类型时，可以考虑不写构造函数

    3. 析构函数

    3.1概念

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

    3.2特性

    1. 析构函数名是在类名前加上字符 ~。
    2. 无参数无返回值类型。
    3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
    4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。 
    1. typedef int DateType;
    2. class Stack
    3. {
    4. public:
    5. 	//构造函数
    6. 	Stack(size_t capacity)
    7. 	{
    8. 		_array = (DateType*)malloc(sizeof(DateType) * capacity);
    9. 		if (_array == nullptr)
    10. 		{
    11. 			perror("malloc fail");
    12. 			exit(-1);
    13. 		}
    14. 		_size = 0;
    15. 		_capacity = capacity;
    16. 	}
    17. 	void STPush(DateType x)
    18. 	{
    19. 		//...
    20. 	}
    21. 	//析构函数
    22. 	~Stack()
    23. 	{
    24. 		free(_array);
    25. 		_array = nullptr;
    26. 		_size = _capacity = 0;
    27. 	}
    28. private:
    29. 	DateType* _array;
    30. 	size_t _capacity;
    31. 	size_t _size;
    32. };
    33.  
    34. int main()
    35. {
    36. 	Stack st(1);
    37. 	return 0;
    38. }

    5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？我们可以采用程序来观察一下： 
    1.  
    2. typedef int DateType;
    3. class Stack
    4. {
    5. public:
    6. 	//构造函数
    7. 	Stack()
    8. 	{
    9. 		_array = (DateType*)malloc(sizeof(DateType) * 4);
    10. 		if (_array == nullptr)
    11. 		{
    12. 			perror("malloc fail");
    13. 			exit(-1);
    14. 		}
    15. 		_size = 0;
    16. 		_capacity = 4;
    17. 	}
    18. 	void STPush(DateType x)
    19. 	{
    20. 		//...
    21. 	}
    22. 	
    23. private:
    24. 	DateType* _array;
    25. 	size_t _capacity;
    26. 	size_t _size;
    27. };
    28.  
    29. int main()
    30. {
    31. 	Stack st;
    32. 	return 0;
    33. }

    可以看到编译器默认生成的析构函数也是不会对内置类型做处理，那么当遇见自定义类型它会如何呢？

    1. typedef int DateType;
    2. class Stack
    3. {
    4. public:
    5. 	//构造函数
    6. 	Stack()
    7. 	{
    8. 		_array = (DateType*)malloc(sizeof(DateType) * 4);
    9. 		if (_array == nullptr)
    10. 		{
    11. 			perror("malloc fail");
    12. 			exit(-1);
    13. 		}
    14. 		_size = 0;
    15. 		_capacity = 4;
    16. 	}
    17. 	void STPush(DateType x)
    18. 	{
    19. 		//...
    20. 	}
    21. 	//析构函数
    22. 	~Stack()
    23. 	{
    24. 		cout << "~Stack()" << endl;
    25. 		free(_array);
    26. 		_array = nullptr;
    27. 		_size = _capacity = 0;
    28. 	}
    29. private:
    30. 	DateType* _array;
    31. 	size_t _capacity;
    32. 	size_t _size;
    33. };
    34.  
    35.  
    36. class Date
    37. {
    38. public:
    39. 	Date(int year = 0, int month = 0, int day = 0)
    40. 	{
    41. 		_year = year;
    42. 		_month = month;
    43. 		_day = day;
    44. 	}
    45.  
    46. private:
    47.  
    48. 	//内置类型
    49. 	int _year;
    50. 	int _month;
    51. 	int _day;
    52.  
    53. 	//自定义类型
    54. 	Stack st;
    55. };
    56. int main()
    57. {
    58. 	//Stack st;
    59. 	Date d1;
    60. 	return 0;
    61. }

    在这个过程中main函数 中创建了 Date 对象 d1 ，而 d1 中包含 4 个成员变量，其中 _year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而st是Stack类对象，所以在d1销毁时，要将其内部包含的Stack类的st 对象销毁，所以要调用Stack类的析构函数。但是：
    main函数中不能直接调用Stack类的析构函数，实际要释放的是Date 类对象，所以编译器会
    调用 Date类的析构函数，而Date 没有显式提供，则编译器会给 Date类生成一个默认的析构函
    数，目的是在其内部调用Stack类的析构函数，即当Date对象销毁时，要保证其内部每个自定
    义对象都可以正确销毁main函数中并没有直接调用Stack类析构函数，而是显式调用编译器
    为Date 类生成的默认析构函数。
    注意：创建哪个类的对象则调用该类的构造函数，销毁那个类的对象则调用该类的析构函数
    6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

    4. 拷贝构造

    4.1概念

    在日常生活中，我们发现有两个人长得几乎一模一样，我们称他们为双胞胎，那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

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

    4.2特性

    首先我们可以看这样一段代码： 
    1. typedef int DateType;
    2. class Stack
    3. {
    4. public:
    5. 	//构造函数
    6. 	Stack(size_t capacity = 3)
    7. 	{
    8. 		cout << "Stack()" << endl;
    9. 		_array = (DateType*)malloc(sizeof(DateType) * capacity);
    10. 		if (_array == nullptr)
    11. 		{
    12. 			perror("malloc fail");
    13. 			exit(-1);
    14. 		}
    15. 		_size = 0;
    16. 		_capacity = capacity;
    17. 	}
    18.  
    19. 	//析构函数
    20. 	~Stack()
    21. 	{
    22. 		cout << "~Stack()" << endl;
    23. 		free(_array);
    24. 		_array = nullptr;
    25. 		_size = _capacity = 0;
    26. 	}
    27. private:
    28. 	DateType* _array;
    29. 	size_t _capacity;
    30. 	size_t _size;
    31. };
    32.  
    33. void func(Stack s)
    34. {
    35. 	//...
    36. }
    37.  
    38. int main()
    39. {
    40. 	Stack s1;
    41.     //函数调用进行了一份拷贝
    42. 	func(s1);
    43. 	return 0;
    44. }

    首先这段代码是会报错的，因为s1是Stack类的对象，当func函数调用s1的时候，会拷贝一份s1，最主要的是拷贝的s与s1是同一块空间，就代表着两个类对象同时指向同一个空间，那么在进行析构函数清理资源的时候，无论先清理哪一个，剩下的一个指向的就是一块已经被释放的空间，就会对同一块空间进行多次释放，造成程序崩溃，那么就需要拷贝构造函数来解决这个问题：

    拷贝构造函数也是特殊的成员函数，其特征如下：
    1. 拷贝构造函数是构造函数的一个重载形式。
    2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。 
    1. class Date
    2. {
    3. public:
    4. 	//构造函数
    5. 	Date(int year = 0, int month = 0, int day = 0)
    6. 	{
    7. 		cout << "Date()" << endl;
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12. 	//拷贝构造
    13. 	//Date(const Date d)  不能使用传值调用
    14. 	Date(const Date& d)
    15. 	{
    16. 		cout << "Date(const Date& d)" << endl;
    17. 		_year = d._year;
    18. 		_month = d._month;
    19. 		_day = d._day;
    20. 	}
    21. private:
    22. 	//内置类型
    23. 	int _year;
    24. 	int _month;
    25. 	int _day;
    26. };
    27. int main()
    28. {
    29. 	Date d1;
    30. 	Date d2(d1);
    31. 	return 0;
    32. }

    在这里说一下在传值调用的时候为什么会发生无穷递归：首先要明白一个点，传值就需要进行拷贝，拷贝就需要调用拷贝构造。

    3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。 
    1.  
    2. class Date
    3. {
    4. public:
    5. 	//构造函数
    6. 	Date(int year = 1949, int month = 10, int day = 1)
    7. 	{
    8. 		cout << "Date()" << endl;
    9. 		_year = year;
    10. 		_month = month;
    11. 		_day = day;
    12. 	}
    13. private:
    14. 	//内置类型
    15. 	int _year;
    16. 	int _month;
    17. 	int _day;
    18. };
    19. int main()
    20. {
    21. 	Date d1;
    22. 	Date d2(d1);
    23. 	return 0;
    24. }

    那么拷贝构造对于自定义类型如何呢？

    1. class Time
    2. {
    3. public:
    4. 	Time()
    5. 	{
    6. 		_hour = 1;
    7. 		_minute = 1;
    8. 		_second = 1;
    9. 	}
    10. private:
    11. 	int _hour;
    12. 	int _minute;
    13. 	int _second;
    14. };
    15.  
    16. class Date
    17. {
    18. public:
    19. 	//构造函数
    20. 	Date(int year = 1949, int month = 10, int day = 1)
    21. 	{
    22. 		cout << "Date()" << endl;
    23. 		_year = year;
    24. 		_month = month;
    25. 		_day = day;
    26. 	}
    27. private:
    28. 	//内置类型
    29. 	int _year;
    30. 	int _month;
    31. 	int _day;
    32.  
    33. 	//自定义类型
    34. 	Time _t;
    35. };
    36. int main()
    37. {
    38. 	Date d1;
    39. 	Date d2(d1);
    40. 	return 0;
    41. }

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

     4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，如果没有资源的创建于释放是不需要自己写拷贝构造的，如果有资源的创建于释放是需要自己写。

    1. typedef int DateType;
    2. class Stack
    3. {
    4. public:
    5. 	//构造函数
    6. 	Stack(size_t capacity = 3)
    7. 	{
    8. 		cout << "Stack()" << endl;
    9. 		_array = (DateType*)malloc(sizeof(DateType) * capacity);
    10. 		if (_array == nullptr)
    11. 		{
    12. 			perror("malloc fail");
    13. 			exit(-1);
    14. 		}
    15. 		_size = 0;
    16. 		_capacity = capacity;
    17. 	}	
    18. 	//析构函数
    19. 	~Stack()
    20. 	{
    21. 		cout << "~Stack()" << endl;
    22. 		free(_array);
    23. 		_array = nullptr;
    24. 		_size = _capacity = 0;
    25. 	}
    26. private:
    27. 	DateType* _array;
    28. 	size_t _capacity;
    29. 	size_t _size;
    30. };
    31.  
    32. int main()
    33. {
    34. 	Stack s1(4);
    35. 	Stack s2(s1);
    36. 	return 0;
    37. }

    程序崩溃了，那么是什么原因呢？

    由于编译器默认生成的拷贝构造函数都是浅拷贝（值拷贝），所以导致了s1和s2指向的是同一块空间，那么在进行s2的析构函数清理资源的时候，先清理了s2，所以s1和s2指向的这同一块空间已经被释放了，但是s1的析构函数并不知道，还会对这块空间进行释放，那么对同一块空间的多次释放就会造成程序崩溃。

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

     

    1. typedef int DateType;
    2. class Stack
    3. {
    4. public:
    5. 	//构造函数
    6. 	Stack(size_t capacity = 3)
    7. 	{
    8. 		cout << "Stack()" << endl;
    9. 		_array = (DateType*)malloc(sizeof(DateType) * capacity);
    10. 		if (_array == nullptr)
    11. 		{
    12. 			perror("malloc fail");
    13. 			exit(-1);
    14. 		}
    15. 		_size = 0;
    16. 		_capacity = capacity;
    17. 	}	
    18. 	//深拷贝
    19.     //拷贝构造
    20. 	Stack(const Stack& s)
    21. 	{
    22. 		cout << "Stack(const Stack& s)" << endl;
    23. 		_array = (DateType*)malloc(sizeof(DateType) * s._capacity);
    24. 		if (_array == nullptr)
    25. 		{
    26. 			perror("malloc fail");
    27. 			exit(-1);
    28. 		}
    29. 		memcpy(_array, s._array, sizeof(DateType) * s._capacity);
    30. 		_size = s._size;
    31. 		_capacity = s._capacity;
    32. 	}
    33. 	//析构函数
    34. 	~Stack()
    35. 	{
    36. 		cout << "~Stack()" << endl;
    37. 		free(_array);
    38. 		_array = nullptr;
    39. 		_size = _capacity = 0;
    40. 	}
    41. private:
    42. 	DateType* _array;
    43. 	size_t _capacity;
    44. 	size_t _size;
    45. };
    46.  
    47. int main()
    48. {
    49. 	Stack s1(4);
    50. 	Stack s2(s1);
    51. 	return 0;
    52. }

    5. 拷贝构造函数典型调用场景：
    • 使用已存在对象创建新对象
    • 函数参数类型为类类型对象
    • 函数返回值类型为类类型对象

    5. 赋值运算符重载

    5.1运算符重载

    C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
    函数名字为：关键字operator后面接需要重载的运算符符号。
    函数原型：返回值类型 operator操作符(参数列表)
    注意：
    • 不能通过连接其他符号来创建新的操作符：比如operator@
    • 重载操作符必须有一个类类型参数
    • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
    • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
    • .*  ::  sizeof  ?:  .  注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

    1. 全局的运算符重载

    1.  
    2. //全局的operator==
    3. bool operator==(const Date& d1, const Date& d2)
    4. {
    5. 	return d1._year == d2._year
    6. 		&& d1._month == d2._month
    7. 		&& d1._day == d2._day;
    8. }
    9.  
    10. //全局的operator!=
    11. bool operator!=(const Date& d1, const Date& d2)
    12. {
    13. 	return !(d1 == d2);
    14. }
    15.  
    16. //全局的operator<
    17. bool operator<(const Date& d1, const Date& d2)
    18. {
    19. 	if (d1._year < d2._year)
    20. 	{
    21. 		return true;
    22. 	}
    23. 	else if (d1._year == d2._year && d1._month < d2._month)
    24. 	{
    25. 		return true;
    26. 	}
    27. 	else if (d1._year == d2._year && d1._month == d2._month && d1._day < d2._day)
    28. 	{
    29. 		return true;
    30. 	}
    31. 	else
    32. 	{
    33. 		return false;
    34. 	}
    35. }
    36.  
    37. //全局的operator<=
    38. bool operator<=(const Date& d1, const Date& d2)
    39. {
    40. 	return d1 < d2 || d1 == d2;
    41. }
    42.  
    43. //全局的operator>
    44. bool operator>(const Date& d1, const Date& d2)
    45. {
    46. 	return !(d1 <= d2);
    47. }
    48.  
    49. //全局的operator>=
    50. bool operator>=(const Date& d1, const Date& d2)
    51. {
    52. 	return !(d1 < d2);
    53. }
    54.  
    55. //获取天数
    56. int GetMonth_day(int year, int month)
    57. {
    58. 	int monthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    59.  
    60. 	if (month == 2 && (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    61. 	{
    62. 		return 29;
    63. 	}
    64. 	return monthArray[month];
    65. }
    66.  
    67. //全局的operator+=
    68. Date& operator+=(Date& d, int day)
    69. {
    70. 	d._day += day;
    71. 	while (d._day > GetMonth_day(d._year, d._month))
    72. 	{
    73. 		//天满了进月
    74. 		d._day -= GetMonth_day(d._year, d._month);
    75. 		d._month++;
    76.  
    77. 		//月满了进年，月置为1
    78. 		if (d._month == 13)
    79. 		{
    80. 			++d._year;
    81. 			d._month = 1;
    82. 		}
    83. 	}
    84. 	return d;
    85. }
    86.  
    87. //全局的operator+
    88. Date operator+(Date& d, int day)
    89. {
    90. 	Date tmp(d);
    91. 	tmp += day;
    92. 	return tmp;
    93. }

    2. 成员函数的运算符重载

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

    1. class Date
    2. {
    3. public:
    4. 	//全缺省构造函数
    5. 	Date(int year = 0, int month = 0, int day = 0)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10. 	}
    11.  
    12. 	void Print()
    13. 	{
    14. 		cout << _year << "/" << _month << "/" << _day << endl;
    15. 	}
    16.  
    17. 	///运算符重载/
    18. 	//成员函数operator==
    19. 	bool operator==(const Date& d)
    20. 	{
    21. 		return _year == d._year
    22. 			&& _month == d._month
    23. 			&& _day == d._day;
    24. 	}
    25.  
    26. 	//成员函数operator!=
    27. 	bool operator!=(const Date& d)
    28. 	{
    29. 		return !(*this == d);
    30. 	}
    31.  
    32. 	//成员函数operator<
    33. 	bool operator<(const Date& d)
    34. 	{
    35. 		if (_year < d._year)
    36. 		{
    37. 			return true;
    38. 		}
    39. 		else if (_year == d._year && _month < d._month)
    40. 		{
    41. 			return true;
    42. 		}
    43. 		else if (_year == d._year && _month == d._month && _day < d._day)
    44. 		{
    45. 			return true;
    46. 		}
    47. 		else
    48. 		{
    49. 			return false;
    50. 		}
    51. 	}
    52.  
    53. 	//成员函数operator<=
    54. 	bool operator<=(const Date& d)
    55. 	{
    56. 		return *this < d || *this == d;
    57. 	}
    58.  
    59. 	//成员函数operator>
    60. 	bool operator>(const Date& d)
    61. 	{
    62. 		return !(*this <= d);
    63. 	}
    64.  
    65. 	//成员函数operator>=
    66. 	bool operator>=(const Date& d)
    67. 	{
    68. 		return !(*this < d);
    69. 	}
    70.  
    71. 	//获取天数
    72. 	int GetMonth_day(int year, int month)
    73. 	{
    74. 		int monthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    75.  
    76. 		if (month == 2 && (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    77. 		{
    78. 			return 29;
    79. 		}
    80. 		return monthArray[month];
    81. 	}
    82.  
    83. 	//成员函数operator+=
    84. 	Date& operator+=(int day)
    85. 	{
    86. 		_day += day;
    87. 		while (_day > GetMonth_day(_year, _month))
    88. 		{
    89. 			//天满了进月
    90. 			_day -= GetMonth_day(_year, _month);
    91. 			_month++;
    92.  
    93. 			//月满了进年，月置为1
    94. 			if (_month == 13)
    95. 			{
    96. 				++_year;
    97. 				_month = 1;
    98. 			}
    99. 		}
    100. 		return *this;
    101. 	}
    102.  
    103. 	//成员函数operator+
    104. 	Date operator+(int day)
    105. 	{
    106. 		Date tmp(*this);
    107. 		tmp += day;
    108. 		return tmp;
    109. 	}
    110. private:  
    111. 	int _year;
    112. 	int _month;
    113. 	int _day;
    114. };

    5.2赋值运算符重载

    1. 赋值运算符重载格式

    ①参数类型：const T&，传递引用可以提高传参效率
    ②返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测③是否自己给自己赋值

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

    1.  
    2. class Date
    3. {
    4. public:
    5. 	//全缺省构造函数
    6. 	Date(int year = 0, int month = 0, int day = 0)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12.  
    13. 	void Print()
    14. 	{
    15. 		cout << _year << "/" << _month << "/" << _day << endl;
    16. 	}
    17.  
    18. 	//成员函数operator=
    19. 	Date& operator=(const Date& d)
    20. 	{
    21. 		//自己不能给自己赋值
    22. 		if (this != &d)
    23. 		{
    24. 			_year = d._year;
    25. 			_month = d._month;
    26. 			_day = d._day;
    27. 		}
    28. 		return *this;
    29. 	}
    30. private:  
    31. 	int _year;
    32. 	int _month;
    33. 	int _day;
    34. };

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

    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 1900, int month = 1, int day = 1)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	int _year;
    11. 	int _month;
    12. 	int _day;
    13. };
    14. // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
    15. Date& operator=(Date& left, const Date& right)
    16. {
    17. 	if (&left != &right)
    18. 	{
    19. 		left._year = right._year;
    20. 		left._month = right._month;
    21. 		left._day = right._day;
    22. 	}
    23. 	return left;
    24. }
    25. // 编译失败：
    26. // error C2801: “operator =”必须是非静态成员

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

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

    1. class Time
    2. {
    3. public:
    4. 	Time()
    5. 	{
    6. 		_hour = 1;
    7. 		_minute = 1;
    8. 		_second = 1;
    9. 	}
    10. 	Time& operator=(const Time& t)
    11. 	{
    12. 		if (this != &t)
    13. 		{
    14. 			_hour = t._hour;
    15. 			_minute = t._minute;
    16. 			_second = t._second;
    17. 		}
    18. 		return *this;
    19. 	}
    20. private:
    21. 	int _hour;
    22. 	int _minute;
    23. 	int _second;
    24. };
    25. class Date1
    26. {
    27. private:
    28. 	// 基本类型(内置类型)
    29. 	int _year = 1970;
    30. 	int _month = 1;
    31. 	int _day = 1;
    32. 	// 自定义类型
    33. 	Time _t;
    34. };
    35. int main()
    36. {
    37. 	Date1 d1;
    38. 	Date1 d2;
    39. 	d1 = d2;
    40. 	return 0;
    41. }

    既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？
    如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要自己实现。

    5.3前置++、后置++重载

    根据前置++和后置++的区别：先使用后++还是先++后使用可以来进行设计：

    1. 前置++

    1.  
    2. class Date
    3. {
    4. public:
    5. 	//全缺省构造函数
    6. 	Date(int year = 0, int month = 0, int day = 0)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12.  
    13. 	void Print()
    14. 	{
    15. 		cout << _year << "/" << _month << "/" << _day << endl;
    16. 	}
    17.  
    18. 	//成员函数operator++(前置)
    19. 	Date& operator++()
    20. 	{
    21. 		_day += 1;
    22. 		return *this;
    23. 	}
    24.  
    25. private:  
    26. 	int _year;
    27. 	int _month;
    28. 	int _day;
    29. };

    前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载

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

    注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1

    2. 后置++

    1.  
    2. class Date
    3. {
    4. public:
    5. 	//全缺省构造函数
    6. 	Date(int year = 0, int month = 0, int day = 0)
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12.  
    13. 	void Print()
    14. 	{
    15. 		cout << _year << "/" << _month << "/" << _day << endl;
    16. 	}
    17.  
    18. 	//成员函数operator++(后置)
    19. 	Date operator++(int)
    20. 	{
    21. 		Date tmp(*this);
    22. 		_day += 1;
    23. 		return tmp;
    24. 	}
    25. private:  
    26. 	int _year;
    27. 	int _month;
    28. 	int _day;
    29. };

    6. const成员

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

    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	void Print()
    11. 	{
    12. 		cout << "Print()" << endl;
    13. 		cout << "year:" << _year << endl;
    14. 		cout << "month:" << _month << endl;
    15. 		cout << "day:" << _day << endl << endl;
    16. 	}
    17. 	void Print() const
    18. 	{
    19. 		cout << "Print()const" << endl;
    20. 		cout << "year:" << _year << endl;
    21. 		cout << "month:" << _month << endl;
    22. 		cout << "day:" << _day << endl << endl;
    23. 	}
    24. private:
    25. 	int _year; // 年
    26. 	int _month; // 月
    27. 	int _day; // 日
    28. };
    29. void Test()
    30. {
    31. 	Date d1(2023, 1, 1);
    32. 	d1.Print();
    33. 	const Date d2(2023, 1, 1);
    34. 	d2.Print();
    35. }
    36.  
    37. int main()
    38. {
    39. 	Test();
    40. 	return 0;
    41. }

    1. const对象可以调用非const成员函数吗？

    不能，const对象权限小于非const对象，权限不能放大。

    2. 非const对象可以调用const成员函数吗？

    可以，权限缩小。

    3. const成员函数内可以调用其它的非const成员函数吗？

    不能，const成员函数它承诺不会修改对象的状态。因此，const成员函数不能调用非const成员函数，因为非const成员函数可以修改对象的状态，权限的放大。

    4. 非const成员函数内可以调用其它的const成员函数吗？

    非const成员函数内可以调用其它的const成员函数。非const成员函数没有限制对对象的修改，因此可以调用const成员函数，而const成员函数不会修改对象的状态，与非const成员函数的调用不冲突。这种情况下，调用const成员函数不会违反const成员函数的承诺。

    7. 取地址及const取地址操作符重载

    这两个默认成员函数一般不用重新定义 ，编译器默认会生成。
     

    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. 	void Print() const
    12. 	{
    13. 		cout << "Print()const" << endl;
    14. 		cout << "year:" << _year << endl;
    15. 		cout << "month:" << _month << endl;
    16. 		cout << "day:" << _day << endl << endl;
    17. 	}
    18.  
    19.     //非const版本
    20. 	Date* operator&()
    21. 	{
    22. 		return this;
    23. 	}
    24.     
    25.     //const版本
    26. 	const Date* operator&()const
    27. 	{
    28. 		return this;
    29. 	}
    30.  
    31. private:
    32. 	int _year; // 年
    33. 	int _month; // 月
    34. 	int _day; // 日
    35. };

    朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，欲知后事如何，请听下回分解~，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！ 

  • 相关阅读:
    接口的用法、常量接口、微观接口和宏观接口（JAVA基础六）
    nodejs+vue+elementui网上书城 图书销售商城网站express
    【机器学习】训练集/验证集/测试集释疑
    CTFHub | 默认口令
    算法笔记-第九章-平衡二叉树
    MySQL分页存储概念清晰梳理
    计算机毕业设计Java精品在线试题库系统(源码+mysql数据库+系统+lw文档）
    weak的实现原理
    【第三方库】Windows编译libtorrent
    测试面试回顾（1）
  • 原文地址：https://blog.csdn.net/Yikefore/article/details/133465873