作者：寒小陽

時間：2013年9月。
出處：http://blog.csdn.net/han_xiaoyang/article/details/10827689。
宣告：版權所有，轉載請註明出處，謝謝。

C++函式的高階特徵
      過載（overloaded）、內聯（inline）、const 和virtual是C++獨有而C不具有的四種機制。其中過載和內聯機制既可用於全域性函式也可用於類的成員函式，const 與virtual機制僅用於類的成員函式。過載和內聯是一把雙刃劍，用的好可以提高效率，精簡程式；而一味濫用也會影響程式的效果。這裡根據筆試面試中常碰到的問題，探究一下過載和內聯的優點與侷限性，說明應該不應該使用的場景。

1 函式過載
      1.1 過載的定義和意義
      在C++程式中，可以將語義、功能相似的幾個函式用同一個名字表示，即函式過載，如下程式所示。但它們互相之間引數不同，這樣便於記憶，提高了函式的易用性，這是C++語言採用過載機制的一個理由。 C++語言採用過載機制的另一個理由是：類的建構函式需要過載機制。因為C++規定建構函式與類同名，建構函式只能有一個名字，但有時候我們需要幾種方法構造物件。

            void Eat(Beef …);     // 吃牛肉
            void Eat(Fish …);     // 吃魚肉
            void Eat(Chicken …);  // 吃雞肉

      1.2 過載的實現方法
      只能靠引數而不能靠返回值型別的不同來區分過載函式。編譯器根據引數為每個過載函式產生不同的內部識別符號。例如編譯器為上節中的三個Eat函式產生象_eat_beef、eat_fish、_eat_chicken之類的內部識別符號（不同的編譯器可能產生不同風格的內部識別符號）。

      說到這裡，要提到一個常見的筆試面試題了：如果C++程式要呼叫已經被編譯後的C函式，該怎麼辦？

      C++程式不能直接呼叫已編譯後的C函式的，這是因為名稱問題，舉個例，一個函式叫做void foo(int x, int y)，該函式被C編譯器編譯後在庫中的名字為_foo，而C++編譯器則會產生像_foo_int_int之類的名字用來支援函式過載和型別安全連線，名稱就不一樣，因此不能直接呼叫的。那要呼叫的話怎麼辦呢？

      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是全域性函式而非成員函式

      1.3 小心隱式型別轉換導致過載函式產生二義性
      隱式型別轉換在很多地方可以簡化程式的書寫，但是也可能留下隱患。如下例：

# include <iostream.h> 
void output( int x);  // 函式宣告
void output( float x); // 函式宣告
void output( int x) 
{ 
cout << " output int " << x << endl ; 
} 
void output( float x) 
{ 
cout << " output float " << x << endl ; 
} 
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 
} 
      第一個output函式的引數是int型別，第二個output函式的引數是float型別。由於數字本身沒有型別，將數字當作引數時將自動進行型別轉換（稱為隱式型別轉換）。語句output(0.5)將產生編譯錯誤，因為編譯器不知道該將0.5轉換成int還是float型別的引數。

6.2 關於成員函式的過載覆蓋和隱藏
      成員函式的過載、覆蓋（override）與隱藏很容易混淆，也是筆試面試中常愛被提到的問題。

      1）關於過載與覆蓋
      成員函式被過載的特徵：

            （1）相同的範圍（在同一個類中）；

            （2）函式名字相同；

            （3）引數不同；

            （4）virtual關鍵字可有可無。

      覆蓋是指派生類函式覆蓋基類函式，特徵是：

            （1）不同的範圍（分別位於派生類與基類）；

            （2）函式名字相同；

            （3）引數相同；

            （4）基類函式必須有virtual關鍵字。

      如下例中，函式Base::f(int)與Base::f(float)相互過載，而Base::g(void)被Derived::g(void)覆蓋。

