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<iostream>
   

9. #include<stdlib.h>
   

10. #include<string.h>
    

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<<this->mystr<<endl;
    

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<<b.mystr;
     

136.         return out;
     

137. }
     

138. 
     

139. 
     

140. 
     

141. 
     

142. int main()
     

143. {
     

144.         testop c("ab");
     

145.         cout<<c<<endl;
     

146.         c++;
     

147.         ++c;
     

148.         cout<<"c:"<<c<<endl;
     

149.         testop a=c;
     

150.         cout<<"a:"<<a<<endl;
     

151.         if(a == c)
     

152.         {
     

153.                 cout<<"相等"<<endl;
     

154.         }
     

155.         a = c+a;
     

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

157.         if(a !=c )
     

158.         {
     

159.                 cout<<"不相等"<<endl;
     

160.         }
     

161. 
     

162. }

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

感謝你能夠認真閱讀完這篇文章，希望小編分享的“C++如何實現操作符重載”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!