C++內嵌函式與宏定義

用內聯取代宏：

1.內聯可調試；

2.可進行型別安全檢查或自動類型轉換；

3.可訪問成員變數。

另外，定義在類聲明中的成員函數自動轉化為內嵌函式。

文章（一）

內嵌函式與宏定義
　　在C中，常用預先處理語句#define來代替一個函數定義。例如：
　　　　#define MAX(a，b) ((a)>(b)?(a):(b))
　　該語句使得程式中每個出現MAX(a,b)函數調用的地方都被宏定義中後面的運算式((a)>(b)?(a):(b))所替換。

　　宏定義語句的書寫格式有過分的講究， MAX與括弧之間不能有空格，所有的參數都要
　　放在括弧裡。儘管如此，它還是有麻煩：
　　　　int a=1，b=0；
　　　　MAX(a++,b)； //a被增值2次
　　　　MAX(a++,b+10)； //a被增值1次
　　　　MAX(a,"Hello")； //錯誤地比較int和字串，沒有參數類型檢查
　　　　MAX( )函數的求值會由於兩個參數值的大小不同而產生不同的副作用。
　　　　MAX(a++,b)的值為2，同時a的值為3；
　　　　MAX(a++,b+10)的值為10，同時a的值為2。
　　如果是普通函數，則MAX(a,"HellO")會受到函數調用的檢查，但此處不會因為兩個參數類型不同而被編譯拒之門外。幸運的是，通過一個內嵌函式可以得到所有宏的替換效能和 所有可預見的狀態以及常規函數的類型檢查：
　　　　inline int MAX(int a，int b)
　　　　{
　　　　　return a>b?a:b；
　　　　}

1.內嵌函式與宏的區別：

      傳統的宏定義函數可能會引起一些麻煩。

      ex：

           #define F(x) x+x

           void main(){int i=1;F(i++);}

            這裡x將被加兩次。

        內嵌函式被編譯器自動的用函數的形勢添加進代碼，而不會出現這種情況。

        內嵌函式的使用提高了效率（省去了很多函數調用彙編代碼如：call和ret等）。

2.內嵌函式的使用：

         所有在類的聲明中定義的函數將被自動認為是內嵌函式。

        class A()

       {

             void c();// not a inline function;

            void d(){ print("d() is a inline function.");}

        }

        如果想將一個全域函數定義為內嵌函式可用，inline 關鍵字。

        inline a(){print("a() is a inline function.");}

注意：

      在內嵌函式中如果有複雜操作將不被內聯。如：迴圈和遞迴調用。

總結：

      將簡單短小的函數定義為內嵌函式將會提高效率。

文章（二）

8.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不是函數，而是宏。（參見6.5節“使用斷言”）
8.5.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)
{
…
}

8.5.3 慎用內聯
內聯能提高函數的執行效率，為什麼不把所有的函數都定義成內嵌函式？
如果所有的函數都是內嵌函式，還用得著“內聯”這個關鍵字嗎？
內
聯是以代碼膨脹（複製）為代價，僅僅省去了函數調用的開銷，從而提高函數的執行效率。如果執行函數體內代碼的時間，相比於函數調用的開銷較大，那麼效率的
收穫會很少。另一方面，每一處內嵌函式的調用都要複製代碼，將使程式的總代碼量增大，消耗更多的記憶體空間。以下情況不宜使用內聯：
（1）如果函數體內的代碼比較長，使用內聯將導致記憶體消耗代價較高。
（2）如果函數體內出現迴圈，那麼執行函數體內代碼的時間要比函數調用的開銷大。
類的建構函式和解構函式容易讓人誤解成使用內聯更有效。要當心建構函式和解構函式可能會隱藏一些行為，如“偷偷地”執行了基類或成員對象的建構函式和解構函式。所以不要隨便地將建構函式和解構函式的定義體放在類聲明中。
一個好的編譯器將會根據函數的定義體，自動地取消不值得的內聯（這進一步說明了inline不應該出現在函數的聲明中）。
8.6 一些心得體會
C++
語言中的重載、內聯、預設參數、隱式轉換等機制展現了很多優點，但是這些優點的背後都隱藏著一些隱患。正如人們的飲食，少食和暴食都不可取，應當恰到好
處。我們要辨證地看待C++的新機制，應該恰如其分地使用它們。雖然這會使我們編程時多費一些心思，少了一些痛快，但這才是編程的藝術。

第9章 類的建構函式、解構函式與賦值函數
建構函式、解構函式與賦值函數是每個類最基本的函數。它們太普通以致讓人容易麻痹大意，其實這些貌似簡單的函數就象沒有頂蓋的下水道那樣危險。
每個類只有一個解構函式和一個賦值函數，但可以有多個建構函式（包含一個拷貝建構函式，其它的稱為普通建構函式）。對於任意一個類A，如果不想編寫上述函數，C++編譯器將自動為A產生四個預設的函數，如
A(void); // 預設的無參數建構函式
A(const A &a); // 預設的拷貝建構函式
~A(void); // 預設的解構函式
A & operate =(const A &a); // 預設的賦值函數

這不禁讓人疑惑，既然能自動產生函數，為什麼還要程式員編寫？
原因如下：
（1）如果使用“預設的無參數建構函式”和“預設的解構函式”，等於放棄了自主“初始化”和“清除”的機會，C++發明人Stroustrup的好心好意白費了。
（2）“預設的拷貝建構函式”和“預設的賦值函數”均採用“位拷貝”而非“值拷貝”的方式來實現，倘若類中含有指標變數，這兩個函數註定將出錯。

對於那些沒有吃夠苦頭的C++程式員，如果他說編寫建構函式、解構函式與賦值函數很容易，可以不用動腦筋，表明他的認識還比較膚淺，水平有待於提高。
本章以類String的設計與實現為例，深入闡述被很多教科書忽視了的道理。String的結構如下：
class String
{
  public:
String(const char *str = NULL); // 普通建構函式
String(const String &other); // 拷貝建構函式
~ String(void); // 解構函式
String & operate =(const String &other); // 賦值函數
  private:
char   *m_data; // 用於儲存字串
};