C++中的內(nèi)聯(lián)函數(shù)inline總結(jié)

http://blog.csdn.net/coder_xia/article/details/6723387


? ? ? 突然看到C++Primer中講到，對于vector的一個循環(huán)，調(diào)用語句：（示例代碼i=v.begin()不是很規(guī)范，雖然不會出錯，客官請將就著看）


for (int i=v.begin() ; i<v.size() ; i++) ?
{ ?
? ? .... ?
} ?
? ? ? ?對于size()的調(diào)用，其實是內(nèi)聯(lián)。想到以前貌似是看《高質(zhì)量C/C++編程》時，提過，在循環(huán)時，可以采用變量保存v.size()的值，以減少每個循環(huán)的調(diào)用開支。于是決定一搜，順便總結(jié)之。


1、inline的引出


考慮下列min()函數(shù)（例子來自C++Primer第三版303頁）


int min( int v1, int v2 ) ?
{ ?
? ? return( v1 < v2 << v1 : v2 ); ?
} ?
? ? ? 為這樣的小操作定義一個函數(shù)的好處是：
? ? ?a.如果一段代碼包含min()的調(diào)用，那閱讀這樣的代碼并解釋其含義比讀一個條件操作符的實例，可讀性會強很多。


? ? ?b.改變一個局部化的實現(xiàn)比更改一個應(yīng)用中的300個出現(xiàn)要容易得多


? ? ?c.語義是統(tǒng)一的，每個測試都能保證相同的方式實現(xiàn)


? ? ?d.函數(shù)可以被重用，不必為其他的應(yīng)用重寫代碼


? ? ?不過，將min()寫成函數(shù)有一個嚴重的缺點：調(diào)用函數(shù)比直接計算條件操作符要慢很多。那怎么能兼顧以上優(yōu)點和效率呢？C++提供的解決方案為inline（內(nèi)聯(lián)）函數(shù)


2、inline的原理：代碼替代


? ? ? ?在程序編譯時，編譯器將程序中出現(xiàn)的內(nèi)聯(lián)函數(shù)的調(diào)用表達式用內(nèi)聯(lián)函數(shù)的函數(shù)體來進行替代。


? ? ? ?例如，如果一個函數(shù)被指定為inline 函數(shù)則它將在程序中每個調(diào)用點上被內(nèi)聯(lián)地展開例如


int minVal2 = min( i, j ); ?
在編譯時被展開為


int minVal2 = i < j << i : j; ?
?則把min()寫成函數(shù)的額外執(zhí)行開銷從而被消除了。
3、inline的使用


? ? ? ?讓一個函數(shù)成為內(nèi)聯(lián)函數(shù)，隱式的為在類里定義函數(shù)，顯式的則是在函數(shù)前加上inline關(guān)鍵字說明。


4、使用inline的一些注意事項


? ? ? a.從inline的原理，我們可以看出，inline的原理，是用空間換取時間的做法，是以代碼膨脹（復(fù)制）為代價，僅僅省去了函數(shù)調(diào)用的開銷，從而提高函數(shù)的執(zhí)行效率。如果執(zhí)行函數(shù)體內(nèi)代碼的時間，相比于函數(shù)調(diào)用的開銷較大，那么效率的收獲會很少。所以，如果函數(shù)體代碼過長或者函數(shù)體重有循環(huán)語句，if語句或switch語句或遞歸時，不宜用內(nèi)聯(lián)


? ? ? b.關(guān)鍵字inline 必須與函數(shù)定義體放在一起才能使函數(shù)成為內(nèi)聯(lián)，僅將inline 放在函數(shù)聲明前面不起任何作用。內(nèi)聯(lián)函數(shù)調(diào)用前必須聲明?！陡哔|(zhì)量C/C++編程》里一個例子。


inline void Foo(int x, int y); // inline 僅與函數(shù)聲明放在一起 ?
void Foo(int x, int y) ?
{ ?
? ? ... ?
} ?
以上代碼不能成為內(nèi)聯(lián)函數(shù)，而以下則可以


