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
不相等

没有问题

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/7728585/viewspace-2135175/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/7728585/viewspace-2135175/