2. 程式人生 > >C++重載

C++重載

阿新 • • 發佈：2017-10-06
重載函數 其他 one oid arr cte 版本 基本 print

C++ 允許在同一作用域中的某個函數和運算符指定多個定義，分別稱為函數重載和運算符重載。本篇博客主要介紹C++中函數重載機制和運算符重載機制。

重載聲明是指一個與之前已經在該作用域內聲明過的函數或方法具有相同名稱的聲明，但是它們的參數列表和定義（實現）不相同（即參數個數或參數順序不同）。
當您調用一個重載函數或重載運算符時，編譯器通過把您所使用的參數類型與定義中的參數類型進行比較，決定選用最合適的定義。選擇最合適的重載函數或重載運算符的過程，稱為重載決策。

函數重載

在同一個作用域內，可以聲明幾個功能類似的同名函數，但是這些同名函數的形式參數（指參數的個數、類型或者順序）必須不同，不能僅通過返回類型的不同來重載函數。

示例：同名函數 print() 被用於輸出不同的數據類型：

技術分享 
#include <iostream>
using namespace std;
class printData
{
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }
      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }
      
 
void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};
int main(void)
{
   printData pd;
   pd.print(5);
   pd.print(500.263);
   pd.print("Hello C++");
   return 0;
}
View Code

運行結果為

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

運算符重載

您可以重定義或重載大部分 C++ 內置的運算符。這樣，您就能使用自定義類型的運算符。重載的運算符是帶有特殊名稱的函數，函數名是由關鍵字 operator 和其後要重載的運算符符號（如operator +）構成的。與其他函數一樣，重載運算符有一個返回類型和一個參數列表。

基本格式 ： 返回類型 operator 運算符 （參數列表）

可重載的運算符：
|+| -| * |\/ |% |^|
|–|–|–|–|–|–|
|& || |~ |! |, |=|
|< |>| <=| >=| ++| –|
|<<| >>| ==| !=| &&| || |
|+= |-= |/= |%= |^= |&=|
||=| *=| <<=| >>=| [] |()|
|-> |->* |new |new [] |delete |delete []|
不可重載的運算符：:: .* . ?:

一元運算符重載

一元運算符只對一個數操作。++，--，-（負號），！（邏輯非）。
註意：對於自增，自減運算符的重載，需要區分前綴操作與後綴操作(後綴重載，參數為int，前綴重載無參數)。

技術分享 
#include <iostream>
using namespace std;

class Time
{
   private:
      int hours;             // 0 到 23
      int minutes;           // 0 到 59
   public:
      // 所需的構造函數
      Time(){
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m){
         hours = h;
         minutes = m;
      }
      // 顯示時間的方法
      void displayTime()
      {
         cout << "H: " << hours << " M:" << minutes <<endl;
      }
      // 重載前綴遞增運算符（ ++ ）
      Time operator++ ()
      {
         ++minutes;          // 對象加 1
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      // 重載後綴遞增運算符（ ++ ）
      Time operator++( int )
      {
         // 保存原始值
         Time T(hours, minutes);
         // 對象加 1
         ++minutes;
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         // 返回舊的原始值
         return T;
      }
};
int main()
{
   Time T1(11, 59), T2(10,40);
   ++T1;                    // T1 加 1
   T1.displayTime();        // 顯示 T1
   ++T1;                    // T1 再加 1
   T1.displayTime();        // 顯示 T1

   T2++;                    // T2 加 1
   T2.displayTime();        // 顯示 T2
   T2++;                    // T2 再加 1
   T2.displayTime();        // 顯示 T2
   return 0;
}
/*運行結果為
H: 12 M:0
H: 12 M:1
H: 10 M:41
H: 10 M:42*/
View Code

二元運算符重載

二元運算符需要兩個參數。我們平常使用的加運算符（ + ）、減運算符（ - ）、乘運算符（ * ）和除運算符（ / ）都屬於二元運算符。
示例（重載二元運算符+）

技術分享 
#include <iostream>
using namespace std;
class Box
{
   double length;      // 長度
   double breadth;     // 寬度
   double height;      // 高度
public:
   double getVolume(void)
   {
      return length * breadth * height;
   }
   void setLength( double len )
   {
       length = len;
   }
   void setBreadth( double bre )
   {
       breadth = bre;
   }
   void setHeight( double hei )
   {
       height = hei;
   }
   Box operator+(const Box& b)
   {
      Box box;
      box.length = this->length + b.length;
      box.breadth = this->breadth + b.breadth;
      box.height = this->height + b.height;
      return box;
   }
};
// 程序的主函數
int main( )
{
   Box Box1,Box2,Box3; 
   double volume = 0.0;     // 把體積存儲在該變量中
   Box1.setLength(6.0);  Box1.setBreadth(7.0);  Box1.setHeight(5.0);
   Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);
   // Box1 的體積
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
   // Box2 的體積
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
   // 把兩個對象相加，得到 Box3
   Box3 = Box1 + Box2;
   // Box3 的體積
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
   return 0;
}
/*運行結果為
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400*/
View Code

