巨集和行內函數的根本區別
阿新 • • 發佈：2019-02-08
行內函數的執行過程與帶引數巨集定義很相似，但引數的處理不同。帶引數的巨集定義並不對引數進行運算，而是直接替換
；行內函數首先是函式，這就意味著函式的很多性質都適用於行內函數，即行內函數先把引數表示式進行運算求值，然
後把表示式的值傳遞給形式引數。
行內函數與帶引數巨集定義的另一個區別是，行內函數的引數型別和返回值型別在宣告中都有明確的指定；而帶引數
巨集定義的引數沒有型別的概念，只有在巨集展開以後，才由編譯器檢查語法，這就存在很多的安全隱患。
使用行內函數時，應注意以下問題：
1）行內函數的定義性宣告應該出現在對該函式的第一次呼叫之前。
2）行內函數首先是函式，函式的很多性質都適用於行內函數，如行內函數可以過載。
3）在行內函數中不允許使用迴圈語句和switch結果，帶有異常介面宣告的函式也不能宣告為行內函數。
1. 巨集做的是簡單的字串替換(注意是字串的替換,不是其他型別引數的替換),而函式的引數的傳遞,引數是有資料類
型的,可以是各種各樣的型別.
2. 巨集的引數替換是不經計算而直接處理的,而函式呼叫是將實參的值傳遞給形參,既然說是值,自然是計算得來的.
3. 巨集在編譯之前進行,即先用巨集體替換巨集名,然後再編譯的,而函式顯然是編譯之後,在執行時,才呼叫的.因此,巨集佔用的
是編譯的時間,而函式佔用的是執行時的時間.
4. 巨集的引數是不佔記憶體空間的,因為只是做字串的替換,而函式呼叫時的引數傳遞則是具體變數之間的資訊傳遞,形參
作為函式的區域性變數,顯然是佔用記憶體的.
5. 函式的呼叫是需要付出一定的時空開銷的,因為系統在呼叫函式時,要保留現場,然後轉入被呼叫函式去執行,呼叫完,
再返回主調函式,此時再恢復現場,這些操作,顯然在巨集中是沒有的.
現在來看行內函數:
所謂"行內函數"就是將很簡單的函式"內嵌"到呼叫他的程式程式碼中,只樣做的目的是為了避免上面說到的第5點,目的旨
在節約下原本函式呼叫時的時空開銷.但必須注意的是:作為行內函數,函式體必須十分簡單,不能含有迴圈、條件、選擇
等複雜的結構，否則就不能做為內聯函數了。事實上，即便你沒有指定函式為行內函數，有的編譯系統也會自動將很簡
單的函式作為行內函數處理；而對於複雜的函式，即便你指定他為行內函數，系統也不會理會的。
介紹行內函數之前，有必要介紹一下預處理巨集。行內函數的功能和預處理巨集的
功能相似。相信大家都用過預處理巨集，我們會經常定義一些巨集，如
#define TABLE_COMP(x) ((x)>0?(x):0)
就定義了一個巨集。
為什麼要使用巨集呢？因為函式的呼叫必須要將程式執行的順序轉移到函式
所存放在記憶體中的某個地址，將函式的程式內容執行完後，再返回到轉去執行
該函式前的地方。這種轉移操作要求在轉去執行前要儲存現場並記憶執行的地
址，轉回後要恢復現場，並按原來儲存地址繼續執行。因此，函式呼叫要有一
定的時間和空間方面的開銷，於是將影響其效率。而巨集只是在預處理的地方把
程式碼展開，不需要額外的空間和時間方面的開銷，所以呼叫一個巨集比呼叫一個
函式更有效率。
但是巨集也有很多的不盡人意的地方。
1、．巨集不能訪問物件的私有成員。
2、．巨集的定義很容易產生二意性。
我們舉個例子：
#define TABLE_MULTI(x) (x*x)
我們用一個數字去呼叫它,TABLE_MULTI(10)，這樣看上去沒有什麼錯誤，
結果返回100,是正確的，但是如果我們用TABLE_MULTI(10+10)去呼叫的話，
我們期望的結果是400，而巨集的呼叫結果是(10+10*10+10),結果是120，這顯
然不是我們要得到的結果。避免這些錯誤的方法，一是給巨集的引數都加上括號。
#define TABLE_MULTI(x) ((x)*(x))
這樣可以確保不會出錯，但是，即使使用了這種定義，這個巨集依然有可能
出錯，例如使用TABLE_MULTI(a++)呼叫它，他們本意是希望得到(a+1)*(a+1)的
結果，而實際上呢？我們可以看看巨集的展開結果: (a++)*(a++)，如果a的值是
4，我們得到的結果是5*6=30。而我們期望的結果是5*5=25,這又出現了問題。
事實上，在一些C的庫函式中也有這些問題。例如: Toupper(*pChar++)就會對
pChar執行兩次++操作，因為Toupper實際上也是一個巨集。
我們可以看到巨集有一些難以避免的問題，怎麼解決呢？
下面就是用我要介紹的行內函數來解決這些問題，我們可以使用行內函數
來取代巨集的定義。而且事實上我們可以用行內函數完全取代預處理巨集。
行內函數和巨集的區別在於，巨集是由前處理器對巨集進行替代，而行內函數是
通過編譯器控制來實現的。而且行內函數是真正的函式，只是在需要用到的時
候，行內函數像巨集一樣的展開，所以取消了函式的引數壓棧，減少了呼叫的開
銷。你可以象呼叫函式一樣來呼叫行內函數，而不必擔心會產生於處理巨集的一
些問題。
我們可以用Inline來定義行內函數，不過，任何在類的說明部分定義的函
數都會被自動的認為是行內函數。
下面我們來介紹一下行內函數的用法。
行內函數必須是和函式體申明在一起，才有效。像這樣的申明
Inline Tablefunction(int I)是沒有效果的，編譯器只是把函式作為普通的函
數申明，我們必須定義函式體。
Inline tablefunction(int I) {return I*I};
這樣我們才算定義了一個行內函數。我們可以把它作為一般的函式一樣調
用。但是執行速度確比一般函式的執行速度要快。
我們也可以將定義在類的外部的函式定義為行內函數，比如：
複製程式碼程式碼如下:
Class TableClass{
Private:
Int I,j;
Public:
Int add() { return I+j;};
Inline int dec() { return I-j;}
Int GetNum();
}
inline int tableclass::GetNum(){
return I;
}
上面申明的三個函式都是行內函數。在C++中，在類的內部定義了函式體的
函式，被預設為是行內函數。而不管你是否有inline關鍵字。
行內函數在C++類中，應用最廣的，應該是用來定義存取函式。我們定義的
類中一般會把資料成員定義成私有的或者保護的，這樣，外界就不能直接讀寫我
們類成員的資料了。
對於私有或者保護成員的讀寫就必須使用成員介面函式來進行。如果我們把
這些讀寫成員函式定義成行內函數的話，將會獲得比較好的效率。
複製程式碼程式碼如下:
Class sample{
Private:
Int nTest;
Public:
Int readtest(){ return nTest;}
Void settest(int I) {nTest=I;}
}
當然，行內函數也有一定的侷限性。就是函式中的執行程式碼不能太多了，如
果，行內函數的函式體過大，一般的編譯器會放棄內聯方式，而採用普通的方式
呼叫函式。這樣，行內函數就和普通函式執行效率一樣了。
巨集的使用
/*這一系列文章《C++ Tips》是公司Code Committee專家會推薦工程師看的，感覺很好，拿出來與大家共同提高。並不
是知道多少會使人與人產生差別，真正的差別在於你能做到多少。
很多程式設計師不知道C中的“巨集”到底是什麼意思？特別是當巨集有引數的時候，經常把巨集和函式混淆。我想在這裡我還是
先講講“巨集”，巨集只是一種定義，他定義了一個語句塊，當程式編譯時，編譯器首先要執行一個“替換”源程式的動作
，把巨集引用的地方替換成巨集定義的語句塊，就像文字檔案替換一樣。這個動作術語叫“巨集的展開”。使用巨集是比較“危
險”的，因為你不知道巨集展開後會是什麼一個樣子。例如下面這個巨集：
#define MAX(a, b) a>b?a:b
當我們這樣使用巨集時，沒有什麼問題： MAX( num1, num2 ); 因為巨集展開後變成 num1>num2?num1:num2；。 但是，如
果是這樣呼叫的，MAX( 17+32, 25+21); 呢，編譯時出現錯誤，原因是，巨集展開後變成：17+32>25+21?17+32:25+21，
Woh，這是什麼啊？
所以，巨集在使用時，引數一定要加上括號，上述的那個例子改成如下所示就能解決問題了。
#define MAX( (a), (b) ) (a)>(b)?(a)b)
即使是這樣，也不這個巨集也還是有Bug，因為如果我這樣呼叫 MAX(i++,j++); ， 經過這個巨集以後，i和j都被累加了兩
次，這絕不是我們想要的。所以，在巨集的使用上還是要謹慎考慮，因為巨集展開是的結果是很難讓人預料的。而且雖然，
巨集的執行很快（因為沒有函式呼叫的開銷），但巨集會讓原始碼澎漲，使目標檔案尺寸變大，（如：一個50行的巨集，程式
中有1000個地方用到，巨集展開後會很不得了），相反不能讓程式執行得更快（因為執行檔案變大，執行時系統換頁頻繁
）。
因此，在決定是用函式，還是用巨集時得要小心。
C++中的行內函數定義很簡單，只要在普通的函式前加一個關鍵字inline就可以了，除此之外和普通函式表面上沒有什
麼區別（包括函式的呼叫方式），因為這樣，所以在很多的C++初學者（甚至一些有C++程式設計經驗的人） 看來，內聯只
是一個概念而已，其實這是對行內函數沒有徹底的認識，下面我們就來談談行內函數和普通 函式以及和巨集的區別，相
信讀完下面的部分，你對這三者一定有了很好的理解。
行內函數和普通函式最大的區別在於內部的實現方面，而不是表面形式，我們知道普通函式在被呼叫時，系統
首先要 跳躍到該函式的入口地址，執行函式體，執行完成後，再返回到函式呼叫的地方，函式始終只有一個拷貝； 而
行內函數則不需要進行一個定址的過程，當執行到行內函數時，此函式展開（很類似巨集的使用），如果在 N處呼叫了此
行內函數，則此函式就會有N個程式碼段的拷貝。
從行內函數的呼叫來看，它因為少了一個定址過程而提高了程式碼的執行效率，但是這是以空間的代價來換取的
。
宣告為內聯的函式，其程式碼段不能太長，過長，一些編譯器則視為普通 函式（究竟函式體多長就超過了限制，
這個好象沒有規定，這個也確實不好規定，個人覺得應該視函式體的邏輯而定）。
下面是行內函數的宣告舉例：
inline void SetVal(int a){ m_b = a};
inline int GetVal(){ return m_b};
從上面的例子可以看出，行內函數的宣告和實現通常都會在一個檔案當中（一般放在.h中就可以了）。
下面我們再來說說行內函數與巨集的區別。很多的資料上，在談到行內函數時就說，行內函數和巨集很類似，但是類
似歸類似，畢竟我們不能把這兩者互換使用。
這兩者的相似之處在於執行時編譯器對其的處理，會將其程式碼展開，執行完後繼續下面的處理。不同之處在於巨集
是簡單的文字替換，它不能返回值，也沒有一般函式引數的概念；而行內函數則具備了普通函式的特徵，如引數列表，
返回值等。下面我們舉個例子說明：
1.#define COUNT(X)(X * X) // 一個計算乘積的巨集
2.inline int count(int x){return x*x} //一個計算乘積的行內函數
printf(COUNT(3)); // 結果為 COUNT(3) ( 3 * 3) = 9;
printf(count(3)); // 結果為 count(3){return 3*3 }=9;
上面的例子好象不足以說明兩者的區別，我們把上面的例子的呼叫改改，再看看結果
printf(COUNT(2+3)); //結果為COUNT(2+3)(2+3 * 2+3) = 11
printf(count(2+3)); //結果為count(2+3){return 5*5 ;} = 25;
如果巨集要達到乘積為25的結果，應該這樣寫：
#define COUNT(X)((X)*(X))
對應到上面的例子就是 #define COUNT(2+3)((2+3)*(2+3))
；行內函數首先是函式，這就意味著函式的很多性質都適用於行內函數，即行內函數先把引數表示式進行運算求值，然
後把表示式的值傳遞給形式引數。
行內函數與帶引數巨集定義的另一個區別是，行內函數的引數型別和返回值型別在宣告中都有明確的指定；而帶引數
巨集定義的引數沒有型別的概念，只有在巨集展開以後，才由編譯器檢查語法，這就存在很多的安全隱患。
使用行內函數時，應注意以下問題：
1）行內函數的定義性宣告應該出現在對該函式的第一次呼叫之前。
2）行內函數首先是函式，函式的很多性質都適用於行內函數，如行內函數可以過載。
3）在行內函數中不允許使用迴圈語句和switch結果，帶有異常介面宣告的函式也不能宣告為行內函數。
1. 巨集做的是簡單的字串替換(注意是字串的替換,不是其他型別引數的替換),而函式的引數的傳遞,引數是有資料類
型的,可以是各種各樣的型別.
2. 巨集的引數替換是不經計算而直接處理的,而函式呼叫是將實參的值傳遞給形參,既然說是值,自然是計算得來的.
3. 巨集在編譯之前進行,即先用巨集體替換巨集名,然後再編譯的,而函式顯然是編譯之後,在執行時,才呼叫的.因此,巨集佔用的
是編譯的時間,而函式佔用的是執行時的時間.
4. 巨集的引數是不佔記憶體空間的,因為只是做字串的替換,而函式呼叫時的引數傳遞則是具體變數之間的資訊傳遞,形參
作為函式的區域性變數,顯然是佔用記憶體的.
5. 函式的呼叫是需要付出一定的時空開銷的,因為系統在呼叫函式時,要保留現場,然後轉入被呼叫函式去執行,呼叫完,
再返回主調函式,此時再恢復現場,這些操作,顯然在巨集中是沒有的.
現在來看行內函數:
所謂"行內函數"就是將很簡單的函式"內嵌"到呼叫他的程式程式碼中,只樣做的目的是為了避免上面說到的第5點,目的旨
在節約下原本函式呼叫時的時空開銷.但必須注意的是:作為行內函數,函式體必須十分簡單,不能含有迴圈、條件、選擇
等複雜的結構，否則就不能做為內聯函數了。事實上，即便你沒有指定函式為行內函數，有的編譯系統也會自動將很簡
單的函式作為行內函數處理；而對於複雜的函式，即便你指定他為行內函數，系統也不會理會的。
介紹行內函數之前，有必要介紹一下預處理巨集。行內函數的功能和預處理巨集的
功能相似。相信大家都用過預處理巨集，我們會經常定義一些巨集，如
#define TABLE_COMP(x) ((x)>0?(x):0)
就定義了一個巨集。
為什麼要使用巨集呢？因為函式的呼叫必須要將程式執行的順序轉移到函式
所存放在記憶體中的某個地址，將函式的程式內容執行完後，再返回到轉去執行
該函式前的地方。這種轉移操作要求在轉去執行前要儲存現場並記憶執行的地
址，轉回後要恢復現場，並按原來儲存地址繼續執行。因此，函式呼叫要有一
定的時間和空間方面的開銷，於是將影響其效率。而巨集只是在預處理的地方把
程式碼展開，不需要額外的空間和時間方面的開銷，所以呼叫一個巨集比呼叫一個
函式更有效率。
但是巨集也有很多的不盡人意的地方。
1、．巨集不能訪問物件的私有成員。
2、．巨集的定義很容易產生二意性。
我們舉個例子：
#define TABLE_MULTI(x) (x*x)
我們用一個數字去呼叫它,TABLE_MULTI(10)，這樣看上去沒有什麼錯誤，
結果返回100,是正確的，但是如果我們用TABLE_MULTI(10+10)去呼叫的話，
我們期望的結果是400，而巨集的呼叫結果是(10+10*10+10),結果是120，這顯
然不是我們要得到的結果。避免這些錯誤的方法，一是給巨集的引數都加上括號。
#define TABLE_MULTI(x) ((x)*(x))
這樣可以確保不會出錯，但是，即使使用了這種定義，這個巨集依然有可能
出錯，例如使用TABLE_MULTI(a++)呼叫它，他們本意是希望得到(a+1)*(a+1)的
結果，而實際上呢？我們可以看看巨集的展開結果: (a++)*(a++)，如果a的值是
4，我們得到的結果是5*6=30。而我們期望的結果是5*5=25,這又出現了問題。
事實上，在一些C的庫函式中也有這些問題。例如: Toupper(*pChar++)就會對
pChar執行兩次++操作，因為Toupper實際上也是一個巨集。
我們可以看到巨集有一些難以避免的問題，怎麼解決呢？
下面就是用我要介紹的行內函數來解決這些問題，我們可以使用行內函數
來取代巨集的定義。而且事實上我們可以用行內函數完全取代預處理巨集。
行內函數和巨集的區別在於，巨集是由前處理器對巨集進行替代，而行內函數是
通過編譯器控制來實現的。而且行內函數是真正的函式，只是在需要用到的時
候，行內函數像巨集一樣的展開，所以取消了函式的引數壓棧，減少了呼叫的開
銷。你可以象呼叫函式一樣來呼叫行內函數，而不必擔心會產生於處理巨集的一
些問題。
我們可以用Inline來定義行內函數，不過，任何在類的說明部分定義的函
數都會被自動的認為是行內函數。
下面我們來介紹一下行內函數的用法。
行內函數必須是和函式體申明在一起，才有效。像這樣的申明
Inline Tablefunction(int I)是沒有效果的，編譯器只是把函式作為普通的函
數申明，我們必須定義函式體。
Inline tablefunction(int I) {return I*I};
這樣我們才算定義了一個行內函數。我們可以把它作為一般的函式一樣調
用。但是執行速度確比一般函式的執行速度要快。
我們也可以將定義在類的外部的函式定義為行內函數，比如：
複製程式碼程式碼如下:
Class TableClass{
Private:
Int I,j;
Public:
Int add() { return I+j;};
Inline int dec() { return I-j;}
Int GetNum();
}
inline int tableclass::GetNum(){
return I;
}
上面申明的三個函式都是行內函數。在C++中，在類的內部定義了函式體的
函式，被預設為是行內函數。而不管你是否有inline關鍵字。
行內函數在C++類中，應用最廣的，應該是用來定義存取函式。我們定義的
類中一般會把資料成員定義成私有的或者保護的，這樣，外界就不能直接讀寫我
們類成員的資料了。
對於私有或者保護成員的讀寫就必須使用成員介面函式來進行。如果我們把
這些讀寫成員函式定義成行內函數的話，將會獲得比較好的效率。
複製程式碼程式碼如下:
Class sample{
Private:
Int nTest;
Public:
Int readtest(){ return nTest;}
Void settest(int I) {nTest=I;}
}
當然，行內函數也有一定的侷限性。就是函式中的執行程式碼不能太多了，如
果，行內函數的函式體過大，一般的編譯器會放棄內聯方式，而採用普通的方式
呼叫函式。這樣，行內函數就和普通函式執行效率一樣了。
巨集的使用
/*這一系列文章《C++ Tips》是公司Code Committee專家會推薦工程師看的，感覺很好，拿出來與大家共同提高。並不
是知道多少會使人與人產生差別，真正的差別在於你能做到多少。
很多程式設計師不知道C中的“巨集”到底是什麼意思？特別是當巨集有引數的時候，經常把巨集和函式混淆。我想在這裡我還是
先講講“巨集”，巨集只是一種定義，他定義了一個語句塊，當程式編譯時，編譯器首先要執行一個“替換”源程式的動作
，把巨集引用的地方替換成巨集定義的語句塊，就像文字檔案替換一樣。這個動作術語叫“巨集的展開”。使用巨集是比較“危
險”的，因為你不知道巨集展開後會是什麼一個樣子。例如下面這個巨集：
#define MAX(a, b) a>b?a:b
當我們這樣使用巨集時，沒有什麼問題： MAX( num1, num2 ); 因為巨集展開後變成 num1>num2?num1:num2；。 但是，如
果是這樣呼叫的，MAX( 17+32, 25+21); 呢，編譯時出現錯誤，原因是，巨集展開後變成：17+32>25+21?17+32:25+21，
Woh，這是什麼啊？
所以，巨集在使用時，引數一定要加上括號，上述的那個例子改成如下所示就能解決問題了。
#define MAX( (a), (b) ) (a)>(b)?(a)b)
即使是這樣，也不這個巨集也還是有Bug，因為如果我這樣呼叫 MAX(i++,j++); ， 經過這個巨集以後，i和j都被累加了兩
次，這絕不是我們想要的。所以，在巨集的使用上還是要謹慎考慮，因為巨集展開是的結果是很難讓人預料的。而且雖然，
巨集的執行很快（因為沒有函式呼叫的開銷），但巨集會讓原始碼澎漲，使目標檔案尺寸變大，（如：一個50行的巨集，程式
中有1000個地方用到，巨集展開後會很不得了），相反不能讓程式執行得更快（因為執行檔案變大，執行時系統換頁頻繁
）。
因此，在決定是用函式，還是用巨集時得要小心。
C++中的行內函數定義很簡單，只要在普通的函式前加一個關鍵字inline就可以了，除此之外和普通函式表面上沒有什
麼區別（包括函式的呼叫方式），因為這樣，所以在很多的C++初學者（甚至一些有C++程式設計經驗的人） 看來，內聯只
是一個概念而已，其實這是對行內函數沒有徹底的認識，下面我們就來談談行內函數和普通 函式以及和巨集的區別，相
信讀完下面的部分，你對這三者一定有了很好的理解。
行內函數和普通函式最大的區別在於內部的實現方面，而不是表面形式，我們知道普通函式在被呼叫時，系統
首先要 跳躍到該函式的入口地址，執行函式體，執行完成後，再返回到函式呼叫的地方，函式始終只有一個拷貝； 而
行內函數則不需要進行一個定址的過程，當執行到行內函數時，此函式展開（很類似巨集的使用），如果在 N處呼叫了此
行內函數，則此函式就會有N個程式碼段的拷貝。
從行內函數的呼叫來看，它因為少了一個定址過程而提高了程式碼的執行效率，但是這是以空間的代價來換取的
。
宣告為內聯的函式，其程式碼段不能太長，過長，一些編譯器則視為普通 函式（究竟函式體多長就超過了限制，
這個好象沒有規定，這個也確實不好規定，個人覺得應該視函式體的邏輯而定）。
下面是行內函數的宣告舉例：
inline void SetVal(int a){ m_b = a};
inline int GetVal(){ return m_b};
從上面的例子可以看出，行內函數的宣告和實現通常都會在一個檔案當中（一般放在.h中就可以了）。
下面我們再來說說行內函數與巨集的區別。很多的資料上，在談到行內函數時就說，行內函數和巨集很類似，但是類
似歸類似，畢竟我們不能把這兩者互換使用。
這兩者的相似之處在於執行時編譯器對其的處理，會將其程式碼展開，執行完後繼續下面的處理。不同之處在於巨集
是簡單的文字替換，它不能返回值，也沒有一般函式引數的概念；而行內函數則具備了普通函式的特徵，如引數列表，
返回值等。下面我們舉個例子說明：
1.#define COUNT(X)(X * X) // 一個計算乘積的巨集
2.inline int count(int x){return x*x} //一個計算乘積的行內函數
printf(COUNT(3)); // 結果為 COUNT(3) ( 3 * 3) = 9;
printf(count(3)); // 結果為 count(3){return 3*3 }=9;
上面的例子好象不足以說明兩者的區別，我們把上面的例子的呼叫改改，再看看結果
printf(COUNT(2+3)); //結果為COUNT(2+3)(2+3 * 2+3) = 11
printf(count(2+3)); //結果為count(2+3){return 5*5 ;} = 25;
如果巨集要達到乘積為25的結果，應該這樣寫：
#define COUNT(X)((X)*(X))
對應到上面的例子就是 #define COUNT(2+3)((2+3)*(2+3))