🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀
目录
🐰运算符重载的函数作为类的成员函数和友元函数
🌸运算符重载定义为类的成员函数
将运算符重载定义为类的成员函数的原型在内部声明格式：
1. class 类名 2. { 3. ... 4. 返回类型 operator 运算符(参数列表); 5. ... 6. };
在类外定义运算符重载函数的格式：
1. 返回类型 类名::operator 运算符(参数列表) 2. { 3. ... 4. }
🌸运算符重载函数作为类的友元函数
将运算符重载函数作为类的友元函数。它与用成员函数重载运算符的函数的不同在于，成员函数重载运算符的函数本身是类中的成员函数，而友元函数是独立于类外的普通函数。
将运算符重载函数定义为类的友元函数，其原型在类的内部声明格式如下：
1. class 类名 2. { 3. ... 4. friend 返回类型 operator 运算符(参数列表); 5. ... 6. };
在类外定义友元运算符重载函数的格式：
1. 返回类型 operator 运算符(参数列表) 2. { 3. ... 4. }
与用成员函数定义的方法相比较，只是在类声明函数原型时前面多了一个关键字friend，表明这是一个友元运算符重载函数，只有声明为友元函数，才可以访问类的private成员；由于友元运算符重载函数不是该类的成员函数，所以在类外定义时不需要加上类名。
🌸实现“+”，“-“的普通重载函数和友元重载函数
1. #include<iostream> 2. using namespace std; 3. class A 4. { 5. public: 6. A(double x=0,double y=0):a(x),b(y) 7. { 8. ; 9. } 10. void show() 11. { 12. cout<<"运算后的结果为："<<endl; 13. cout<<"("<<a<<","<<b<<")"<<endl; 14. } 15. A operator+(A& ptr);//运算符普通重载函数 16. A operator-(A& ptr); 17. // friend A operator+(A& pf,A& pc);//友元运算符重载函数 18. // friend A operator-(A& pf,A& pc); 19. private: 20. double a; 21. double b; 22. }; 23. A A::operator+(A& ptr)//为什么ptr可以调用私有成员 24. { 25. return A(a+ptr.a,b+ptr.b); 26. } 27. A A::operator-(A& ptr) 28. { 29. return A(a-ptr.a,b-ptr.b); 30. } 31. //A operator+(A& pf,A& pc) 32. //{ 33. // return A(pf.a+pc.a); 34. //} 35. //A operator-(A& pf,A& pc) 36. //{ 37. // return A(pf.a-pc.a,pf.b-pc.b); 38. //} 39. int main() 40. { 41. A a(1,0),b(0,1),c(1,0),d(0,1),ph; 42. ph=a+b; 43. ph.show(); 44. ph=a-b; 45. ph.show(); 46. return 0; 47. } 48. 普通重载函数和友元重载函数的结果都是一样的 49. 运算后的结果为： 50. (1,1) 51. 运算后的结果为： 52. (1,-1)
大家可能会疑惑，运算符重载函数可以是类的成员函数，也可以是类的友元函数，是否可以既不是类的成员函数也不是类的友元函数，其实是可以的，但是很少会用到，原因是普通函数不能直接访问类的私有成员，由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符重载为成员函数。有时为了方便理解，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。但是也有例外，C++规定，有的运算符（赋值运算符，下标运算符，函数调用运算符）必须重载为类的成员函数，有的运算符则不能重载为类的成员函数（插入运算符"<<"和流提取运算符">>"、类型转化运算符）。
🌸单目运算符"++"和"--"的重载
有两种形式：前置的++ --，后置的++ --
有两种方法：运算符重载的成员函数 运算符重载的友元函数
（1）运算符重载的成员函数：
1. （1）运算符重载的成员函数 2. #include<iostream> 3. using namespace std; 4. class A 5. { 6. public: 7. A(int count=0):Count(count) 8. { 9. ; 10. } 11. void show() 12. { 13. cout<<"运算后结果为:"<<Count<<endl; 14. } 15. //前置++，-- 16. A operator++() 17. { 18. ++Count; 19. return *this; 20. } 21. A operator--() 22. { 23. --Count; 24. return *this; 25. } 26. //后置++，-- 27. A operator++(int) 28. { 29. A num=*this; 30. ++(*this); 31. return num; 32. } 33. A operator--(int) 34. { 35. A num=*this; 36. --(*this); 37. return num; 38. } 39. private: 40. int Count; 41. }; 42. int main() 43. { 44. A a(100),b(100),c(100),d(100); 45. (++a).show(); 46. (b++).show(); 47. (--c).show(); 48. (d--).show(); 49. return 0; 50. } 51. 结果为： 52. 运算后结果为:101 53. 运算后结果为:100 54. 运算后结果为:99 55. 运算后结果为:100
（2）运算符重载的友元函数：
1. （1）运算符重载的成员函数 2. #include<iostream> 3. using namespace std; 4. class A 5. { 6. public: 7. A(int count=0):Count(count) 8. { 9. ; 10. } 11. void show() 12. { 13. cout<<"运算后结果为:"<<Count<<endl; 14. } 15. friend A operator++(A& ptr); 16. friend A operator--(A& ptr); 17. friend A operator++(A& ptr,int); 18. friend A operator--(A& ptr,int); 19. private: 20. int Count; 21. }; 22. //前置++，-- 23. A operator++(A& ptr) 24. { 25. ++ptr.Count; 26. return ptr; 27. } 28. A operator--(A& ptr) 29. { 30. --ptr.Count; 31. return ptr; 32. } 33. //后置++，-- 34. A operator++(A& ptr,int) 35. { 36. A num; 37. num=ptr; 38. ++ptr.Count; 39. return num; 40. } 41. A operator--(A& ptr,int) 42. { 43. A num; 44. num=ptr; 45. --ptr.Count; 46. return num; 47. } 48. 49. int main() 50. { 51. A a(100),b(100),c(100),d(100); 52. (++a).show(); 53. (b++).show(); 54. (--c).show(); 55. (d--).show(); 56. return 0; 57. } 58. 结果： 59. 运算后结果为:101 60. 运算后结果为:100 61. 运算后结果为:99 62. 运算后结果为:100
🌸🌸🌸如果大家还有不懂或者建议都可以发在评论区，我们共同探讨，共同学习，共同进步。谢谢大家！ 🌸🌸🌸