關系運算符重載

C++ 語言支持各種關系運算符（ < 、 > 、 <= 、 >= 、 == 等等），它們可用於比較 C++ 內置的數據類型。我們可以重載任何一個關系運算符，重載後的關系運算符可用於比較類的對象。
示例：（重載 < 運算符）

技術分享 
#include <iostream>
using namespace std;
class Distance
{
   private:
      int feet;             // 0 到無窮
      int inches;           // 0 到 12
   public:
      // 所需的構造函數
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 重載小於運算符（ < ）
      bool operator <(const Distance& d)
      {
         if(feet < d.feet)
         {
            return true;
         }
         if(feet == d.feet && inches < d.inches)
         {
            return true;
         }
         return false;
      }
};
int main()
{
   Distance D1(11, 10), D2(5, 11);
   if( D1 < D2 )
   {
      cout << "D1 is less than D2 " << endl;
   }
   else
   {
      cout << "D2 is less than D1 " << endl;
   }
   return 0;
}
//運行結果為：    D2 is less than D1
View Code

輸入輸出運算符重載

C++ 能夠使用流提取運算符 >> 和流插入運算符 << 來輸入和輸出內置的數據類型。您可以重載流提取運算符和流插入運算符來操作對象等用戶自定義的數據類型。
註意：我們需要把運算符重載函數聲明為類的友元函數，這樣我們就能不用創建對象而直接調用函數。

示例：（重載提取運算符 >> 和插入運算符 <<）

技術分享 
#include <iostream>
using namespace std;
class Distance
{
   private:
      int feet;             // 0 到無窮
      int inches;           // 0 到 12
   public:
      // 所需的構造函數
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      friend ostream &operator<<( ostream &output,
                                       const Distance &D )
      {
         output << "F : " << D.feet << " I : " << D.inches;
         return output;
      }
      friend istream &operator>>( istream  &input, Distance &D )
      {
         input >> D.feet >> D.inches;
         return input;
      }
};
int main()
{
   Distance D1(11, 10), D2(5, 11), D3;
   cout << "Enter the value of object : " << endl;
   cin >> D3;
   cout << "First Distance : " << D1 << endl;
   cout << "Second Distance :" << D2 << endl;
   cout << "Third Distance :" << D3 << endl;
   return 0;
}
//運行結果
Enter the value of object :
12 10
First Distance : F : 11 I : 10
Second Distance :F : 5 I : 11
Third Distance :F : 12 I : 10*/
View Code

賦值運算符重載

就像其他運算符一樣，您可以重載賦值運算符（ = ），用於創建一個對象，比如拷貝構造函數。
示例：