#include <iostream.h> 
class Base 
{ 
public: 
void f(int x){ cout << "Base::f(int) " << x << endl; } 
void f(float x){ cout << "Base::f(float) " << x << endl; } 
virtual void g(void){ cout << "Base::g(void)" << endl;} 
}; 
class Derived : public Base 
{ 
public: 
virtual void g(void){ cout << "Derived::g(void)" << endl;} 
}; 
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) 
} 
      2）令人迷惑的隱藏規則
      本來僅僅區別過載與覆蓋並不算困難，但是C++的隱藏規則使問題複雜性陡然增加。

      這裡“隱藏”是指派生類的函式遮蔽了與其同名的基類函式，規則如下：

      （1）如果派生類的函式與基類的函式同名，但是引數不同。此時，不論有無virtual關鍵字，基類的函式將被隱藏（注意別與過載混淆）。

      （2）如果派生類的函式與基類的函式同名，並且引數也相同，但是基類函式沒有virtual關鍵字。此時，基類的函式被隱藏（注意別與覆蓋混淆）。

      如下面要給出的例子中：

      （1）函式Derived::f(float)覆蓋了Base::f(float)。

      （2）函式Derived::g(int)隱藏了Base::g(float)，而不是過載。

      （3）函式Derived::h(float)隱藏了Base::h(float)，而不是覆蓋。

#include <iostream.h> 
class Base 
{ 
public: 
virtual void f(float x){ cout << "Base::f(float) " << x << endl; } 
void g(float x){ cout << "Base::g(float) " << x << endl; } 
void h(float x){ cout << "Base::h(float) " << x << endl; } 
}; 
class Derived : public Base 
{ 
public: 
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; } 
void g(int x){ cout << "Derived::g(int) " << x << endl; } 
void h(float x){ cout << "Derived::h(float) " << x << endl; } 
}; 
      而下例中，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 
} 

      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看來，隱藏規則似乎很愚蠢。但是隱藏規則至少有兩個存在的理由：

      （1）寫語句pd->f(10)的人可能真的想呼叫Derived::f(char *)函式，只是他誤將引數寫錯了。有了隱藏規則，編譯器就可以明確指出錯誤，這未必不是好事。否則，編譯器會靜悄悄地將錯就錯，程式設計師將很難發現這個錯誤，流下禍根。

      （2）假如類Derived有多個基類（多重繼承），有時搞不清楚哪些基類定義了函式f。如果沒有隱藏規則，那麼pd->f(10)可能會呼叫一個出乎意料的基類函式f。儘管隱藏規則看起來不怎麼有道理，但它的確能消滅這些意外。

      上例中，如果語句pd->f(10)一定要呼叫函式Base::f(int)，那麼將類Derived修改為如下即可。

class Derived : public Base 
{ 
public: 
void f(char *str); 
void f(int x) { Base::f(x); } 
};
6.3 關於函式引數的預設值
      有一些引數的值在每次函式呼叫時都相同，書寫這樣的語句會使人厭煩。C++語言採用引數的預設值使書寫變得簡潔（在編譯時，預設值由編譯器自動插入）。

      對於函式的預設值，建議大家遵照以下一些規則：

      1）引數預設值只能出現在函式的宣告中，而不能出現在定義體中。

      例如：

void Foo(int x=0, int y=0);  // 正確，預設值出現在函式的宣告中
void Foo(int x=0, int y=0) // 錯誤，預設值出現在函式的定義體中
{ 
…
} 

      為什麼會這樣？我想是有兩個原因：一是函式的實現（定義）本來就與引數是否有預設值無關，所以沒有必要讓預設值出現在函式的定義體中。二是引數的預設值可能會改動，顯然修改函式的宣告比修改函式的定義要方便。

      2）如果函式有多個引數，引數只能從後向前挨個兒預設，否則將導致函式呼叫語句怪模怪樣。

      正確的示例如下：

void Foo(int x, int y=0, int z=0); 
      錯誤的示例如下：

