C++如何实现操作符重载

这篇文章主要介绍了C++如何实现操作符重载，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

在C++中经常会遇到重载运算符的问题，其实运算符重载必须将运算符看做
一个函数，分清他的形参返回值，必须搞清楚内存在哪里如何分配如何回收
什么时候生成匿名对象，什么时候使用this指针返回。
运算符可以用友元函数和成员函数完成，一般来讲都使用成员函数，但是某些
特殊的情况必须使用友元函数，比如<< 因为其左操作数为ostream&类型，是不
可能进行任何修改的。

成员函数运算符重载大体步骤如下：

比如Tclass a
Tclass b
我们要重载=号
a = b
1、将需要重载的运算符看做一个函数生成operator函数名
如重载等待=
即operator=
2、分清楚形参
如果是等号重载很明显如果是成员函数形参是右操作数b原型为及
Tclass& b
这个时候第一操作数被隐藏即 *this。
3、分清返回值
为了实现如：a=b=c的级联编程，因为=连接性右到左
则为
a=(b=c)即 a.operator=(b.operator=(c))
那么b=c需要返回一个Tclass&类型，当然最好就是 b直接返回
也就是*this内存空间。
那么分析到这里我们可以写出函数原型和返回如下：


Tclass& operator=( Tclass& b)
{
...........
return *this;
}
具体实现具体分析。


下面是一个关于char*类型类的运算符重载，包括了
1、=操作符重载(深拷贝)
2、+操作符重载
3、前置++ 后置++重载
4、!= ==重载
5、<< 重载
因为涉及到char*类型的类容易引起内存泄露下面是测试程序内存泄露检查
==5613== HEAP SUMMARY:
==5613== in use at exit: 0 bytes in 0 blocks
==5613== total heap usage: 9 allocs, 9 frees, 102 bytes allocated
==5613==
==5613== All heap blocks were freed -- no leaks are possible
==5613==
==5613== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==5613== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)


具体代码如下：

点击(此处)折叠或打开

1. /*************************************************************************
   

2. > File Name: class.cpp
   

3. > Author: gaopeng QQ:22389860 all right reserved
   

4. > Mail: gaopp_200217@163.com
   

5. > Created Time: Sat 25 Mar 2017 04:40:31 PM CST
   

6. ************************************************************************/
   

7. 
   

8. #include
   

9. #include
   

10. #include
    

11. 
    

12. using namespace std;
    

13. 
    

14. 
    

15. class testop
    

16. {
    

17. private:
    

18. char* mystr;
    

19. int len;
    

20. public:
    

21. testop(const char* instr)
    

22. {
    

23. this->len = strlen(instr)+1;
    

24. this->mystr = new char[this->len];
    

25. memset(this->mystr,0,this->len);
    

26. strcpy(this->mystr,instr);
    

27. }
    

28. testop()
    

29. {
    

30. this->len = 0;
    

31. this->mystr = NULL;
    

32. }
    

33. testop(const testop& b)//copy 构造函数深拷贝
    

34. {
    

35. this->len = b.len;
    

36. this->mystr = new char[b.len];
    

37. memset(this->mystr,0,this->len);
    

38. strcpy(this->mystr,b.mystr);
    

39. }
    

40. void printmystr()
    

41. {
    

42. cout<mystr<

43. }
    

44. 
    

45. ~testop()
    

46. {
    

47. delete [] this->mystr;
    

48. }
    

49. //操作符重载 + 使用成员函数
    

50. testop operator+(const testop& b)
    

51. {
    

52. testop temp;
    

53. temp.len = this->len + b.len;
    

54. temp.mystr = new char[temp.len];
    

55. memset(temp.mystr,0,temp.len);
    

56. strcat(strcat(temp.mystr,this->mystr),b.mystr);
    

57. return temp;
    

58. }
    

59. //操作符重载 = 使用成员函数 深拷贝
    

60. testop& operator=(const testop& b)
    

61. {
    

62. if(this->mystr != NULL)//必须先释放内存
    

63. {
    

64. delete [] this->mystr;
    

65. }
    

66. this->len = b.len;
    

67. this->mystr = new char[this->len];
    

68. memset(this->mystr,0,this->len);
    

69. strcpy(this->mystr,b.mystr);
    

70. return *this;
    

71. }
    

72. //操作符重载前置(++),使用成员函数 支持链试编程
    

73. 
    

74. testop& operator++()
    

75. {
    

76. this->len = this->len+this->len;
    

77. char* temp = new char[this->len];
    

78. memset(temp,0,this->len);
    

79. strcat(strcat(temp,this->mystr),this->mystr);
    

80. delete [] this->mystr;
    

81. this->mystr = new char[this->len];
    

82. strcpy(this->mystr,temp);
    

83. delete [] temp;
    

84. return *this;
    

85. }
    

86. 
    

87. //操作符重载后置(++),使用成员函数 不支持链试编程 因为返回的为一个匿名对象
    

88. 
    

89. testop operator++(int)
    

90. {
    

91. testop tempop = *this;
    

92. this->len = this->len+this->len;
    

93. char* temp = new char[this->len];
    

94. memset(temp,0,this->len);
    

95. strcat(strcat(temp,this->mystr),this->mystr);
    

96. delete [] this->mystr;
    

97. this->mystr = new char[this->len];
    

98. strcpy(this->mystr,temp);
    

99. delete [] temp;
    

100. return tempop;
     

101. }
     

102. 
     

103. 
     

104. //操作符重载 << 必须使用友元函数 支持链试编程
     

105. friend ostream& operator<<(ostream& out,testop& b);
     

106. //操作符重载 == 使用成员函数
     

107. bool operator==(testop& b)
     

108. {
     

109. if(this->len == b.len && !strcmp(this->mystr,b.mystr))
     

110. {
     

111. return true;
     

112. }
     

113. else
     

114. {
     

115. return false;
     

116. }
     

117. }
     

118. //操作符重载 != 使用成员函数
     

119. bool operator!=(testop& b)
     

120. {
     

121. if((*this) == b )
     

122. {
     

123. return false;
     

124. }
     

125. else
     

126. {
     

127. return true;
     

128. }
     

129. }
     

130. 
     

131. };
     

132. 
     

133. ostream& operator<<(ostream& out,testop& b) // 友元函数
     

134. {
     

135. out<

136. return out;
     

137. }
     

138. 
     

139. 
     

140. 
     

141. 
     

142. int main()
     

143. {
     

144. testop c("ab");
     

145. cout<

146. c++;
     

147. ++c;
     

148. cout<<"c:"<

149. testop a=c;
     

150. cout<<"a:"<

151. if(a == c)
     

152. {
     

153. cout<<"相等"<

154. }
     

155. a = c+a;
     

156. cout<<"a=c+a:"<

157. if(a !=c )
     

158. {
     

159. cout<<"不相等"<

160. }
     

161. 
     

162. }

结果如下：
gaopeng@bogon:~/cplusnew/操作符重载$ ./a.out
ab
c:abababab
a:abababab
相等
a=c+a:abababababababab
不相等

感谢你能够认真阅读完这篇文章，希望小编分享的"C++如何实现操作符重载"这篇文章对大家有帮助，同时也希望大家多多支持，关注行业资讯频道，更多相关知识等着你来学习!