void Foo(int x, int y); ?
inline void Foo(int x, int y) // inline 與函數(shù)定義體放在一起 ?
{ ?
? ? ... ?
} ?
? ? ? ?所以說，inline 是一種“用于實現(xiàn)的關(guān)鍵字”，而不是一種“用于聲明的關(guān)鍵字”。對于以上例子，林銳還建議，只在定義前加上inline，而不是在聲明和定義前都加，因為這能體現(xiàn)高質(zhì)量C++/C 程序設(shè)計風格的一個基本原則：聲明與定義不可混為一談。
? ? ? ?c.inline對于編譯器來說只是一個建議，編譯器可以選擇忽略該建議。換句話說，哪怕真的寫成了inline，也沒有任何錯誤的情況下，編譯器會自動進行優(yōu)化。所以當inline中出現(xiàn)了遞歸，循環(huán)，或過多代碼時，編譯器自動無視inline聲明，同樣作為普通函數(shù)調(diào)用。


總結(jié)下：


? ? ? ?樓主覺得可以將內(nèi)聯(lián)理解為C++中對于函數(shù)專有的宏，對于C的函數(shù)宏的一種改進。對于常量宏，C++提供const替代；而對于函數(shù)宏，C++提供的方案則是inline。在C中，大家都知道宏的優(yōu)勢，編譯器通過復(fù)制宏代碼的方式，省去了參數(shù)壓棧，生成匯編的call調(diào)用，返回參數(shù)等操作，雖然存在一些安全隱患，但在效率上，還是很可取的。
? ? ? ?不過函數(shù)宏還是有不少缺陷的，主要有以下：


? ? ? ?a.在復(fù)制代碼時，容易出現(xiàn)一想不到的邊際效應(yīng)，比如經(jīng)典的


#define MAX(a, b) (a) > (b) ? (a) : (b) ?
在執(zhí)行語句：


result = MAX(i, j) + 2 ; ?
時，會被解釋為


result = (i) > (j) ? (i) : (j) + 2 ; ?
? ? ?b.使用宏，無法進行調(diào)試，雖然windows提供了ASSERT宏
? ? ?c.使用宏，無法訪問類的私有成員
? ? ? 所以，C++ 通過內(nèi)聯(lián)機制，既具備宏代碼的效率，又增加了安全性，還可以自由操作類的數(shù)據(jù)成員，算是一個比較完美的解決方案。


? ? ? 關(guān)于宏，大家還可以參考下：http://dev.yesky.com/260/2095260.shtml，更原創(chuàng)，內(nèi)容豐富，可取，http://wenku.baidu.com/view/1247bc22192e45361066f564.html總結(jié)了各家觀點，稍微整理了下，不過還是蠻清楚的。
========

c++內(nèi)聯(lián)函數(shù)(inline)及內(nèi)聯(lián)函數(shù)的使用及注意點

http://blog.csdn.net/wyq_tc25/article/details/51721636 ?


介紹內(nèi)聯(lián)函數(shù)之前，有必要介紹一下預(yù)處理宏。內(nèi)聯(lián)函數(shù)的功能和預(yù)處理宏的功能相似。相信大家都用過預(yù)處理宏，我們會經(jīng)常定義一些宏，如


#define TABLE_COMP(x) ((x)>0?(x):0)


就定義了一個宏。


為什么要使用宏呢？因為函數(shù)的調(diào)用必須要將程序執(zhí)行的順序轉(zhuǎn)移到函數(shù)所存放在內(nèi)存中的某個地址，將函數(shù)的程序內(nèi)容執(zhí)行完后，再返回到轉(zhuǎn)去執(zhí)行該函數(shù)前的地方。這種轉(zhuǎn)移操作要求在轉(zhuǎn)去執(zhí)行前要保存現(xiàn)場并記憶執(zhí)行的地址，轉(zhuǎn)回后要恢復(fù)現(xiàn)場，并按原來保存地址繼續(xù)執(zhí)行。因此，函數(shù)調(diào)用要有一定的時間和空間方面的開銷，于是將影響其效率。而宏只是在預(yù)處理的地方把代碼展開，不需要額外的空間和時間方面的開銷，所以調(diào)用一個宏比調(diào)用一個函數(shù)更有效率。
但是宏也有很多的不盡人意的地方。
1、宏不能訪問對象的私有成員。
2、宏的定義很容易產(chǎn)生二意性。
我們舉個例子：
復(fù)制代碼 代碼如下:


