c++/《重载操作符》

本文主要是介绍c++/《重载操作符》，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

为什么要对运算符进行重载：

        C++预定义中的运算符的操作对象只局限于基本的内置数据类型，但是对于我们自定义的类型（类）是没有办法操作的。但是大多时候我们需要对我们定义的类型进行类似的运算，这个时候就需要我们对这么运算符进行重新定义，赋予其新的功能，以满足自身的需求。

<返回类型说明符> operator <运算符符号>(<参数表>)  
{  <函数体>  }  

 

 

 

C++运算符重载的实质：

        运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。要重载运算符，需要使用被称为运算符函数的特殊函数形式，运算符函数形式：operatorp（argument-list）//operator 后面的'p'为要重载的运算符符号。

运算符重载的规则：

1.C++规定重载后的运算符的操作对象必须至少有一个是用户定义的类型

 

2.使用运算符不能违法运算符原来的句法规则。如不能将% 重载为一个操作数

例如：
int index；

%index；这种是不被允许的。

3.不能修改运算符原先的优先级。

4.不能创建一个新的运算符，例如不能定义operator** （···）来表示求幂

5.不能进行重载的运算符：成员运算符，作用域运算符，条件运算符，sizeof运算符，typeid（一个RTTI运算符），const_cast、dynamic_cast、reinterpret_cast、static_cast强制类型转换运算符

6.大多数运算符可以通过成员函数和非成员函数进行重载但是下面这四种运算符只能通过成员函数进行重载：

= 赋值运算符，（）函数调用运算符，[ ]下标运算符，->通过指针访问类成员的运算符。

7.除了上述的规则，其实我们还应该注意在重载运算符的时候遵守一些明智的规则：例如：不要将+运算符重载为交换两个对象的值。

 

 

重载运算符的两种形式：

重载运算符有两种方式，即：重载为类的成员函数||重载为类的非成员函数。

        重载为类的非成员函数的时候:通常我们都将其声明为友元函数，因为大多数时候重载运算符要访问类的私有数据，（当然也可以设置为非友元非类的成员函数。但是非友元又不是类的成员函数是没有办法直接访问类的私有数据的），如果不声明为类的友元函数，而是通过在此函数中调用类的公有函数来访问私有数据会降低性能。所以一般都会设置为类的友元函数，这样我们就可以在此非成员函数中访问类中的数据了。

1.一般运算符重载

在进行对象之间的运算时，程序会调用与运算符相对应的函数进行处理，所以运算符重载有两种方式：成员函数和友元函数。成员函数的形式比较简单，就是在类里面定义了一个与操作符相关的函数。友元函数因为没有this指针，所以形参会多一个。

 

1. class A
2. {
3. public:
4. A(int d):data(d){}
5. A operator+(A&);//成员函数
6. A operator-(A&);
7. A operator*(A&);
8. A operator/(A&);
9. A operator%(A&);
10. friend A operator+(A&,A&);//友元函数
11. friend A operator-(A&,A&);
12. friend A operator*(A&,A&);
13. friend A operator/(A&,A&);
14. friend A operator%(A&,A&);
15. private:
16. int data;
17. };
18. //成员函数的形式
19. A A::operator+(A &a)
20. {
21. return A(data+a.data);
22. }
23.  
24. A A::operator-(A &a)
25. {
26. return A(data-a.data);
27. }
28.  
29. A A::operator*(A &a)
30. {
31. return A(data*a.data);
32. }
33.  
34. A A::operator/(A &a)
35. {
36. return A(data/a.data);
37. }
38.  
39. A A::operator%(A &a)
40. {
41. return A(data%a.data);
42. }
43. //友元函数的形式
44. A operator+(A &a1,A &a2)
45. {
46. return A(a1.data+a2.data);
47. }
48.  
49. A operator-(A &a1,A &a2)
50. {
51. return A(a1.data-a2.data);
52. }
53.  
54. A operator*(A &a1,A &a2)
55. {
56. return A(a1.data*a2.data);
57. }
58.  
59. A operator/(A &a1,A &a2)
60. {
61. return A(a1.data/a2.data);
62. }
63.  
64. A operator%(A &a1,A &a2)
65. {
66. return A(a1.data%a2.data);
67. }
68.  
69. //然后我们就可以对类的对象进行+、-、*、/了。
70. void main(void)
71. {
72. A a1(1),a2(2),a3(3);
73. a1=a2+a3;
74. //或者
75. a1=a2.operator+(a3);
76. }

注意：在进行a2+a3的时候会出错，因为我们在上面对+定义了两种方法，去掉一种即可。

2.关系运算符重载

因为函数体比较简单，后面我就只给出成员函数形式的函数声明了，关系运算符有==,!=,<,>,<=,>=。

 

1. bool operator == (const A& );
2. bool operator != (const A& );
3. bool operator < (const A& );
4. bool operator <= (const A& );
5. bool operator > (const A& );
6. bool operator >= (const A& );

3.逻辑运算符重载

1. bool operator || (const A& );
2. bool operator && (const A& );
3. bool operator ! ();

4.单目运算符重载

这里的+、-是正负的意思，放在对象前面。

1. A& operator + ();
2. A& operator - ();
3. A* operator & ();
4. A& operator * ();

5.自增减运算符重载

++和--根据位置的不同有四种情况，都可以重载。

1. A& operator ++ ();//前置++
2. A operator ++ (int);//后置++
3. A& operator --();//前置--
4. A operator -- (int);//后置--

6.位运算符重载

按位操作。

1. A operator | (const A& );
2. A operator & (const A& );
3. A operator ^ (const A& );
4. A operator << (int i);
5. A operator >> (int i);
6. A operator ~ ();

7.赋值运算符重载

没有=哦。

1. A& operator += (const A& );
2. A& operator -= (const A& );
3. A& operator *= (const A& );
4. A& operator /= (const A& );
5. A& operator %= (const A& );
6. A& operator &= (const A& );
7. A& operator |= (const A& );
8. A& operator ^= (const A& );
9. A& operator <<= (int i);
10. A& operator >>= (int i);

8.内存运算符重载

1. void *operator new(size_t size);
2. void *operator new(size_t size, int i);
3. void *operator new[](size_t size);
4. void operator delete(void*p);
5. void operator delete(void*p, int i, int j);
6. void operator delete [](void* p);

9.特殊运算符重载

上面的运算符重载都有两种方式，而下面的运算符只能用一种，特殊吧。 这些运算符的重载只能是成员函数。

1. A& operator = (const A& );
2. char operator [] (int i);//返回值不能作为左值
3. const char* operator () ();
4. T operator -> ();
5.  
6. //类型转换符
7. operator char* () const;
8. operator int ();
9. operator const char () const;
10. operator short int () const;
11. operator long long () const;
12. //还有很多就不写了

而这些只能以友元函数的形式重载

1. friend inline ostream &operator << (ostream&, A&);//输出流
2. friend inline istream &operator >> (istream&, A&);//输入流

10.总结

两种重载方式的比较：

• 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
• 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。
• 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。 C++提供4个类型转换函数：reinterpret_cast（在编译期间实现转换）、const_cast（在编译期间实现转换）、stactic_cast（在编译期间实现转换）、dynamic_cast（在运行期间实现转换，并可以返回转换成功与否的标志）。
• 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
• 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
• 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部 类型的对象，该运算符函数必须作为一个友元函数来实现。
• 当需要重载运算符具有可交换性时，选择重载为友元函数。

注意事项：

1. 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，C++中的所有运算符都可以重载。
2. 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
3. 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
4. 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
5. 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
6. 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。

 

这篇关于c++/《重载操作符》的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---