技術分享 
#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到無窮
      int inches;           // 0 到 12
   public:
      // 所需的構造函數
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      void operator=(const Distance &D )
      { 
         feet = D.feet;
         inches = D.inches;
      }
      // 顯示距離的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }
      
};
int main()
{
   Distance D1(11, 10), D2(5, 11);
   cout << "First Distance : "; 
   D1.displayDistance();
   cout << "Second Distance :"; 
   D2.displayDistance();
   // 使用賦值運算符
   D1 = D2;
   cout << "First Distance :"; 
   D1.displayDistance();
   return 0;
}
/*示例程序執行結果：
First Distance : F: 11 I:10
Second Distance :F: 5 I:11
First Distance :F: 5 I:11*/
View Code

函數調用運算符()重載

函數調用運算符 () 可以被重載用於類的對象。當重載 () 時，您不是創造了一種新的調用函數的方式，相反地，這是創建一個可以傳遞任意數目參數的運算符函數。
示例：

技術分享 
#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到無窮
      int inches;           // 0 到 12
   public:
      // 所需的構造函數
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 重載函數調用運算符
      Distance operator()(int a, int b, int c)
      {
         Distance D;
         // 進行隨機計算
         D.feet = a + c + 10;
         D.inches = b + c + 100 ;
         return D;
      }
      // 顯示距離的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }
      
};
int main()
{
   Distance D1(11, 10), D2;
   cout << "First Distance : "; 
   D1.displayDistance();
   D2 = D1(10, 10, 10); // invoke operator()
   cout << "Second Distance :"; 
   D2.displayDistance();
   return 0;
}
/*示例程序執行結果：
First Distance : F: 11 I:10
Second Distance :F: 30 I:120*/
View Code

下標運算符[]重載

下標操作符 [] 通常用於訪問數組元素。重載該運算符用於增強操作 C++ 數組的功能。
示例：

技術分享 
#include <iostream>
using namespace std;
const int SIZE = 10;
class safearay
{
   private:
      int arr[SIZE];
   public:
      safearay() 
      {
         register int i;
         for(i = 0; i < SIZE; i++)
         {
           arr[i] = i;
         }
      }
      int& operator[](int i)
      {
          if( i > SIZE )
          {
              cout << "索引超過最大值" ; 
              // 返回第一個元素
              return arr[0];
          }
          return arr[i];
      }
};
int main()
{
   safearay A;
   cout << "A[2] 的值為 : " << A[2] <<endl;
   cout << "A[5] 的值為 : " << A[5]<<endl;
   cout << "A[12] 的值為 : " << A[12]<<endl;
   return 0;
}
/*示例程序執行結果：
A[2] 的值為 : 2
A[5] 的值為 : 5
A[12] 的值為 : 索引超過最大值0*/
View Code

類成員訪問運算符->重載

類成員訪問運算符（ -> ）可以被重載，但它較為麻煩。它被定義用於為一個類賦予”指針”行為。運算符 -> 必須是一個成員函數。如果使用了 -> 運算符，返回類型必須是指針或者是類的對象。

運算符 -> 通常與指針引用運算符 * 結合使用，用於實現”智能指針”的功能。這些指針是行為與正常指針相似的對象，唯一不同的是，當您通過指針訪問對象時，它們會執行其他的任務。比如，當指針銷毀時，或者當指針指向另一個對象時，會自動刪除對象。

間接引用運算符 -> 可被定義為一個一元後綴運算符。也就是說，給出一個類：

