c++运算符重载

c++运算符重载实质上是函数重载；

       运算符重载分为两大类，一：运算符重载作为类的成员函数，此时，该函数的参数个数比原操作数要少1个。这是由于作为成员函数，该类对象隐式作为左操作数。

       二：运算符重载在全局，此时，该重载函数的参数个数和原操作数一致。如：

1. class A
2. {
3. public:
4. A(int d):data(d){}
5. Aoperator+(A&);//成员函数
6. Aoperator-(A&);
7. Aoperator*(A&);
8. Aoperator/(A&);
9. Aoperator%(A&);
10. friend A operator+(A&,A&);//友元函数
11. friend Aoperator-(A&,A&);
12. friend Aoperator*(A&,A&);
13. friend Aoperator/(A&,A&);
14. friend Aoperator%(A&,A&);
15. private:
16. int data;
17. };
18. //成员函数的形式
19. A A::operator+(A&a)
20. {
21. return A(data+a.data);
22. }
24. A A::operator-(A&a)
25. {
26. return A(data-a.data);
27. }
29. A A::operator*(A&a)
30. {
31. return A(data*a.data);
32. }
34. A A::operator/(A&a)
35. {
36. return A(data/a.data);
37. }
39. A A::operator%(A&a)
40. {
41. return A(data%a.data);
42. }
43. 既然是作为类的成员函数，那么调用时候的写法有：
44. A a,b;
45. a.operator%(b);//也可以写成a%b;
46. 

47. //友元函数的形式 在外部重载
48. Aoperator+(A&a1,A&a2)
49. {
50. return A(a1.data+a2.data);
51. }
53. Aoperator-(A&a1,A&a2)
54. {
55. return A(a1.data-a2.data);
56. }
58. Aoperator*(A&a1,A&a2)
59. {
60. return A(a1.data*a2.data);
61. }
63. Aoperator/(A&a1,A&a2)
64. {
65. return A(a1.data/a2.data);
66. }
68. Aoperator%(A&a1,A&a2)
69. {
70. return A(a1.data%a2.data);
71. }

另外 自增自减运算符

1. A&operator++();//前置++
2. Aoperator++(int);//后置++
3. A&operator--();//前置--
4. Aoperator--(int);//后置--
5. 内存运算符的重载
6. void*operatornew(size_t size);
7. void*operatornew(size_t size,int i);
8. void*operatornew[](size_t size);
9. voidoperatordelete(void*p);
10. voidoperatordelete(void*p,int i,int j);
11. voidoperatordelete[](void* p);
12. 以上这些都有两种重载形式，既可以作为类的成员函数，又可以作为非成员函数。
13. 
    
14. 
    

类型转换运算符只能作为类的成员函数

1. operatorchar*()const;
2. operatorint();
3. operatorconstchar()const;
4. operatorshortint()const;
5. operatorlonglong()const;
6. 因为：运算符重载就是函数重载，要遵循函数重载的原则，不能改变原有的运算符的功能，只是在原来的功能上，新增了新的功能。
7. 而类型转换运算符重载为全局函数，那么会和原本的功能产生二义性，所以，它们只能重载作为类的成员函数。

重载指向(->)操作符，与众不同，它表现的像二元操作符一样，一个对象名和一个成员名，但不管，表现怎么样，重载指向操作符时，因为->右操作数是成员，所以不接受参数。

（是由编译器获取成员工作）

c++规定 =，[]，()，->这四个运算符只能被重载为成员函数。这是因为重载为友元函数会与原来的功能冲突。

运算符重载规则：

1、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已经有的运算符。
2、重载之后运算符的优先级和结合性都不会改变
3、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造，一般来讲，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。
    注意：不能重载的运算符只有5个，它们是类属关系运算符“.”、成员指针运算符“.*”、作用域分辨符“::”、sizeof运算符和三木运算符“?:”。前面两个运算符保证了C++中访问成员功能的含义不被改变。作用域分辨符和sizeof运算符的操作数是类型。
重载函数要意义明确，不能产生二义性。
new operator和opeartor new的差别？

例子 string *ps = new string("memory management");

这里使用的new是所谓的new operator，它实际上做两件事：一是分配内存，二是调用一个constructor（构造函数）；new operator总是做这两件事；我们能改变的是它分配内存的行为，也就是operator new,它只分配内存和malloc一样；

new operator里包含operator new，即先调用使用new时（new operator）,先通过operator new分配内存，然后在调用
constructor（构造函数），我们能重载的实际上是operator new 分配内存的行为。