void Foo(int x=0, int y, int z=0); 

      要注意，使用引數的預設值並沒有賦予函式新的功能，僅僅是使書寫變得簡潔一些。它可能會提高函式的易用性，但是也可能會降低函式的可理解性。所以我們只能適當地使用引數的預設值，要防止使用不當產生負面效果。下例中，不合理地使用引數的預設值將導致過載函式output產生二義性。

#include <iostream.h> 
void output( int x); 
void output( int x, float y=0.0); 
void output( int x) 
{ 
cout << " output int " << x << endl ; 
} 
void output( int x, float y) 
{ 
cout << " output int " << x << " and float " << y << endl ; 
} 
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 
} 
6.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;   // 用運算子+ 
      如果運算子被過載為全域性函式，那麼只有一個引數的運算子叫做一元運算子，有兩個引數的運算子叫做二元運算子。如果運算子被過載為類的成員函式，那麼一元運算子沒有引數，二元運算子只有一個右側引數，因為物件自己成了左側引數。

      從語法上講，運算子既可以定義為全域性函式，也可以定義為成員函式。但是我們有以下建議：

      由於C++語言支援函式過載，才能將運算子當成函式來用，C語言就不行。我們要以平常心來對待運算子過載：

            （1）不要過分擔心自己不會用，它的本質仍然是程式設計師們熟悉的函式。

            （2）不要過分熱心地使用，如果它不能使程式碼變得更加易讀易寫，那就別用，否則會自找麻煩。

      2）不能被過載的運算子
      在C++運算子集合中，有一些運算子是不允許被過載的。這種限制是出於安全方面的考慮，可防止錯誤和混亂。

            （1）不能改變C++內部資料型別（如int,float等）的運算子。

            （2）不能過載‘.’，因為‘.’在類中對任何成員都有意義，已經成為標準用法。

            （3）不能過載目前C++運算子集合中沒有的符號，如#,@,$等。原因有兩點，一是難以理解，二是難以確定優先順序。

            （4）對已經存在的運算子進行過載時，不能改變優先順序規則，否則將引起混亂。

6.5 關於行內函數
      1）用內聯取代巨集程式碼
      C++ 語言支援函式內聯，其目的是為了提高函式的執行效率（速度）。

      在C程式中，可以用巨集程式碼提高執行效率。巨集程式碼本身不是函式，但使用起來象函式。前處理器用複製巨集程式碼的方式代替函式呼叫，省去了引數壓棧、生成組合語言的CALL呼叫、返回引數、執行return等過程，從而提高了速度。使用巨集程式碼最大的缺點是容易出錯，由於巨集是直接替代展開，前處理器在複製巨集程式碼時常常產生意想不到的邊際效應。例如

#define MAX(a, b) (a) > (b) ? (a) : (b) 
      語句

result = MAX(i, j) + 2 ; 
      將被前處理器解釋為

result = (i) > (j) ? (i) : (j) + 2 ; 
      由於運算子‘+’比運算子‘:’的優先順序高，所以上述語句並不等價於期望的

result = ( (i) > (j) ? (i) : (j) ) + 2 ; 
      如果把巨集程式碼改寫為

#define MAX(a, b) ( (a) > (b) ? (a) : (b) ) 
      則可以解決由優先順序引起的錯誤。但是即使使用修改後的巨集程式碼也不是萬無一失的，例如語句

result = MAX(i++, j); 
      將被前處理器解釋為