技術分享 
#include <iostream>
#include <vector>
using namespace std;
// 假設一個實際的類
class Obj {
   static int i, j;
public:
   void f() const { cout << i++ << endl; }
   void g() const { cout << j++ << endl; }
};
// 靜態成員定義
int Obj::i = 10;
int Obj::j = 12;
// 為上面的類實現一個容器
class ObjContainer {
   vector<Obj*> a;
public:
   void add(Obj* obj)
   { 
      a.push_back(obj);  // 調用向量的標準方法
   }
   friend class SmartPointer;
};
// 實現智能指針，用於訪問類 Obj 的成員
class SmartPointer {
   ObjContainer oc;
   int index;
public:
   SmartPointer(ObjContainer& objc)
   { 
       oc = objc;
       index = 0;
   }
   // 返回值表示列表結束
   bool operator++() // 前綴版本
   { 
     if(index >= oc.a.size()) return false;
     if(oc.a[++index] == 0) return false;
     return true;
   }
   bool operator++(int) // 後綴版本
   { 
      return operator++();
   }
   // 重載運算符 ->
   Obj* operator->() const 
   {
     if(!oc.a[index])
     {
        cout << "Zero value";
        return (Obj*)0;
     }
     return oc.a[index];
   }
};
int main() {
   const int sz = 10;
   Obj o[sz];
   ObjContainer oc;
   for(int i = 0; i < sz; i++)
   {
       oc.add(&o[i]);
   }
   SmartPointer sp(oc); // 創建一個叠代器
   do {
      sp->f(); // 智能指針調用
      sp->g();
   } while(sp++);
   return 0;
}
示例程序執行結果：
10
12
11
13
12
14
13
15
14
16
15
17
16
18
17
19
18
20
19
21
View Code

轉改於huqunxing。site

C++重載

相關推薦

C++重載、覆蓋與隱藏關系

註意 tar soft 範圍 span rtu 類函數 href 不存在 在C++中，成員函數的重載、覆蓋與隱藏是很容易混淆的概念，一定要搞清楚他們之間的關系與差別。 1、成員函數重載的特性 （1）相同的範圍（即在同一個類中）。也就是意味著基類與派生類之間的成員函數不存在重

C++重載>>和<<（輸入輸出運算符）

2.4 返回 ring per dddddd adding 輸入輸出 pla using 在C++中，標準庫本身已經對左移運算符<<和右移運算符>>分別進行了重載，使其能夠用於不同數據的輸入輸出，但是輸入輸出的對象只能是 C++ 內置的數據類型（例如

筆記：C++重載++前後區分

span c++ r+ 返回 con 返回值 後置 ++重載 ++ a++ ++a ++有2種方式，那麽在重載++的時候要怎麽區分： 前置： T& operator++(){ do something return *this; } 後置： cons

C++重載、覆蓋、隱藏的區別與舉例

重載、覆蓋、隱藏參考博客：http://blog.csdn.net/hexi_2000/article/details/4392107//重載，覆蓋，隱藏舉例 #include <iostream> using namespace std; class A { public: int

C++重載

重載函數 其他 one oid arr cte 版本 基本 print C++ 允許在同一作用域中的某個函數和運算符指定多個定義，分別稱為函數重載和運算符重載。本篇博客主要介紹C++中函數重載機制和運算符重載機制。 重載聲明是指一個與之前已經在該作用域內聲明過的函數或方法具

C++重載的構造函數不能互相調用

