| 導購 | 订阅 | 在线投稿
分享
 
 
 

高質量C++/C編程指南(八)

2008-06-01 01:57:52  編輯來源:互聯網  简体版  手機版  評論  字體: ||
 
  第8章 C++函數的高級特性
  對比于C語言的函數,C++增加了重載(overloaded)、內聯(inline)、const和virtual四種新機制。其中重載和內聯機制既可用于全局函數也可用于類的成員函數,const與virtual機制僅用于類的成員函數。
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  重載和內聯肯定有其好處才會被C++語言采納,但是不可以當成免費的午餐而濫用。本章將探究重載和內聯的優點與局限性,說明什麽情況下應該采用、不該采用以及要警惕錯用。
  8.1 函數重載的概念
  8.1.1 重載的起源
  自然語言中,一個詞可以有許多不同的含義,即該詞被重載了。人們可以通過上下文來判定該詞到底是哪種含義。「詞的重載」可以使語言更加簡練。例如「吃飯」的含義十分廣泛,人們沒有必要每次非得說清楚具體吃什麽不可。別迂腐得象孔已己,說茴香豆的茴字有四種寫法。
  在C++程序中,可以將語義、功能相似的幾個函數用同一個名字表示,即函數重載。這樣便于記憶,提高了函數的易用性,這是C++語言采用重載機制的一個理由。例如示例8-1-1中的函數EatBeef,EatFish,EatChicken可以用同一個函數名Eat表示,用不同類型的參數加以區別。
  void EatBeef(…); // 可以改爲 void Eat(Beef …);
  void EatFish(…); // 可以改爲 void Eat(Fish …);
  void EatChicken(…); // 可以改爲 void Eat(Chicken …);
  示例8-1-1 重載函數Eat
  C++語言采用重載機制的另一個理由是:類的構造函數需要重載機制。因爲C++規定構造函數與類同名(請參見第9章),構造函數只能有一個名字。假如想用幾種不同的方法創建對象該怎麽辦?別無選擇,只能用重載機制來實現。所以類可以有多個同名的構造函數。
  8.1.2 重載是如何實現的?
  幾個同名的重載函數仍然是不同的函數,它們是如何區分的呢?我們自然想到函數接口的兩個要素:參數與返回值。
  假如同名函數的參數不同(包括類型、順序不同),那麽輕易區別出它們是不同的函數。
  假如同名函數僅僅是返回值類型不同,有時可以區分,有時卻不能。例如:
  void Function(void);
  int Function (void);
  上述兩個函數,第一個沒有返回值,第二個的返回值是int類型。假如這樣調用函數:
  int x = Function ();
  則可以判定出Function是第二個函數。問題是在C++/C程序中,我們可以忽略函數的返回值。在這種情況下,編譯器和程序員都不知道哪個Function函數被調用。
  所以只能靠參數而不能靠返回值類型的不同來區分重載函數。編譯器根據參數爲每個重載函數産生不同的內部標識符。例如編譯器爲示例8-1-1中的三個Eat函數産生象_eat_beef、_eat_fish、_eat_chicken之類的內部標識符(不同的編譯器可能産生不同風格的內部標識符)。
  假如C++程序要調用已經被編譯後的C函數,該怎麽辦?
  假設某個C函數的聲明如下:
  void foo(int x, int y);
  該函數被C編譯器編譯後在庫中的名字爲_foo,而C++編譯器則會産生像_foo_int_int之類的名字用來支持函數重載和類型安全連接。由于編譯後的名字不同,C++程序不能直接調用C函數。C++提供了一個C連接交換指定符號extern「C」來解決這個問題。例如:
  extern 「C」
  {
  void foo(int x, int y);
  … // 其它函數
  }
  或者寫成
  extern 「C」
  {
  #include 「myheader.h」
  … // 其它C頭文件
  }
  這就告訴C++編譯譯器,函數foo是個C連接,應該到庫中找名字_foo而不是找_foo_int_int。C++編譯器開發商已經對C標准庫的頭文件作了extern「C」處理,所以我們可以用#include 直接引用這些頭文件。
  注重並不是兩個函數的名字相同就能構成重載。全局函數和類的成員函數同名不算重載,因爲函數的作用域不同。例如:
  void PRint(…); // 全局函數
  class A
  {…
  void Print(…); // 成員函數
  }
  不論兩個Print函數的參數是否不同,假如類的某個成員函數要調用全局函數Print,爲了與成員函數Print區別,全局函數被調用時應加『::』標志。如
  ::Print(…); // 表示Print是全局函數而非成員函數
  8.1.3 當心隱式類型轉換導致重載函數産生二義性
  示例8-1-3中,第一個output函數的參數是int類型,第二個output函數的參數是float類型。由于數字本身沒有類型,將數字當作參數時將自動進行類型轉換(稱爲隱式類型轉換)。語句output(0.5)將産生編譯錯誤,因爲編譯器不知道該將0.5轉換成int還是float類型的參數。隱式類型轉換在很多地方可以簡化程序的書寫,但是也可能留下隱患。
  # include
  void output( int x); // 函數聲明
  void output( float x); // 函數聲明
  void output( int x)
  {
  cout
  }
  void output( float x)
  {
  cout
  }
  void main(void)
  {
  int x = 1;
  float y = 1.0;
  output(x); // output int 1
  output(y); // output float 1
  output(1); // output int 1
  // output(0.5); // error! ambiguous call, 因爲自動類型轉換
  output(int(0.5)); // output int 0
  output(float(0.5)); // output float 0.5
  }
  示例8-1-3 隱式類型轉換導致重載函數産生二義性