result = (i++) > (j) ? (i++) : (j); 
      對於C++ 而言，使用巨集程式碼還有另一種缺點：無法操作類的私有資料成員。

      讓我們看看C++ 的“函式內聯”是如何工作的。對於任何行內函數，編譯器在符號表裡放入函式的宣告（包括名字、引數型別、返回值型別）。如果編譯器沒有發現行內函數存在錯誤，那麼該函式的程式碼也被放入符號表裡。在呼叫一個行內函數時，編譯器首先檢查呼叫是否正確（進行型別安全檢查，或者進行自動型別轉換，當然對所有的函式都一樣）。如果正確，行內函數的程式碼就會直接替換函式呼叫，於是省去了函式呼叫的開銷。這個過程與預處理有顯著的不同，因為前處理器不能進行型別安全檢查，或者進行自動型別轉換。假如行內函數是成員函式，物件的地址（this）會被放在合適的地方，這也是前處理器辦不到的。

      C++ 語言的函式內聯機制既具備巨集程式碼的效率，又增加了安全性，而且可以自由操作類的資料成員。所以在C++ 程式中，應該用行內函數取代所有巨集程式碼，“斷言assert”恐怕是唯一的例外。assert 是僅在Debug版本起作用的巨集，它用於檢查“不應該”發生的情況。為了不在程式的Debug版本和Release版本引起差別，assert 不應該產生任何副作用。如果assert是函式，由於函式呼叫會引起記憶體、程式碼的變動，那麼將導致Debug版本與Release版本存在差異。所以assert 不是函式，而是巨集。

      2）行內函數的程式設計風格
      關鍵字inline必須與函式定義體放在一起才能使函式成為內聯，僅將inline放在函式宣告前面不起任何作用。如下風格的函式Foo不能成為行內函數：

inline void Foo(int x, int y);  // inline僅與函式宣告放在一起
void Foo(int x, int y) 
{ 
…
} 
      而如下風格的函式Foo則成為行內函數：

void Foo(int x, int y); 
inline void Foo(int x, int y) // inline與函式定義體放在一起
{ 
…
} 

      所以說，inline是一種“用於實現的關鍵字”，而不是一種“用於宣告的關鍵字”。一般地，使用者可以閱讀函式的宣告，但是看不到函式的定義。儘管在大多數教科書中行內函數的宣告、定義體前面都加了inline關鍵字，但我認為inline不應該出現在函式的宣告中。這個細節雖然不會影響函式的功能，但是體現了高質量C++/C程式設計風格的一個基本原則：宣告與定義不可混為一談，使用者沒有必要、也不應該知道函式是否需要內聯。

      定義在類宣告之中的成員函式將自動地成為行內函數，例如

class A 
{ 
public: 
void Foo(int x, int y) { …} // 自動地成為行內函數
} 

      將成員函式的定義體放在類宣告之中雖然能帶來書寫上的方便，但不是一種良好的程式設計風格，上例應該改成：

// 標頭檔案
class A 
{ 
public: 
void Foo(int x, int y)；
} 
// 定義檔案
inline void A::Foo(int x, int y) 
{ 
…
} 

      3）慎用內聯
      內聯能提高函式的執行效率，為什麼不把所有的函式都定義成行內函數？如果所有的函式都是行內函數，還用得著“內聯”這個關鍵字嗎？內聯是以程式碼膨脹（複製）為代價，僅僅省去了函式呼叫的開銷，從而提高函式的執行效率。如果執行函式體內程式碼的時間，相比於函式呼叫的開銷較大，那麼效率的收穫會很少。另一方面，每一處行內函數的呼叫都要複製程式碼，將使程式的總程式碼量增大，消耗更多的記憶體空間。以下情況不宜使用內聯：

      （1）如果函式體內的程式碼比較長，使用內聯將導致記憶體消耗代價較高。

      （2）如果函式體內出現迴圈，那麼執行函式體內程式碼的時間要比函式呼叫的開銷大。

      類的建構函式和解構函式容易讓人誤解成使用內聯更有效。要當心建構函式和解構函式可能會隱藏一些行為，如“偷偷地”執行了基類或成員物件的建構函式和解構函式。所以不要隨便地將建構函式和解構函式的定義體放在類宣告中。

      一個好的編譯器將會根據函式的定義體，自動地取消不值得的內聯（這進一步說明了inline不應該出現在函式的宣告中）。
--------------------- 
作者：寒小陽 
來源：CSDN 
原文：https://blog.csdn.net/han_xiaoyang/article/details/10827689?utm_source=copy 
版權宣告：本文為博主原創文章，轉載請附上博文連結！