• c++类和对象（二）六个默认成员函数。

    目录

    <一>构造函数

    1.概念

    2,特征

    <二>析构函数

    特性

    <三>拷贝构造

    特性

    <四>赋值运算符重载

    1，运算符重载（都是针对自定义类型的，和内置类型没关系）

    注意：一般运算符重载都定义在类里面，如果定义全局的话，就会要把成员变量改为公有的，一般这样不好，或者用友元函数的方法，但是最常用的就是定义在类里面。方便一些。

    2，赋值运算符重载

    绪论：

    我们给出一个空类真的里面什么都没有吗？并不是，任何类在什么都不写的情况下，编译器会默认生成六个默认成员函数（用户没有实现，编译器会自动生成的成员函数称为默认成员函数）。假如我们自己实现了编译器就不会生成了，有些类需要我们自己写，而有些类不需要我们自己写。

    <一>构造函数

    1.概念

    对于date类：

    1. #include
    2. using namespace std;
    3.  
    4. class Date
    5. {
    6. public:
    7. 	void Init(int year, int month, int day)
    8. 	{
    9. 		_year = year;
    10. 		_month = month;
    11. 		_day = day;
    12. 	}
    13. 	void print()
    14. 	{
    15. 		cout << _year << '/' << _month << '/' << _day << endl;
    16. 	}
    17. private:
    18. 	int _year;
    19. 	int _month;
    20. 	int _day;
    21. };

    一个日期类我们可以通过加入一个成员函数（Init）来实现给对象初始化，但是这这回有有一个问题，有时候会忘记调用这个成员函数就会造成很不好的后果，有点太麻烦了。这就需要我们用到构造函数了。

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

    2,特征

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

    特征

    1，函数名于类名相同。

    2，无返回值。

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

    4，构造函数的也可以重载，可以写多个构造函数，这样就会有多种初始化方式。一般会将无参和半缺省合并直接用全缺省来表示。

    1. class Date
    2. {
    3. public:
    4. 	Date()//可以无参构造。/调用/Date a;
    5. 	{
    6. 		_year = 0;
    7. 		_month = 0;
    8. 		_day = 0;
    9. 	}
    10.  
    11. 	Date(int year, int month,int day)//可以带参构造。  /调用/ Date a(2022,10,20);
    12. 	{
    13. 		_year = year;
    14. 		_month = month;
    15. 		_day = day;
    16. 	}
    17.  
    18. 	Date(int year, int month =10, int day = 20)//可以半缺省。/调用/  Date a(2022) 或者 Date a(2022,10); 或者  Date a(2022,10,20);
    19. 	{
    20. 		_year = year;
    21. 		_month = month;
    22. 		_day = day;
    23. 	}
    24.  
    25. 	Date(int year = 2022, int month =10 , int day = 20)//可以全缺省。  /调用/Date a; 或者 Date a(2022); 或者 Date a(2022,10); 或者  Date a(2022,10,20);
    26. 	{
    27. 		_year = year;
    28. 		_month = month;
    29. 		_day = day;
    30. 	}
    31.     //一般直接如果自己写构造函数的话，就会使用全缺省的构造函数，可以涵盖所有的对象定义方式。
    32. 	void print()
    33. 	{
    34. 		cout << _year << '/' << _month << '/' << _day << endl;
    35. 	}
    36. private:
    37. 	int _year;
    38. 	int _month;
    39. 	int _day;
    40. };
    41.  
    42. int main()
    43. {
    44. 	Date a();//注意不能这样写。这是函数的声明，不是类对象的定义。
    45. 	//注意这里的通过无参构造函数在创建对象的时候，对象后面不用加（），否则就成了函数的声明。
    46. 	return 0;
    47. }

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

    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month=10, int day=20) //半缺省  / 调用 / Date a(2022) 或者 Date a(2022, 10); 或者  Date a(2022, 10, 20);
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    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 a;
    24. //将Date屏蔽后可以编译通过，编译器生成了一个无参的默认构造函数。
    25. //将Date放开后，编译器就不再生成，就会出现问题，没有合适的默认构造函数可用。
    26. /// 应该调用 / Date a(2022) 或者 Date a(2022, 10); 或者  Date a(2022, 10, 20);
    27. 	return 0;
    28. }

    6，编译会自动生成默认构造函数，为什么还需要我们自己定义一个构造函数呢。答案就是编译器自动生成的构造函数，对内置类型不处理，而对自定义类型又会调用该自定义类型的默认构造函数。有时候不能满足我们的需求。就需要我们自己写默认构造函数。

    1.  
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. class Time
    7. {
    8. public:
    9. 	Time(int hour = 0, int minute = 0, int second = 0)//默认构造函数
    10. 	{
    11. 		cout << "time(int ,int ,int)" << endl;
    12. 		_hour = hour;
    13. 		_minute = minute;
    14. 		_second = second;
    15. 	}
    16.  
    17. 	//这个也是默认构造函数 但是一般用上面的定义方式。
    18. 	//Time()//默认构造函数
    19. 	//{
    20. 	//	cout << "time()" << endl;
    21. 	//	_hour = 0;
    22. 	//	_minute = 0;
    23. 	//	_second = 0;
    24. 	//}
    25. 	void print()
    26. 	{
    27. 		cout << _hour<<'/' << _minute<<'/' << _second << endl;
    28. 	}
    29.  
    30. private:
    31. 	int _hour;
    32. 	int _minute;
    33. 	int _second;
    34. };
    35.  
    36.  
    37. class Date
    38. {
    39. public:
    40. 	void print()
    41. 	{
    42. 		cout << _year<<'/' << _month<<'/' << _day << '/' << endl;
    43. 		_a.print();
    44. 	}
    45.  
    46. private:
    47. 	//内置类型
    48. 	int _year;
    49. 	int _month;
    50. 	int _day;
    51. 	//自定义类型
    52. 	Time _a;
    53. };
    54.  
    55. int main()
    56. {
    57. 	Date a;
    58. 	a.print();
    59. 	return 0;
    60. }

    运行结果：我们可以看到  对于内置类型并没有初始化，而是随机数。对于自定义类型则调用了他的默认构造函数。

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

    1. class Date
    2. {
    3. public:
    4. 	void print()
    5. 	{
    6. 		cout << _year<<'/' << _month<<'/' << _day << '/' << endl;
    7. 		_a.print();
    8. 	}
    9.  
    10. private:
    11. 	//内置类型
    12. 	int _year = 2022;
    13. 	int _month = 10;///c++11的补丁 内置类型声明的时候可以给默认值
    14. 	int _day = 20;//就是一种缺省值
    15. 	//自定义类型
    16. 	Time _a;
    17. };
    18.  
    19. int main()
    20. {
    21. 	Date a;
    22. 	a.print();
    23. 	return 0;
    24. }

    运行结果为：这样也能兼顾内置；类型的问题了。

    7.无参的构造函数和全缺省的构造函数都称为默认构造函数。并且默认构造函数只能有一个。也就是无参的全缺省的构造函数只能有一个存在。俩都存在就会造成歧义。

    注意：无参的构造函数，全缺省的构造函数 ，以及我们没写编译器自动生成的构造函数都是默认构造函数。如果我们写的是半缺省的构造函数，就必须要传参了。如果我们写了，但是不是默认构造函数，普通的构造函数就有不传参定义就会有问题。

    1.  
    2. class Time
    3. {
    4. public:
    5. 	Time(int hour = 0, int minute = 0, int second = 0)//默认构造函数
    6. 	{
    7. 		cout << "time(int ,int ,int)" << endl;
    8. 		_hour = hour;
    9. 		_minute = minute;
    10. 		_second = second;
    11. 	}
    12.  
    13. 	//这个也是默认构造函数 但是一般用上面的定义方式。//但是两个不能同时存在。会出现调用歧义的问题。
    14. 	Time()//默认构造函数
    15. 	{
    16. 		cout << "time()" << endl;
    17. 		_hour = 0;
    18. 		_minute = 0;
    19. 		_second = 0;
    20. 	}
    21.  
    22. 	void print()
    23. 	{
    24. 		cout << _hour << '/' << _minute << '/' << _second << endl;
    25. 	}
    26.  
    27. private:
    28. 	int _hour;
    29. 	int _minute;
    30. 	int _second;
    31. };

    <二>析构函数

    析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。资源包括动态开辟的空间，文件的关闭等。相当于C语言阶段写的destroy函数。

    特性

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

    2 无参数无返回值类型。

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

    4  对象生命周期结束时，C++编译系统系统自动调用析构函数。避免自己遗忘的问题。

    5 一般有资源需要释放一般使用过：malloc fopen的类都需要自己写默认析构函数。如果编译器自动生成的够用就不需要自己写。

    1. class stack
    2. {
    3.  
    4. public:
    5. 	stack(int capacity = 10)//这是默认构造函数
    6. 	{
    7. 		cout << "stack()" << endl;
    8. 		_capacity = capacity;
    9. 		_array = (int*)malloc(sizeof(int) * capacity);
    10. 		_size = 0;
    11. 	}
    12.  
    13. 	~stack()//这就是一个标准的默认析构函数。//需要我们手动释放空间，或者关闭文件。
    14. 	{
    15. 		cout << "~stack()" << endl;
    16.  
    17. 		if (_array)
    18. 		{
    19. 			free(_array);
    20. 			_array = nullptr;
    21. 			_size = 0;
    22. 			_capacity = 0;
    23. 		}
    24. 	}
    25.  
    26. private:
    27. 	int* _array;
    28. 	int _size;
    29. 	int _capacity;
    30. };
    31.  
    32. int main()
    33. {
    34. 	stack a;
    35. 	return 0;
    36. }

    6 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定义类型会调用他的默认析构函数。对于内置类型不处理，内置类型也不需要处理。因为没有额外的空间。

    1. class stack
    2. {
    3.  
    4. public:
    5. 	stack(int capacity = 10)
    6. 	{
    7. 		cout << "stack()" << endl;
    8. 		_capacity = capacity;
    9. 		_array = (int*)malloc(sizeof(int) * capacity);
    10. 		_size = 0;
    11. 	}
    12.  
    13. 	~stack()
    14. 	{
    15. 		cout << "~stack()" << endl;
    16.  
    17. 		if (_array)
    18. 		{
    19. 			free(_array);
    20. 			_array = nullptr;
    21. 			_size = 0;
    22. 			_capacity = 0;
    23. 		}
    24. 	}
    25.  
    26. private:
    27. 	int* _array;
    28. 	int _size;
    29. 	int _capacity;
    30. };
    31.  
    32. class My_Queue
    33. {
    34. public:
    35. 	//
    36. private:
    37. 	//内置类型
    38. 	int size;
    39.  
    40. 	//自定义类型 ，会调用他的析构函数。和构造函数相同。
    41. 	stack push;
    42. 	stack pop;
    43. };
    44.  
    45.  
    46. int main()
    47. {
    48. 	My_Queue a;
    49. //和构造函数相同，在a定义的时候会生成自己的默认构造函数，函数内部对内置类型不处理，对自定义类型会调用他的默认构造函数
    50. //在a的生命周期结束的时候，a类也会自动生成一个默认析构函数，对自定义类型会调用他自己的默认析构函数。
    51. //内置类型不需要资源清理，最后直接由造作系统将其内存回收即可。
    52.  
    53. 	return 0;
    54. }

    注意：那个类对象的声明周期结束，调用那个类的默认析构函数，该默认析构函数内部，对内置类型不处理，对自定义类型会调用他的默认析构函数。

    7对于有资源申请时候一定要写析构函数，否则就会造成内存泄漏的问题。

    <三>拷贝构造

    在创建对象的时候，我们可否创建一个与已存在对象一模一样的新对象。这个时候就需要用到拷贝构造函数了。拷贝构造也是一种构造函数，是构造函数的一种重载。只是参数不一样。

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

    特性

    1，拷贝构造函数是构造函数的一个重载形式。

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

    1. #include
    2. using namespace std;
    3.  
    4. class Date
    5. {
    6. public:
    7.  
    8. 	Date(int year =2022, int month=10, int day=20)
    9. 	{
    10. 		_year = year;
    11. 		_month = month;
    12. 		_day = day;
    13. 	}
    14.  
    15. 	Date(const Date& d)//这就是一个标准的拷贝构造函数，参数是对应类型的const引用
    16. 	{
    17. 		_year = d._year;
    18. 		_month = d._month;
    19. 		_day = d._day;
    20. 	}//虽然用指针也能实现对应的功能但是，那样只是一个普通的构造函数，不是拷贝构造。
    21.  
    22. 	Date(const Date d)//这里是错误的会引发无穷递归。
    23. 	{
    24. 		_year = d._year;
    25. 		_month = d._month;
    26. 		_day = d._day;
    27. 	}
    28.  
    29. 	void print()
    30. 	{
    31. 		cout << _year << '/' << _month << '/' << _day << endl;
    32. 	}
    33.  
    34. private:
    35. 	int _year;
    36. 	int _month;
    37. 	int _day;
    38. };
    39.  
    40.  
    41. int main()
    42. {
    43. 	Date d1;
    44. 	Date d2(d1);
    45. 	d1.print();
    46. 	d2.print();
    47.  
    48. 	return 0;
    49. }

    想要了解为什么这里会引发无穷递归？我们需要先知道，什么情况下会调用拷贝构造这个函数。

    1. void fun(Date d)
    2. {
    3. 	;
    4. }
    5.  
    6. int main()
    7. {
    8. 	Date d1;//这里调用默认构造函数
    9.  
    10.  
    11. 	//对象定义的时候会调用拷贝构造函数
    12. 	Date d2(d1);
    13. 	//传值传参的时候也会调用拷贝构造
    14. 	fun(d1);
    15.  
    16.     //做返回值的时候也会调用拷贝构造。
    17. 	return 0;
    18. }

    回到我们刚刚的问题为什么拷贝构造传值的时候会引发无穷递归呢？用d1给d2传值传参的时候，会调用拷贝构造函数，又会去传参，就这样一直调用下去无穷递归。

    3，如果未显示定义，编译器会生成默认的拷贝构造函数，默认的拷贝构造函数。默认的拷贝构造函数按照内存存储的字节序完成拷贝，这种叫做浅拷贝，或者值拷贝。有些时候浅拷贝是我们需要的，有些时候并不是我们需要的值，例如一个stack类型的类，里面会malloc内存空间地址。如果我们只是简单的值拷贝的话 就会出现一个问题。两个对象同时指向同一块内存空间地址。这样是错误的。是不需要深拷贝就可以的，比如日期类

    1.  
    2.  
    3.  
    4. class Time
    5. {
    6. public:
    7. 	Time(int hour = 0, int minute = 0, int second = 0)//默认构造函数
    8. 	{
    9. 		_hour = hour;
    10. 		_minute = minute;
    11. 		_second = second;
    12. 	}
    13. 	void print()
    14. 	{
    15. 		cout << _hour<<'/' << _minute<<'/' << _second << endl;
    16. 	}
    17. private:
    18. 	int _hour;
    19. 	int _minute;
    20. 	int _second;
    21. };
    22.  
    23. class Date
    24. {
    25. public:
    26. 	void print()
    27. 	{
    28. 		cout << _year<<'/' << _month<<'/' << _day << '/' << endl;
    29. 		_a.print();//注意在这里我们无法直接访问到Time _a 私有的成员变量。
    30. 	}
    31. private:
    32. 	//内置类型
    33. 	int _year = 2022;//偷懒给了默认值
    34. 	int _month = 10;
    35. 	int _day = 20;
    36. 	//自定义类型
    37. 	Time _a;
    38. };
    39. int main()
    40. {
    41. 	Date a;
    42. 	Date b(a);
    43. 	b.print();
    44. 	return 0;
    45. }

     stack就需要深拷贝

    1.  
    2. class stack
    3. {
    4. public:
    5. 	stack(int capacity = 10)//默认构造函数
    6. 	{
    7. 		_arr = (int*)malloc(sizeof(int) * capacity);
    8. 		_size = 0;
    9. 		_capacity = capacity;
    10. 	}
    11. 	~stack()
    12. 	{
    13. 		if (_arr)
    14. 		{
    15. 			free(_arr);
    16. 			_arr = nullptr;
    17. 			_capacity = 0;
    18. 			_size = 0;
    19. 		}
    20. 	}
    21. 	void push(int x)
    22. 	{
    23. 		_arr[_size] = x;
    24. 		_size++;
    25. 	}
    26. 	stack(stack& a)
    27. 	{
    28. 		//这里只是演示就不扩容了
    29. 		_arr = (int*)malloc(sizeof(int) * a._capacity);
    30. 		_capacity = a._capacity;
    31. 		_size = a._size;
    32. 		memmove(_arr, a._arr, sizeof(int) * _capacity);//注意这里不能丢掉
    33.  
    34. 	}
    35. private:
    36. 	int* _arr;
    37. 	int _size;
    38. 	int _capacity;
    39. };
    40.  
    41.  
    42. int main()
    43. {
    44. 	stack a;
    45. 	a.push(1);
    46. 	a.push(2);
    47. 	a.push(3);
    48. 	a.push(4);
    49. 	stack b(a);
    50. //大家可以通过监视窗口去看看  b和a的地址肯定是不同的。
    51. 	return 0;
    52. }

    4， 一般需要写析构函数的类，都需要写拷贝构造函数。其实深拷贝就是在拷贝的开辟的资源。如果一个类没有涉及到资源申请时，拷贝构造函数是否写都可以，但是一旦涉及到资源申请，就必须写拷贝构造。否则就是浅拷贝。

    5，有时候我们写的类，不写拷贝构造就会出现错误，而有些就刚刚好是我们需要的。这个要视情况而定。（上面的例子就会报错，同一块空间被free两次这是错误的）。

    6，什么时候会用调用拷贝构造呢？1使用已存在的对象创建新对象，2函数传值传参，3函数返回值类型为类类型的对象。（可以用引用解决一些问题）

    1. class Date
    2. {
    3. public:
    4.  
    5. 	Date(int year =2022, int month=10, int day=20)
    6. 	{
    7. 		_year = year;
    8. 		_month = month;
    9. 		_day = day;
    10. 	}
    11.  
    12. 	Date(const Date& d)//这就是一个标准的拷贝构造函数，参数是对应类型的const引用
    13. 	{
    14. 		cout << "Date(Date & d)" << endl;
    15. 		_year = d._year+100;
    16. 		_month = d._month+100;
    17. 		_day = d._day+100;
    18. 	}
    19.  
    20. 	void print()
    21. 	{
    22. 		cout << _year << '/' << _month << '/' << _day << endl;
    23. 	}
    24.  
    25. private:
    26. 	int _year;
    27. 	int _month;
    28. 	int _day;
    29. };
    30.  
    31. Date d1;	//这里调用默认构造函数
    32.  
    33. void fun1(Date d)
    34. {
    35. 	;
    36. }
    37.  
    38. Date fun2()
    39. {
    40. 	return d1;
    41. }
    42.  
    43. int main()
    44. {
    45. 	//对象定义的时候会调用拷贝构造函数
    46. 	Date d2(d1);
    47.  
    48. 	//传值传参的时候也会调用拷贝构造
    49. 	fun1(d1);
    50.  
    51. 	//做返回值的时候也会调用拷贝构造。
    52. 	fun2();
    53. 	
    54. 	return 0;
    55. }

    结果为：

    <四>赋值运算符重载

    1，运算符重载（都是针对自定义类型的，和内置类型没关系）

    c++为了增强代码的可读性，引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有返回值类型，函数名字以及参数列表。其返回值类型于参数列表与参数列表与普通的函数类似。

    函数名字为：关键字operator后面接需要重载的运算符号。

    函数原型为：返回值类型  operator运算符（参数列表）

    注意：

    • 不能通过连接其他符号来创建新的操作符：比如operator@
    • 重载操作符必须有一个类类型的参数
    • 用于内置类型的运算符，其含义不能修改，例如内置类型的 + 不能该变他的含义。
    • 作为类成员函数重载时，其形参看起来比操作数数目少一个，因为成员函数的第一个参数为隐藏的this指针。
    • （.*   ::    sizeof    ? :     .    ）注意以上5个运算符不能重载。这个经常在笔试选择题中出 现。
    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 2022, int month = 10, int day = 21)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	void print();
    11. 	bool operator==(const Date& d2);
    12.  
    13. 	bool operator>(const Date& d2)
    14. 	{
    15. 		if (_year > d2._year)
    16. 		{
    17. 			return true;
    18. 		}
    19. 		else if (_year < d2._year)
    20. 		{
    21. 			return false;
    22. 		}
    23. 		else
    24. 		{
    25. 			if (_month > d2._month)
    26. 			{
    27. 				return true;
    28. 			}
    29. 			else if (_month < d2._month)
    30. 			{
    31. 				return false;
    32. 			}
    33. 			else
    34. 			{
    35. 				if (_day > d2._day)
    36. 				{
    37. 					return true;
    38. 				}
    39. 				else if (_day < d2._day)
    40. 				{
    41. 					return false;
    42. 				}
    43. 				else
    44. 				{
    45. 					return false;
    46. 				}
    47. 			}
    48. 		
    49. 		}
    50. 	}
    51.  
    52. 	bool operator>=(Date& d2)
    53. 	{
    54. 		//return *this > d2 || *this == d2;
    55. 		return this->operator>(d2) || this->operator==(d2);
    56. 	}
    57.  
    58.  
    59. 	int GetMonthDay(int year, int month)//获取对应年对应月的天数。
    60. 	{
    61. 		//可以把他改为静态的，不用每次调用就创建。
    62. 		static int arr[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    63.  
    64. 		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
    65. 		{
    66. 			return 29;
    67. 		}
    68. 		else
    69. 		{
    70. 			return arr[month];
    71. 		}
    72. 	}
    73.  
    74. 	Date& operator+=(int day)
    75. 	{
    76. 		_day += day;
    77. 		while (_day > GetMonthDay(_year, _month))
    78. 		{
    79. 			int ret= GetMonthDay(_year, _month);
    80. 			_day -= ret;
    81. 			_month++;
    82.  
    83. 			if (_month == 13)
    84. 			{
    85. 				_year++;
    86. 				_month = 1;
    87. 			}
    88. 		}
    89. 		return *this;
    90. 	}
    91.  
    92. private:
    93. 	int _year;
    94. 	int _month;
    95. 	int _day;
    96. };
    97.  
    98. int main()
    99. {
    100.     Date d1;
    101.     Date d2;
    102.  
    103.     cout<<(d1==d2)<//隐式调用
    104.     cout<//显示调用
    105.     //两种调用都是相同的意思，但是一般用隐式调用。可读性更高。
    106.  
    107.     return 0；
    108. }

    注意：一般运算符重载都定义在类里面，如果定义全局的话，就会要把成员变量改为公有的，一般这样不好，或者用友元函数的方法，但是最常用的就是定义在类里面。方便一些。

    2，赋值运算符重载

    1. 赋值运算符重载格式

    • 参数类型：const T&，传递引用可以提高传参效率。
    • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值。
    • 检测是否自己给自己赋值。
    • 返回*this ：要复合连续赋值的含义。
    1. class Date
    2. {
    3. public:
    4. 	Date(int year = 2022, int month = 10, int day = 21)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	Date(const Date& d)
    11. 	{
    12. 		_year = d._year;
    13. 		_month = d._month;
    14. 		_day = d._day;
    15. 	}
    16. 	//赋值重载
    17. 	Date& operator=(const Date& d)
    18. 	{
    19. 		if (this != &d)
    20. 		{
    21. 			_year = d._year;
    22. 			_month = d._month;
    23. 			_day = d._day;
    24. 		}
    25.  
    26. 		return *this;
    27. 	}
    28. 	void print()
    29. 	{
    30. 		cout << _year << '/' << _month << '/' << _day << '/'<
    31. 	}
    32.  
    33. private:
    34. 	int _year;
    35. 	int _month;
    36. 	int _day;
    37. };
    38.  
    39.  
    40.  
    41. int main()
    42. {
    43. 	Date d1(2001, 9, 9);
    44. 	Date d2;
    45.  
    46.  
    47. 	d2.print();
    48. 	d2 = d1;
    49. 	d2.print();
    50.  
    51.  
    52.  
    53. 	return 0;
    54. }
    55.  
    56.

    • 赋值运算符只能重载成类的成员函数不能重载成全局函数
    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. 	void print()
    11. 	{
    12. 		cout << _year << '/' << _month << '/' << _day << endl;
    13. 	}
    14. 	//公有的
    15. 	int _year;
    16. 	int _month;
    17. 	int _day;
    18. };
    19. // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
    20. Date& operator=(Date& left, const Date& right)
    21. {
    22. 	if (&left != &right)
    23. 	{
    24. 		left._year = right._year;
    25. 		left._month = right._month;
    26. 		left._day = right._day;
    27. 	}
    28. 	return left;
    29. }
    30. int main()
    31. {
    32. 	Date d1(2001, 9, 9);
    33. 	Date d2;
    34. 	d2.print();
    35. 	d2 = d1;
    36. 	d2.print();
    37.  
    38. 	return 0;//这里编译器会报错
    39. }

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

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

    这里回到我们刚刚写的第一个例子Date类，如果我们没有给赋值重载，也是可以达到我们想要的意思的。和拷贝构造差不多。如果我没没实现编译会自动生成一个，这个赋值重载对于内置类型直接memmove，对于自定义类型直接调用他的赋值重载。

  • 相关阅读:
    RecyclerView的好朋友 — SnapHelpter
    .NET集成DeveloperSharp操作Sql Server数据库
    leetcode做题笔记138. 复制带随机指针的链表
    GPS北斗卫星授时服务器架设具体有哪几步？
    洛谷P3065 First G
    JavaScript常用函数
    在香橙派OrangePi 3 LTS开发板上安装向日葵远程控制软件的操作方法
    MyBatis完成添加、修改、删除功能
    OpenCV--图像的运算
    C# TextBox如何变成多行且右边可以上下拉动
  • 原文地址：https://blog.csdn.net/zxf123567/article/details/127419737