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類型的參數。

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); } 
};

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 
}

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）對已經存在的運算符進行重載時，不能改變優先級規則，否則將引起混亂。

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不應該出現在函數的聲明中）。

原文：https://blog.csdn.net/han_xiaoyang/article/details/10827689

C++函數的高級特徵