C++操作符過載

gaopengtttt發表於2017-03-12
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.  ************************************************************************/

  8. #include<iostream>
  9. #include<stdlib.h>
  10. #include<string.h>

  12. using namespace std;


  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.                 }

  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.                 //操作符過載前置(++),使用成員函式 支援鏈試程式設計

  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.                 }

  87.                 //操作符過載後置(++),使用成員函式 不支援鏈試程式設計 因為返回的為一個匿名物件

  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.                 }


  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.                 }

  131. };

  133. ostream& operator<<(ostream& out,testop& b) // 友元函式
  134. {
  135.         out<<b.mystr;
  136.         return out;
  137. }




  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.         }

  162. }


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

沒有問題

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/7728585/viewspace-2135175/，如需轉載，請註明出處，否則將追究法律責任。

相關文章