#define TABLE_MULTI(x) (x*x)
我們用一個數(shù)字去調(diào)用它,TABLE_MULTI(10)，這樣看上去沒有什么錯誤，結(jié)果返回100,是正確的，但是如果我們用TABLE_MULTI(10+10)去調(diào)用的話，我們期望的結(jié)果是４００，而宏的調(diào)用結(jié)果是(10+10*10+10),結(jié)果是120，這顯然不是我們要得到的結(jié)果。避免這些錯誤的方法，一是給宏的參數(shù)都加上括號。


#define TABLE_MULTI(x) ((x)*(x))
這樣可以確保不會出錯，但是，即使使用了這種定義，這個宏依然有可能出錯，例如使用TABLE_MULTI(a++)調(diào)用它，他們本意是希望得到(a+1)*(a+1)的結(jié)果，而實際上呢？我們可以看看宏的展開結(jié)果: (a++)*(a++)，如果a的值是４，我們得到的結(jié)果是5*6=30。而我們期望的結(jié)果是5*5=25,這又出現(xiàn)了問題。事實上，在一些C的庫函數(shù)中也有這些問題。例如: Toupper(*pChar++)就會對pChar執(zhí)行兩次++操作，因為Toupper實際上也是一個宏。
我們可以看到宏有一些難以避免的問題，怎么解決呢？
下面就是用我要介紹的內(nèi)聯(lián)函數(shù)來解決這些問題，我們可以使用內(nèi)聯(lián)函數(shù)來取代宏的定義。而且事實上我們可以用內(nèi)聯(lián)函數(shù)完全取代預(yù)處理宏。
內(nèi)聯(lián)函數(shù)和宏的區(qū)別在于，宏是由預(yù)處理器對宏進行替代，而內(nèi)聯(lián)函數(shù)是通過編譯器控制來實現(xiàn)的。而且內(nèi)聯(lián)函數(shù)是真正的函數(shù)，只是在需要用到的時候，內(nèi)聯(lián)函數(shù)像宏一樣的展開，所以取消了函數(shù)的參數(shù)壓棧，減少了調(diào)用的開銷。你可以象調(diào)用函數(shù)一樣來調(diào)用內(nèi)聯(lián)函數(shù)，而不必擔心會產(chǎn)生于處理宏的一些問題。
我們可以用Inline來定義內(nèi)聯(lián)函數(shù)，不過，任何在類的說明部分定義的函數(shù)都會被自動的認為是內(nèi)聯(lián)函數(shù)。
下面我們來介紹一下內(nèi)聯(lián)函數(shù)的用法。
內(nèi)聯(lián)函數(shù)必須是和函數(shù)體申明在一起，才有效。像這樣的申明Inline Tablefunction(int I)是沒有效果的，編譯器只是把函數(shù)作為普通的函數(shù)申明，我們必須定義函數(shù)體。


Inline tablefunction(int I) {return I*I};
這樣我們才算定義了一個內(nèi)聯(lián)函數(shù)。我們可以把它作為一般的函數(shù)一樣調(diào)用。但是執(zhí)行速度確比一般函數(shù)的執(zhí)行速度要快。
我們也可以將定義在類的外部的函數(shù)定義為內(nèi)聯(lián)函數(shù)，比如：


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;
}
上面申明的三個函數(shù)都是內(nèi)聯(lián)函數(shù)。在C++中，在類的內(nèi)部定義了函數(shù)體的函數(shù)，被默認為是內(nèi)聯(lián)函數(shù)。而不管你是否有inline關(guān)鍵字。
內(nèi)聯(lián)函數(shù)在C++類中，應(yīng)用最廣的，應(yīng)該是用來定義存取函數(shù)。我們定義的類中一般會把數(shù)據(jù)成員定義成私有的或者保護的，這樣，外界就不能直接讀寫我們類成員的數(shù)據(jù)了。對于私有或者保護成員的讀寫就必須使用成員接口函數(shù)來進行。如果我們把這些讀寫成員函數(shù)定義成內(nèi)聯(lián)函數(shù)的話，將會獲得比較好的效率。