構造函數 this public clu span out sta ++ tor java類裏的重載構造函數可以互相調用，如下代碼： 1 public class TestConstructor { 2 private int value; 3 4

C/C++(C++重載，默認參數，引用)

end 常量 能夠 local clu char 原則 添加 上下文 C++重載詳解 重載就是同名而非同義，具體意義根據上下文的語境而言。 重載規則： 1，函數名相同。 2，參數個數不同，參數的類型不同，參數順序不同，均可構成重載。 3，返回值類型不同則不可以構成重載。

c++ 重載

while pla 例子 its ring ostream lan IE more 函數重載 　　當函數基本上執行相同的任務， 但使用不同形式的數據時， 才應菜哦那個函數重載 #include <iostream> #include <

C++ 重載賦值運算符與11選5平臺修復

操作 成員 我們 進行 例如 {} 返回 參考 平臺 1、C++中重載賦值操作函數應該返回什麽？ 　　11選5平臺修復（企 娥:217 1793 408）類重載賦值操作符一般都是作為成員函數而存在的，那函數應該返回什麽類型呢？參考內置類型的賦值操作，例如 　　int x,y

C#重載和重寫的區別

列表 父類 不同 版權 作者 就是 nal 重新 rri C#重載和重寫的區別 重載就是在同一個類中，方法名相同，參數列表不同。參數列表不同包括：參數的個數不同，參數類型不同等。重載特征： I.方法名必須相同 II.參數列表必須不相同，與參數列表的順序無關 III.返回值類

[C++] 重載new和delete——控制內存分配

標準庫函數 delet locate cep 庫函數 一個 異常 mes wan 1、new和delete表達式的工作機理 1）new表達式實際執行了三步 string *sp=new string("aaaa"); string *arr=new str

C++筆記(3)：運算符重載

存在 新的 邏輯運算符 int() 取地址 參數 spl this 函數的重載 　　　　　　　　　　　　　　　　　　　　運算符重載 1.運算符重載基礎 2.運算符重載的規則 3.重載雙目運算符 4.重載單目運算符 5.重載流插入和提取運算符 6.類型轉換 7.定義自己的st

第十五周oj刷題——Problem M: C++習題 矩陣求和--重載運算符

des fcm 輸出 content 運算符 reserve int 習題 tor Description 有兩個矩陣a和b，均為2行3列。求兩個矩陣之和。重載運算符“+”，使之能用於矩陣相加（如c=a+b）。 重載流插入運算符“<&l

C++ 運算符重載（一）

c++ operator 運算符重載前景 ： 在設計模式裏面存在觀察者模式（主題只有一個 ， 訂閱著（訂閱主題）有很多個 ）。在一些語言中叫事件發送/事件偵聽 比如AS3 。在C#也有類似的概念 ， 不過它重載了+/-用於訂閱和取消訂閱的計算。這裏重載+/-用於訂閱或取消訂閱確實比AS3的 addEventL

c++運算符重載以及一些基本概念

不同類 col end 錯誤 pan [] () 無限 c++對象 c++primer第四版435 1.賦值( = )， 下標( [ ] ) ，調用 ( ( ) ), 成員訪問箭頭 （->）等操作符必須定義為成員，定義為非成員時，編譯器報錯 2. 像賦值一樣。

C++ Primer筆記12_運算符重載_遞增遞減運算符_成員訪問運算符

primer -a rime scott ipp 變量 函數 ott 解決 1.遞增遞減運算符 C++語言並不要求遞增遞減運算符必須是類的成員。可是由於他們改變的正好是所操作對象的狀態。所以建議設定為成員函數。 對於遞增與遞減運算符來說，有前置與

C++之運算符重載

cells pro 運算符重載 似的 width uri erl wrap height C++ Code 1234567891011121314151617181920212223242526272829303132333435363738394041424

深入C++的運算符重載

stream pre 比較 float 聲明變量 友元 輸出 賦值 per 對於簡單的運算符，可以參考之前的博文。之後會有一篇關於從等號運算符重載的角度研究深淺拷貝的博文。 逗號運算符重載 逗號運算符重載需要一個參數，並且返回自身類。逗號運算符在復制操作中比較常見，下

《Inside C#》筆記(十一) 運算符重載

筆記 去重 返回值 ron 需要 使用 als 增加 返回 運算符重載與之前的索引器類似，目的是為了讓語言本身使用起來更方便直接，也是一種語法糖。 一 運算符重載(Operator Overloading) 運算符重載的存在，使得現有的各種運算符可以被重新定義並用來操作用戶

C++運算符重載

ast != 結合性 con 為什麽 operator 不能重載 += 重載方式 為什麽要對運算符進行重載： C++預定義中的運算符的操作對象只局限於基本的內置數據類型，但是對於我們自定義的類型（類）是沒有辦法操作的。但是大多時候我們需要對我們定義的類型進行類似的運算，這個