高質量C++/C編程指南(八)
更多內容請看C/C++技術專題 java編程開發手冊專題,或
  8.2 成員函數的重載、覆蓋與隱藏
  成員函數的重載、覆蓋(override)與隱藏很輕易混淆,C++程序員必須要搞清楚概念,否則錯誤將防不勝防。
  8.2.1 重載與覆蓋
  成員函數被重載的特征:
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  (1)相同的範圍(在同一個類中);
  (2)函數名字相同;
  (3)參數不同;
  (4)virtual要害字可有可無。
  覆蓋是指派生類函數覆蓋基類函數,特征是:
  (1)不同的範圍(分別位于派生類與基類);
  (2)函數名字相同;
  (3)參數相同;
  (4)基類函數必須有virtual要害字。
  示例8-2-1中,函數Base::f(int)與Base::f(float)相互重載,而Base::g(void)被Derived::g(void)覆蓋。
  #include
  class Base
  {
  public:
  void f(int x){ cout
  void f(float x){ cout
  virtual void g(void){ cout
  };
  class Derived : public Base
  {
  public:
  virtual void g(void){ cout
  };
  void main(void)
  {
  Derived d;
  Base *pb = &d;
  pb-f(42); // Base::f(int) 42
  pb-f(3.14f); // Base::f(float) 3.14
  pb-g(); // Derived::g(void)
  }
  示例8-2-1成員函數的重載和覆蓋
  8.2.2 令人迷惑的隱藏規則
  本來僅僅區別重載與覆蓋並不算困難,但是C++的隱藏規則使問題複雜性陡然增加。這裏「隱藏」是指派生類的函數屏蔽了與其同名的基類函數,規則如下:
  (1)假如派生類的函數與基類的函數同名,但是參數不同。此時,不論有無virtual要害字,基類的函數將被隱藏(注重別與重載混淆)。
  (2)假如派生類的函數與基類的函數同名,並且參數也相同,但是基類函數沒有virtual要害字。此時,基類的函數被隱藏(注重別與覆蓋混淆)。
  示例程序8-2-2(a)中:
  (1)函數Derived::f(float)覆蓋了Base::f(float)。
  (2)函數Derived::g(int)隱藏了Base::g(float),而不是重載。
  (3)函數Derived::h(float)隱藏了Base::h(float),而不是覆蓋。
  #include
  class Base
  {
  public:
  virtual void f(float x){ cout
  void g(float x){ cout
  void h(float x){ cout
  };
  class Derived : public Base
  {
  public:
  virtual void f(float x){ cout
  void g(int x){ cout
  void h(float x){ cout
  };
  示例8-2-2(a)成員函數的重載、覆蓋和隱藏
  據作者考察,很多C++程序員沒有意識到有「隱藏」這回事。由于熟悉不夠深刻,「隱藏」的發生可謂神出鬼沒,經常産生令人迷惑的結果。
  示例8-2-2(b)中,bp和dp指向同一地址,按理說運行結果應該是相同的,可事實並非這樣。
  void main(void)
  {
  Derived d;
  Base *pb = &d;
  Derived *pd = &d;
  // Good : behavior depends solely on type of the object
  pb-f(3.14f); // Derived::f(float) 3.14
  pd-f(3.14f); // Derived::f(float) 3.14
  // Bad : behavior depends on type of the pointer
  pb-g(3.14f); // Base::g(float) 3.14
  pd-g(3.14f); // Derived::g(int) 3 (surprise!)
  // Bad : behavior depends on type of the pointer
  pb-h(3.14f); // Base::h(float) 3.14 (surprise!)
  pd-h(3.14f); // Derived::h(float) 3.14
  }
  示例8-2-2(b) 重載、覆蓋和隱藏的比較
高質量C++/C編程指南(八)
更多內容請看C/C++技術專題 Java編程開發手冊專題,或
  8.2.3 擺脫隱藏
  隱藏規則引起了不少麻煩。示例8-2-3程序中,語句pd-f(10)的本意是想調用函數Base::f(int),但是Base::f(int)不幸被Derived::f(char *)隱藏了。由于數字10不能被隱式地轉化爲字符串,所以在編譯時出錯。
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  class Base
  {
  public:
  void f(int x);
  };
  class Derived : public Base
  {
  public:
  void f(char *str);
  };
  void Test(void)
  {
  Derived *pd = new Derived;
  pd-f(10); // error
  }
  示例8-2-3 由于隱藏而導致錯誤
  從示例8-2-3看來,隱藏規則似乎很愚蠢。但是隱藏規則至少有兩個存在的理由:
  u 寫語句pd-f(10)的人可能真的想調用Derived::f(char *)函數,只是他誤將參數寫錯了。有了隱藏規則,編譯器就可以明確指出錯誤,這未必不是好事。否則,編譯器會靜靜靜地將錯就錯,程序員將很難發現這個錯誤,流下禍根。
  u 假如類Derived有多個基類(多重繼續),有時搞不清楚哪些基類定義了函數f。假如沒有隱藏規則,那麽pd-f(10)可能會調用一個出乎意料的基類函數f。盡管隱藏規則看起來不怎麽有道理,但它的確能消滅這些意外。
  示例8-2-3中,假如語句pd-f(10)一定要調用函數Base::f(int),那麽將類Derived修改爲如下即可。
  class Derived : public Base
  {
  public:
  void f(char *str);
  void f(int x) { Base::f(x); }
  };
  8.3 參數的缺省值
  有一些參數的值在每次函數調用時都相同,書寫這樣的語句會使人厭煩。C++語言采用參數的缺省值使書寫變得簡潔(在編譯時,缺省值由編譯器自動插入)。
  參數缺省值的使用規則:
  l 【規則8-3-1】參數缺省值只能出現在函數的聲明中,而不能出現在定義體中。
  例如:
  void Foo(int x=0, int y=0); // 正確,缺省值出現在函數的聲明中
  void Foo(int x=0, int y=0) // 錯誤,缺省值出現在函數的定義體中
  {
  …
  }
  爲什麽會這樣?我想是有兩個原因:一是函數的實現(定義)本來就與參數是否有缺省值無關,所以沒有必要讓缺省值出現在函數的定義體中。二是參數的缺省值可能會改動,顯然修改函數的聲明比修改函數的定義要方便。
  l 【規則8-3-2】假如函數有多個參數,參數只能從後向前挨個兒缺省,否則將導致函數調用語句怪模怪樣。
  正確的示例如下:
  void Foo(int x, int y=0, int z=0);
  錯誤的示例如下:
  void Foo(int x=0, int y, int z=0);
  要注重,使用參數的缺省值並沒有賦予函數新的功能,僅僅是使書寫變得簡潔一些。它可能會提高函數的易用性,但是也可能會降低函數的可理解性。所以我們只能適當地使用參數的缺省值,要防止使用不當産生負面效果。示例8-3-2中,不合理地使用參數的缺省值將導致重載函數output産生二義性。
  #include
  void output( int x);
  void output( int x, float y=0.0);
  void output( int x)
  {
  cout
  }
  void output( int x, float y)
  {
  cout
  }
  void main(void)
  {
  int x=1;
  float y=0.5;
  // output(x); // error! ambiguous call
  output(x,y); // output int 1 and float 0.5
  }
  示例8-3-2 參數的缺省值將導致重載函數産生二義性
  8.4 運算符重載
  8.4.1 概念
  在C++語言中,可以用要害字Operator加上運算符來表示函數,叫做運算符重載。
  
   例如兩個複數相加函數:
  Complex Add(const Complex &a, const Complex &b);
  可以用運算符重載來表示:
  Complex operator +(const Complex &a, const Complex &b);
  運算符與普通函數在調用時的不同之處是:對于普通函數,參數出現在圓括號內;而對于運算符,參數出現在其左、右側。例如
  Complex a, b, c;
  …
  c = Add(a, b); // 用普通函數
  c = a + b; // 用運算符 +
  假如運算符被重載爲全局函數,那麽只有一個參數的運算符叫做一元運算符,有兩個參數的運算符叫做二元運算符。
  假如運算符被重載爲類的成員函數,那麽一元運算符沒有參數,二元運算符只有一個右側參數,因爲對象自己成了左側參數。
  從語法上講,運算符既可以定義爲全局函數,也可以定義爲成員函數。文獻[Murray , p44-p47]對此問題作了較多的闡述,並總結了表8-4-1的規則。
  運算符
  規則
  所有的一元運算符
  建議重載爲成員函數
  = () [] -
  只能重載爲成員函數
  += -= /= *= &= = ~= %= =
  建議重載爲成員函數
  所有其它運算符
  建議重載爲全局函數
  表8-4-1 運算符的重載規則
高質量C++/C編程指南(八)
更多內容請看C/C++技術專題 Java編程開發手冊專題,或
 
  第8章 C++函數的高級特性   對比于C語言的函數,C++增加了重載(overloaded)、內聯(inline)、const和virtual四種新機制。其中重載和內聯機制既可用于全局函數也可用于類的成員函數,const與virtual機制僅用于類的成員函數。   重載和內聯肯定有其好處才會被C++語言采納,但是不可以當成免費的午餐而濫用。本章將探究重載和內聯的優點與局限性,說明什麽情況下應該采用、不該采用以及要警惕錯用。   8.1 函數重載的概念   8.1.1 重載的起源   自然語言中,一個詞可以有許多不同的含義,即該詞被重載了。人們可以通過上下文來判定該詞到底是哪種含義。「詞的重載」可以使語言更加簡練。例如「吃飯」的含義十分廣泛,人們沒有必要每次非得說清楚具體吃什麽不可。別迂腐得象孔已己,說茴香豆的茴字有四種寫法。   在C++程序中,可以將語義、功能相似的幾個函數用同一個名字表示,即函數重載。這樣便于記憶,提高了函數的易用性,這是C++語言采用重載機制的一個理由。例如示例8-1-1中的函數EatBeef,EatFish,EatChicken可以用同一個函數名Eat表示,用不同類型的參數加以區別。   void EatBeef(…); // 可以改爲 void Eat(Beef …);   void EatFish(…); // 可以改爲 void Eat(Fish …);   void EatChicken(…); // 可以改爲 void Eat(Chicken …);   示例8-1-1 重載函數Eat   C++語言采用重載機制的另一個理由是:類的構造函數需要重載機制。因爲C++規定構造函數與類同名(請參見第9章),構造函數只能有一個名字。假如想用幾種不同的方法創建對象該怎麽辦?別無選擇,只能用重載機制來實現。所以類可以有多個同名的構造函數。   8.1.2 重載是如何實現的?   幾個同名的重載函數仍然是不同的函數,它們是如何區分的呢?我們自然想到函數接口的兩個要素:參數與返回值。   假如同名函數的參數不同(包括類型、順序不同),那麽輕易區別出它們是不同的函數。   假如同名函數僅僅是返回值類型不同,有時可以區分,有時卻不能。例如:   void Function(void);   int Function (void);   上述兩個函數,第一個沒有返回值,第二個的返回值是int類型。假如這樣調用函數:   int x = Function ();   則可以判定出Function是第二個函數。問題是在C++/C程序中,我們可以忽略函數的返回值。在這種情況下,編譯器和程序員都不知道哪個Function函數被調用。   所以只能靠參數而不能靠返回值類型的不同來區分重載函數。編譯器根據參數爲每個重載函數産生不同的內部標識符。例如編譯器爲示例8-1-1中的三個Eat函數産生象_eat_beef、_eat_fish、_eat_chicken之類的內部標識符(不同的編譯器可能産生不同風格的內部標識符)。   假如C++程序要調用已經被編譯後的C函數,該怎麽辦?   假設某個C函數的聲明如下:   void foo(int x, int y);   該函數被C編譯器編譯後在庫中的名字爲_foo,而C++編譯器則會産生像_foo_int_int之類的名字用來支持函數重載和類型安全連接。由于編譯後的名字不同,C++程序不能直接調用C函數。C++提供了一個C連接交換指定符號extern「C」來解決這個問題。例如:   extern 「C」   {   void foo(int x, int y);   … // 其它函數   }   或者寫成   extern 「C」   {   #include 「myheader.h」   … // 其它C頭文件   }   這就告訴C++編譯譯器,函數foo是個C連接,應該到庫中找名字_foo而不是找_foo_int_int。C++編譯器開發商已經對C標准庫的頭文件作了extern「C」處理,所以我們可以用#include 直接引用這些頭文件。   注重並不是兩個函數的名字相同就能構成重載。全局函數和類的成員函數同名不算重載,因爲函數的作用域不同。例如:   void PRint(…); // 全局函數   class A   {…   void Print(…); // 成員函數   }   不論兩個Print函數的參數是否不同,假如類的某個成員函數要調用全局函數Print,爲了與成員函數Print區別,全局函數被調用時應加『::』標志。如   ::Print(…); // 表示Print是全局函數而非成員函數      8.1.3 當心隱式類型轉換導致重載函數産生二義性   示例8-1-3中,第一個output函數的參數是int類型,第二個output函數的參數是float類型。由于數字本身沒有類型,將數字當作參數時將自動進行類型轉換(稱爲隱式類型轉換)。語句output(0.5)將産生編譯錯誤,因爲編譯器不知道該將0.5轉換成int還是float類型的參數。隱式類型轉換在很多地方可以簡化程序的書寫,但是也可能留下隱患。   # include   void output( int x); // 函數聲明   void output( float x); // 函數聲明   void output( int x)   {   cout   }   void output( float x)   {   cout   }   void main(void)   {   int x = 1;   float y = 1.0;   output(x); // output int 1   output(y); // output float 1   output(1); // output int 1   // output(0.5); // error! ambiguous call, 因爲自動類型轉換   output(int(0.5)); // output int 0   output(float(0.5)); // output float 0.5   }   示例8-1-3 隱式類型轉換導致重載函數産生二義性 [url=/bbs/detail_1785092.html][img]http://image.wangchao.net.cn/it/1323424734597.gif[/img][/url] 更多內容請看C/C++技術專題 java編程開發手冊專題,或   8.2 成員函數的重載、覆蓋與隱藏   成員函數的重載、覆蓋(override)與隱藏很輕易混淆,C++程序員必須要搞清楚概念,否則錯誤將防不勝防。   8.2.1 重載與覆蓋   成員函數被重載的特征:   (1)相同的範圍(在同一個類中);   (2)函數名字相同;   (3)參數不同;   (4)virtual要害字可有可無。   覆蓋是指派生類函數覆蓋基類函數,特征是:   (1)不同的範圍(分別位于派生類與基類);   (2)函數名字相同;   (3)參數相同;   (4)基類函數必須有virtual要害字。   示例8-2-1中,函數Base::f(int)與Base::f(float)相互重載,而Base::g(void)被Derived::g(void)覆蓋。   #include   class Base   {   public:   void f(int x){ cout   void f(float x){ cout   virtual void g(void){ cout   };   class Derived : public Base   {   public:   virtual void g(void){ cout   };   void main(void)   {   Derived d;   Base *pb = &d;   pb-f(42); // Base::f(int) 42   pb-f(3.14f); // Base::f(float) 3.14   pb-g(); // Derived::g(void)   }   示例8-2-1成員函數的重載和覆蓋      8.2.2 令人迷惑的隱藏規則   本來僅僅區別重載與覆蓋並不算困難,但是C++的隱藏規則使問題複雜性陡然增加。這裏「隱藏」是指派生類的函數屏蔽了與其同名的基類函數,規則如下:   (1)假如派生類的函數與基類的函數同名,但是參數不同。此時,不論有無virtual要害字,基類的函數將被隱藏(注重別與重載混淆)。   (2)假如派生類的函數與基類的函數同名,並且參數也相同,但是基類函數沒有virtual要害字。此時,基類的函數被隱藏(注重別與覆蓋混淆)。   示例程序8-2-2(a)中:   (1)函數Derived::f(float)覆蓋了Base::f(float)。   (2)函數Derived::g(int)隱藏了Base::g(float),而不是重載。   (3)函數Derived::h(float)隱藏了Base::h(float),而不是覆蓋。   #include   class Base   {   public:   virtual void f(float x){ cout   void g(float x){ cout   void h(float x){ cout   };   class Derived : public Base   {   public:   virtual void f(float x){ cout   void g(int x){ cout   void h(float x){ cout   };   示例8-2-2(a)成員函數的重載、覆蓋和隱藏   據作者考察,很多C++程序員沒有意識到有「隱藏」這回事。由于熟悉不夠深刻,「隱藏」的發生可謂神出鬼沒,經常産生令人迷惑的結果。   示例8-2-2(b)中,bp和dp指向同一地址,按理說運行結果應該是相同的,可事實並非這樣。   void main(void)   {   Derived d;   Base *pb = &d;   Derived *pd = &d;   // Good : behavior depends solely on type of the object   pb-f(3.14f); // Derived::f(float) 3.14   pd-f(3.14f); // Derived::f(float) 3.14   // Bad : behavior depends on type of the pointer   pb-g(3.14f); // Base::g(float) 3.14   pd-g(3.14f); // Derived::g(int) 3 (surprise!)   // Bad : behavior depends on type of the pointer   pb-h(3.14f); // Base::h(float) 3.14 (surprise!)   pd-h(3.14f); // Derived::h(float) 3.14   }   示例8-2-2(b) 重載、覆蓋和隱藏的比較 [url=/bbs/detail_1785092.html][img]http://image.wangchao.net.cn/it/1323424734635.gif[/img][/url] 更多內容請看C/C++技術專題 Java編程開發手冊專題,或   8.2.3 擺脫隱藏   隱藏規則引起了不少麻煩。示例8-2-3程序中,語句pd-f(10)的本意是想調用函數Base::f(int),但是Base::f(int)不幸被Derived::f(char *)隱藏了。由于數字10不能被隱式地轉化爲字符串,所以在編譯時出錯。   class Base   {   public:   void f(int x);   };   class Derived : public Base   {   public:   void f(char *str);   };   void Test(void)   {   Derived *pd = new Derived;   pd-f(10); // error   }   示例8-2-3 由于隱藏而導致錯誤   從示例8-2-3看來,隱藏規則似乎很愚蠢。但是隱藏規則至少有兩個存在的理由:   u 寫語句pd-f(10)的人可能真的想調用Derived::f(char *)函數,只是他誤將參數寫錯了。有了隱藏規則,編譯器就可以明確指出錯誤,這未必不是好事。否則,編譯器會靜靜靜地將錯就錯,程序員將很難發現這個錯誤,流下禍根。   u 假如類Derived有多個基類(多重繼續),有時搞不清楚哪些基類定義了函數f。假如沒有隱藏規則,那麽pd-f(10)可能會調用一個出乎意料的基類函數f。盡管隱藏規則看起來不怎麽有道理,但它的確能消滅這些意外。   示例8-2-3中,假如語句pd-f(10)一定要調用函數Base::f(int),那麽將類Derived修改爲如下即可。   class Derived : public Base   {   public:   void f(char *str);   void f(int x) { Base::f(x); }   };   8.3 參數的缺省值   有一些參數的值在每次函數調用時都相同,書寫這樣的語句會使人厭煩。C++語言采用參數的缺省值使書寫變得簡潔(在編譯時,缺省值由編譯器自動插入)。   參數缺省值的使用規則:   l 【規則8-3-1】參數缺省值只能出現在函數的聲明中,而不能出現在定義體中。   例如:   void Foo(int x=0, int y=0); // 正確,缺省值出現在函數的聲明中   void Foo(int x=0, int y=0) // 錯誤,缺省值出現在函數的定義體中   {   …   }   爲什麽會這樣?我想是有兩個原因:一是函數的實現(定義)本來就與參數是否有缺省值無關,所以沒有必要讓缺省值出現在函數的定義體中。二是參數的缺省值可能會改動,顯然修改函數的聲明比修改函數的定義要方便。   l 【規則8-3-2】假如函數有多個參數,參數只能從後向前挨個兒缺省,否則將導致函數調用語句怪模怪樣。   正確的示例如下:   void Foo(int x, int y=0, int z=0);   錯誤的示例如下:   void Foo(int x=0, int y, int z=0);   要注重,使用參數的缺省值並沒有賦予函數新的功能,僅僅是使書寫變得簡潔一些。它可能會提高函數的易用性,但是也可能會降低函數的可理解性。所以我們只能適當地使用參數的缺省值,要防止使用不當産生負面效果。示例8-3-2中,不合理地使用參數的缺省值將導致重載函數output産生二義性。   #include   void output( int x);   void output( int x, float y=0.0);   void output( int x)   {   cout   }   void output( int x, float y)   {   cout   }   void main(void)   {   int x=1;   float y=0.5;   // output(x); // error! ambiguous call   output(x,y); // output int 1 and float 0.5   }   示例8-3-2 參數的缺省值將導致重載函數産生二義性   8.4 運算符重載   8.4.1 概念   在C++語言中,可以用要害字Operator加上運算符來表示函數,叫做運算符重載。 例如兩個複數相加函數:   Complex Add(const Complex &a, const Complex &b);   可以用運算符重載來表示:   Complex operator +(const Complex &a, const Complex &b);   運算符與普通函數在調用時的不同之處是:對于普通函數,參數出現在圓括號內;而對于運算符,參數出現在其左、右側。例如   Complex a, b, c;   …   c = Add(a, b); // 用普通函數   c = a + b; // 用運算符 +   假如運算符被重載爲全局函數,那麽只有一個參數的運算符叫做一元運算符,有兩個參數的運算符叫做二元運算符。   假如運算符被重載爲類的成員函數,那麽一元運算符沒有參數,二元運算符只有一個右側參數,因爲對象自己成了左側參數。   從語法上講,運算符既可以定義爲全局函數,也可以定義爲成員函數。文獻[Murray , p44-p47]對此問題作了較多的闡述,並總結了表8-4-1的規則。   運算符   規則   所有的一元運算符   建議重載爲成員函數   = () [] -   只能重載爲成員函數   += -= /= *= &= = ~= %= =   建議重載爲成員函數   所有其它運算符   建議重載爲全局函數   表8-4-1 運算符的重載規則 [url=/bbs/detail_1785092.html][img]http://image.wangchao.net.cn/it/1323424734657.gif[/img][/url] 更多內容請看C/C++技術專題 Java編程開發手冊專題,或
󰈣󰈤
 
 
 
>>返回首頁<<
 
 
 
 
 熱帖排行
 
王朝網路微信公眾號
微信掃碼關註本站公眾號 wangchaonetcn
 
  免責聲明:本文僅代表作者個人觀點,與王朝網絡無關。王朝網絡登載此文出於傳遞更多信息之目的,並不意味著贊同其觀點或證實其描述,其原創性以及文中陳述文字和內容未經本站證實,對本文以及其中全部或者部分內容、文字的真實性、完整性、及時性本站不作任何保證或承諾,請讀者僅作參考,並請自行核實相關內容。
 
© 2005- 王朝網路 版權所有