Class sample{
　Private:
Int nTest;
　Public:
Int readtest(){ return nTest;}
　Void settest(int I) {nTest=I;}
}


當然，內(nèi)聯(lián)函數(shù)也有一定的局限性。就是函數(shù)中的執(zhí)行代碼不能太多了，如果，內(nèi)聯(lián)函數(shù)的函數(shù)體過大，一般的編譯器會放棄內(nèi)聯(lián)方式，而采用普通的方式調(diào)用函數(shù)。這樣，內(nèi)聯(lián)函數(shù)就和普通函數(shù)執(zhí)行效率一樣了。
以下轉(zhuǎn)自：http://www.cnblogs.com/xkfz007/archive/2012/03/27/2420166.html
內(nèi)聯(lián)函數(shù)并不總是內(nèi)聯(lián) Inline function是在C++中引入的一種機制，它可以拓展函數(shù)代碼，避免調(diào)用函數(shù)的額外開銷。在Linux環(huán)境下，gcc編譯選項必須加上優(yōu)化選項才能使inline有效。
inline與static的關(guān)系
在這兒有一個比較詳細的分析：http://www.cnblogs.com/xkfz007/articles/2370640.html
內(nèi)聯(lián)函數(shù)（inline）機制與陷阱
內(nèi)聯(lián)機制被引入C++作為對宏（Macro）機制的改進和補充（不是取代）。內(nèi)聯(lián)函數(shù)的參數(shù)傳遞機制與普通函數(shù)相同。但是編譯器會在每處調(diào)用內(nèi)聯(lián)函數(shù)的地方將內(nèi)聯(lián)函數(shù)的內(nèi)容展開。這樣既避免了函數(shù)調(diào)用的開銷又沒有宏機制的前三個缺陷。
但是程序代碼中的關(guān)鍵字"inline"只是對編譯器的建議：被"inline"修飾的函數(shù)不一定被內(nèi)聯(lián)（但是無"inline"修飾的函數(shù)一定不是）。
許多書上都會提到這是因為編譯器比絕大多數(shù)程序員都更清楚函數(shù)調(diào)用的開銷有多大，所以如果編譯器認為調(diào)用某函數(shù)的開銷相對該函數(shù)本身的開銷而言微不足道或者不足以為之承擔代碼膨脹的后果則沒必要內(nèi)聯(lián)該函數(shù)。這當然有一定道理，但是按照C、C++一脈相承的賦予程序員充分自由與決定權(quán)的風格來看，理由還不夠充分。我猜想最主要的原因是為了避免編譯器陷入無窮遞歸。如果內(nèi)聯(lián)函數(shù)之間存在遞歸調(diào)用則可能導(dǎo)致編譯器展開內(nèi)聯(lián)函數(shù)時陷入無窮遞歸。有時候函數(shù)的遞歸調(diào)用十分隱蔽，程序員并不容易發(fā)現(xiàn)，所以簡單起見，將內(nèi)聯(lián)與否的決定權(quán)交給編譯器。
?
另一種不被內(nèi)聯(lián)的情況是使用函數(shù)指針來調(diào)用內(nèi)聯(lián)函數(shù)。
對于C++中內(nèi)聯(lián)機制的一個常見誤解是：關(guān)鍵字"inline"只是對編譯器的建議，如果編譯器發(fā)現(xiàn)指定的函數(shù)不適合內(nèi)聯(lián)就不會內(nèi)聯(lián)；所以即使內(nèi)聯(lián)使用的不恰當也不會有任何副作用。這句話只對了一半，內(nèi)聯(lián)使用不恰當是會有副作用的：會帶來代碼膨脹，還有可能引入難以發(fā)現(xiàn)的程序臭蟲。
根據(jù)規(guī)范，當編譯器認為希望被內(nèi)聯(lián)的函數(shù)不適合內(nèi)聯(lián)的時候，編譯器可以不內(nèi)聯(lián)該函數(shù)。但是不內(nèi)聯(lián)該函數(shù)不代表該函數(shù)就是一個普通函數(shù)了，從編譯器的實際實現(xiàn)上來講，內(nèi)聯(lián)失敗的函數(shù)與普通函數(shù)是有區(qū)別的：
（1）普通的函數(shù)在編譯時被單獨編譯一個對象，包含在相應(yīng)的目標文件中。目標文件鏈接時，函數(shù)調(diào)用被鏈接到該對象上。
（2）若一個函數(shù)被聲明成內(nèi)聯(lián)函數(shù)，編譯器即使遇到該函數(shù)的聲明也不會為該函數(shù)編譯出一個對象，因為內(nèi)聯(lián)函數(shù)是在用到的地方展開的?？墒侨粼谡{(diào)用該內(nèi)聯(lián)函數(shù)的地方發(fā)現(xiàn)該內(nèi)聯(lián)函數(shù)的不適合展開時怎么辦？一種選擇是在調(diào)用該內(nèi)聯(lián)函數(shù)的目標文件中為該內(nèi)聯(lián)函數(shù)編譯一個對象。這么做的直接后果是：若在多個文件調(diào)用了內(nèi)聯(lián)失敗的函數(shù)，其中每個文件對應(yīng)的目標文件中都會包含一份該內(nèi)聯(lián)函數(shù)的目標代碼。
如果編譯器真的選擇了上面的做法對待內(nèi)聯(lián)失敗的函數(shù)，那么最好的情況是：沒吃到羊肉，反惹了一身騷。即內(nèi)聯(lián)的好處沒享受到，缺點卻承擔了：目標代碼的體積膨脹得與成功內(nèi)聯(lián)的目標代碼一樣，但目標代碼的效率確和沒內(nèi)聯(lián)一樣。
更糟的是由于存在多份函數(shù)目標代碼帶來一些程序臭蟲。最明顯的例子是：內(nèi)聯(lián)失敗的函數(shù)內(nèi)的靜態(tài)變量實際上就不在只有一份，而是有若干份。這顯然是個錯誤，但是如果不了解內(nèi)幕就很難找到原因。
========

C++內(nèi)聯(lián)函數(shù)（inline）的工作原理與例子

http://blog.csdn.net/buptzhengchaojie/article/details/50568789） ?


? ? ? ?內(nèi)聯(lián)函數(shù)(inline function與一般的函數(shù)不同，它不是在調(diào)用時發(fā)生控制轉(zhuǎn)移，而是在編譯階段將函數(shù)體嵌入到每一個調(diào)用該函數(shù)的語句塊中。內(nèi)聯(lián)函數(shù)(inline function)與編譯器的工作息息相關(guān)。編譯器會將程序中出現(xiàn)內(nèi)聯(lián)函數(shù)的調(diào)用表達式用內(nèi)聯(lián)函數(shù)的函數(shù)體來替換。
內(nèi)聯(lián)函數(shù)的優(yōu)點：
? ? ? ?內(nèi)聯(lián)函數(shù)是將程序執(zhí)行轉(zhuǎn)移到被調(diào)用函數(shù)所存放的內(nèi)存地址，將函數(shù)執(zhí)行完后，在返回到執(zhí)行此函數(shù)前的地方。這種轉(zhuǎn)移操作需要保護現(xiàn)場、包括進棧等操作，在被調(diào)用函數(shù)代碼執(zhí)行完后，再恢復(fù)現(xiàn)場。但是保護現(xiàn)場和恢復(fù)現(xiàn)場需要較大的資源開銷。對于一些較小的調(diào)用函數(shù)來說，若是頻繁調(diào)用，函數(shù)調(diào)用過程甚至可能比函數(shù)執(zhí)行過程需要的系統(tǒng)資源更多。所以引入內(nèi)聯(lián)函數(shù)，可以讓程序執(zhí)行效率更高。
內(nèi)聯(lián)函數(shù)的缺點：
? ? ? ?如果調(diào)用內(nèi)聯(lián)函數(shù)的地方過多，也可能造成代碼膨脹。因為編譯器會把內(nèi)聯(lián)函數(shù)的函數(shù)體嵌入到每一個調(diào)用了它的地方，重復(fù)地嵌入。
以下是幾種含有內(nèi)聯(lián)函數(shù)的情況：
一、 在類中使用內(nèi)聯(lián)函數(shù)和不使用內(nèi)聯(lián)函數(shù)
1、
?

/**? *在類里定義的成員函數(shù)會被默認的認為是指定為內(nèi)置函數(shù)? */ ? #include <iostream> ? ? #include <string> ? ?using namespace std; ?class Person ? { ? public: ?void display() ?{ ?cout << "name:" << name << endl; ?} ?string name; ? }; ?int main(int argc, char* argv[]) ? { ?Person person; ?person.name = "Erin"; ?person.display(); ?return 0; ? } ?

2、

/**? *類外定義的函數(shù)用inline指定為內(nèi)置函數(shù)? */ ? #include <iostream> ? ? #include <string> ? ?using namespace std; ?class Person ? { ? public: ?inline void display(); ?string name; ? }; ?inline void Person::display() ? { ?cout << "name:" << name << endl; ? } ?int main(int argc, char* argv[]) ? { ?Person person; ?person.name = "Erin"; ?person.display(); ?return 0; ? } ?

3、
?

/**? *無內(nèi)置函數(shù)? *既沒有在類內(nèi)定義函數(shù)，也沒有用inline在類外定義函數(shù)? */ ?#include <iostream> ? ? #include <string> ? ?using namespace std; ?class Person ? { ? public: ?void display(); ?string name; ? }; void Person::display() ? { ?cout << "name:" << name << endl; ? }int main(int argc, char* argv[]) ? { ?Person person; ?person.name = "Erin"; ?person.display(); ?return 0; ? }

二、普通函數(shù)的調(diào)用內(nèi)聯(lián)函數(shù)
?
#include<iostream> ?
using namespace std; ?
inline int max(int i, int j, int k) { ?
? ? if (i<j) ?
? ? { ?
? ? ? ? i = j; ?
? ? } ?
? ? if (i < k) { ?
? ? ? ? i = k; ?
? ? } ?
? ? return i; ?
} ?
int main() { ?
? ? int i = 1, j = 2, k = 3; ?
? ? int bigest = max(i, j, k); ?
? ? cout << bigest << endl; ?
? ? return 0; ?
}?
========

C++如何處理內(nèi)聯(lián)虛函數(shù)

http://www.cnblogs.com/jingzhishen/p/4199931.html


當一個函數(shù)是內(nèi)聯(lián)和虛函數(shù)時，會發(fā)生代碼替換或使用虛表調(diào)用嗎？ 為了弄清楚內(nèi)聯(lián)和虛函數(shù)，讓我們將它們分開來考慮。通常，一個內(nèi)聯(lián)函數(shù)是被展開的。


? ? ? ? class CFoo {
? ? ? ? private:
? ? ? ? ? ? int val;
? ? ? ? public:
? ? ? ? int GetVal() { return val; }
? ? ? ? int SetVal(int v) { return val=v; }
? ? ? ? }; ? ? ? ?
這里，如果使用下列代碼：


? ? ? ? CFoo x;
? ? ? ? x.SetVal(17);
? ? ? ? int y = x.GetVal(); ?
那么編譯器產(chǎn)生的目標代碼將與下面的代碼段一樣：


? ? ? ? CFoo x;
? ? ? ? x.val = 17;
? ? ? ? int y = x.val; ?
? ? 你當然不能這么做，因為val是個私有變量。內(nèi)聯(lián)函數(shù)的優(yōu)點是不用函數(shù)調(diào)用就能隱藏數(shù)據(jù)，僅此而已。


? ? 虛函數(shù)有多態(tài)性，意味著派生的類能實現(xiàn)相同的函數(shù)，但功能卻不同。假設(shè) GetVal 被聲明為虛函數(shù)，并且你有第二個 以不同方法實現(xiàn)的類 CFoo2：


? ? ? ? class CFoo2 : public CFoo {
? ? ? ? public:?
? ? ? ? // virtual in base class too!
? ? ? ? virtual int CFoo2::GetVal() { return someOtherVal; }?
? ? ? ? };
? ? 如果 pFoo是一個 CFoo 或 CFoo2 指針，那么，無論 pFoo 指向哪個類 CFoo 或 CFoo2，成員函數(shù) pFoo->GetVal 都能調(diào)用成功。


? ? 如果一個函數(shù)既是虛擬函數(shù)，又是內(nèi)聯(lián)函數(shù)，會是什么情況呢？記住，有兩種方式建立內(nèi)聯(lián)函數(shù)，


第一種是在函數(shù)定義中使用關(guān)鍵字 inline，如：


? ? ? ? inline CFoo::GetVal() { return val; } ? ? ? ?
第二種是在類的聲明中編寫函數(shù)體，就象前面的 CFoo2::GetVal 一樣。所以如果將虛函數(shù)體包含在類的聲明中，如：


? ? ? ? class CFoo {
? ? ? ? public:
? ? ? ? virtual int GetVal() { return val; }
? ? ? ? }; ? ? ? ?
? ? 編譯器便認為這個函數(shù) GetVal 是內(nèi)聯(lián)的，同時也是虛擬的。那么，多態(tài)性和內(nèi)聯(lián)特性如何同時工作呢？


? ? 編譯器遵循的第一個規(guī)則是無論發(fā)生什么事情，多態(tài)性必須起作用。如果有一個指向 CFoo 對象的指針，pFoo->GetVal 被保證去調(diào)用正確的函數(shù)。一般情況下，這就是說函數(shù) GetVal 將被實例化為非內(nèi)聯(lián)函數(shù)，并有vtable（虛表）入口指向它們。但這并不意味著這個函數(shù)不能被擴展！再看看下面的代碼：


? ? ? ? CFoo x;?
? ? ? ? x.SetVal(17)
? ? ? ? int y = x.GetVal() ?
? ? 編譯器知道x是 CFoo,而不是CFoo2，因為這個堆對象是被顯式聲明的。x肯定不會是CFoo2。所以展開 SetVal/GetVal 內(nèi)聯(lián)是安全的。如果要寫更多的復(fù)雜代碼：


CFoo x;?
CFoo* pfoo=&x;?
pfoo->SetVal(17);?
int y = pfoo->GetVal();?
...
CFoo2 x2;?
pfoo = &x2;?
pfoo->SetVal(17); //etc.?
編譯器知道 pfoo 第一次指向x，第二次指向x2，所以展開虛擬函數(shù)也是安全的。


? ? 你還可以編寫更復(fù)雜的代碼，其中，pfoo 所指的對象類型總是透明的，但是大多數(shù)編譯器不會做任何更多的分析。即使在前面的例子中，某些編譯器將會安全運行，實例化并通過一個虛表來調(diào)用。實際上， 編譯器總是忽略內(nèi)聯(lián)需要并總是使用虛表。唯一絕對的規(guī)則是代碼必須工作；也就是說，虛函數(shù)必須有多態(tài)行為。
? ? 通常，無論是顯式還是隱式內(nèi)聯(lián)，它只是一個提示而已，并非是必須的，就象寄存器一樣。編譯器完全能拒絕展開一個非虛內(nèi)聯(lián)函數(shù)，C++編譯器常常首先會報 錯：“內(nèi)聯(lián)中斷-函數(shù)太大”。如果內(nèi)聯(lián)函數(shù)調(diào)用自身，或者你在某處傳遞其地址，編譯器必須產(chǎn)生一個正常（外聯(lián)？）函數(shù)。內(nèi)聯(lián)函數(shù)在DEBUG BUILDS中不被展開，可設(shè)置編譯選項來預(yù)防。
? ? 要想知道編譯器正在做什么，唯一的方法是看它產(chǎn)生的代碼。對于微軟的編譯器來說，你可以用-FA編譯選項產(chǎn)生匯編清單。你不必知道匯編程序如何做。我鼓勵 你完成這個實驗；這對于了解機器實際所做的事情機器有益，同時你可學(xué)習(xí)許多匯編列表中的內(nèi)容。
? ? 有關(guān)內(nèi)聯(lián)函數(shù)的東西比你第一次接觸它時要復(fù)雜得多。有許多種情況強迫編譯器產(chǎn)生正常函數(shù)：遞歸，獲取函數(shù)地址，太大的那些函數(shù)和虛函數(shù)。但是如果編譯器決定實例化你的內(nèi)聯(lián)函數(shù)，就要考慮把函數(shù)放在什么地方？它進入哪個模塊？
? ? 通常類在頭文件中聲明，所以如果某個cpp包含foo.h，并且編譯器決定實例化CFoo::GetVal，則在cpp文件中將它實例化成一個靜態(tài)函數(shù)。 如果十個模塊包含foo.h，編譯器產(chǎn)生的虛函數(shù)拷貝就有十個。實際上，可以用虛表指向不同類型的GetVal拷貝，從而是相同類型的對象只產(chǎn)生拷貝。一 些鏈接器能巧妙地在鏈接時排除冗余，但一般你是不能指望他來保證的。
? ? 我們得出的結(jié)論是：最好不要使用內(nèi)聯(lián)虛函數(shù)，因為它們幾乎不會被展開，即便你的函數(shù)只有一行，你最好還是將它與其它的類函數(shù)一起放在模塊（cpp文件） 中。當然，開發(fā)者常常將簡短的虛函數(shù)放在類聲明中-不是因為他們希望這個函數(shù)被展開為內(nèi)聯(lián)，而是因為這樣做更方便和可讀性更強。
=======

C++內(nèi)聯(lián)函數(shù)跟普通函數(shù)的區(qū)別以及實現(xiàn)機制

http://blog.csdn.net/xiaofei2010/article/details/7609355


內(nèi)聯(lián)函數(shù)定義：
將函數(shù)定義為內(nèi)聯(lián)函數(shù)，一般就是將他在程序中每個調(diào)用點上“內(nèi)聯(lián)地”展開。在函數(shù)返回類型前加上inline關(guān)鍵字。
定義在類聲明之中的成員函數(shù)將自動地成為內(nèi)聯(lián)函數(shù)。


內(nèi)聯(lián)函數(shù)適用情況：
1.一個函數(shù)被重復(fù)調(diào)用；
2.函數(shù)只有幾行，且不包含for，while，switch語句。
內(nèi)聯(lián)函數(shù)應(yīng)該放在頭文件中定義，這一點不同于其他函數(shù)。


內(nèi)聯(lián)函數(shù)可能在程序中定義不止一次，只要內(nèi)聯(lián)函數(shù)的定義在某個源文件中只出現(xiàn)一次，而且在所有的源文件中，其定義必須是相同的。如果inline函數(shù)的定義和聲明是分開的，而在另外一個文件中需要調(diào)用這些inline函數(shù)得時候，內(nèi)聯(lián)是無法在這些調(diào)用函數(shù)內(nèi)展開的。這樣內(nèi)聯(lián)函數(shù)在全局范圍內(nèi)就失去了作用。解決的辦法就是把內(nèi)聯(lián)函數(shù)得定義放在頭文件中，當其它文件要調(diào)用這些內(nèi)聯(lián)函數(shù)的時候，只要包含這個頭文件就可以了。把內(nèi)聯(lián)函數(shù)的定義放在頭文件中，可以確保在調(diào)用函數(shù)時所使用的定義是相同的，并保證在調(diào)用點該函數(shù)的定義對調(diào)用點可見。


內(nèi)聯(lián)函數(shù)具有一般函數(shù)的特性，它與一般函數(shù)所不同之處只在于函數(shù)調(diào)用的處理：
一般函數(shù)進行調(diào)用時，要將程序執(zhí)行權(quán)轉(zhuǎn)到被調(diào)用函數(shù)中，然后再返回到調(diào)用它的函數(shù)中；而內(nèi)聯(lián)函數(shù)在調(diào)用時，是將調(diào)用表達式用內(nèi)聯(lián)函數(shù)體來替換。
========

總結(jié)

以上是生活随笔為你收集整理的C++内联函数学习总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。