作者：amure
原文地址：
http://www.azure.com.cn/article.asp?id=190一般而言，比起C程序來說，C++游戲程序是可重用和可維護(hù)的。可這真的有價(jià)值嗎？復(fù)雜的C++可以在速度上與傳統(tǒng)的C程序相提并論嗎？
如果有一個(gè)好的編譯器，再加上對(duì)語(yǔ)言的了解，真的有可能用C++寫出一些有效率的游戲程序來。本文描述了典型的幾種你可以用來加速游戲的技術(shù)。它假設(shè)你已經(jīng)非常肯定使用C++的好處，并且你也對(duì)優(yōu)化的基本概念相當(dāng)熟悉。
第一個(gè)經(jīng)常讓人獲益的基本概念顯然是剖析（profiling）的重要性。缺乏剖析的話，程序員將犯兩種錯(cuò)誤，其一是優(yōu)化了錯(cuò)誤的代碼：如果一個(gè)程序的主要指標(biāo)不是效率，那么一切花在使其更高效上的時(shí)間都是浪費(fèi)。靠直覺來判斷哪段代碼的主要指標(biāo)是效率是不可信的，只有直接去測(cè)量。第二個(gè)概念是程序員經(jīng)常“優(yōu)化”到降低了代碼的速度。這在C++是一個(gè)典型問題，一個(gè)簡(jiǎn)單的指令行可能會(huì)產(chǎn)生巨大數(shù)量的機(jī)器代碼，你應(yīng)當(dāng)經(jīng)常檢查你的編譯器的輸出，并且剖析之。
1、對(duì)象的構(gòu)造與析構(gòu)
對(duì)象的構(gòu)造與析構(gòu)是C++的核心概念之一，也是編譯器背著你產(chǎn)生代碼的一個(gè)主要地方。未經(jīng)認(rèn)真設(shè)計(jì)的程序經(jīng)常花費(fèi)不少時(shí)間在調(diào)用構(gòu)造函數(shù)，拷貝對(duì)象以及初始化臨時(shí)對(duì)象等等。幸運(yùn)的是，一般的感覺和幾條簡(jiǎn)單的規(guī)則可以讓沉重的對(duì)象代碼跑得和C只有毫厘之差。
除非需要否則不構(gòu)造。
最快的代碼是根本不運(yùn)行的代碼。為什么要?jiǎng)?chuàng)建一個(gè)你根本不去使用的對(duì)象呢？在后面的代碼中：
voide Function(int arg)
{
Object boj;
If(arg==0)
Return;
...
}
即便arg為0，我們也付出了調(diào)用Object的構(gòu)造函數(shù)的代價(jià)。特別是如果arg經(jīng)常是0，并且Object本身還分配內(nèi)存，這種浪費(fèi)會(huì)更加嚴(yán)重。顯然的，解決方案就是把obj的定義移到判斷之后。
小心在循環(huán)中定義復(fù)雜變量，如果在循環(huán)中按照除非需要否則不構(gòu)造的原則構(gòu)造了復(fù)雜的對(duì)象，那么你在每一次循環(huán)的時(shí)候都要付出一次構(gòu)造的代價(jià)。最好在循環(huán)外構(gòu)造之以只構(gòu)造一次。如果一個(gè)函數(shù)在內(nèi)循環(huán)中被調(diào)用，而該函數(shù)在棧內(nèi)構(gòu)造了一個(gè)對(duì)象，你可以在外部構(gòu)造并傳遞一個(gè)應(yīng)用給它。
1.1 采用初始化列表
考慮下面的類：
class Vehicle
{
public
Vehicle(const std::string &name)
{
mName=name
}
private:
std::string mName;
}
因?yàn)槌蓡T變量會(huì)在構(gòu)造函數(shù)本體執(zhí)行前構(gòu)造，這段代碼調(diào)用了string mName的構(gòu)造函數(shù)，然后調(diào)用了一個(gè)=操作符，來拷貝其值。這個(gè)例子中的一個(gè)典型的不好之處在于string的缺省構(gòu)造函數(shù)會(huì)分配內(nèi)存，但實(shí)際上都會(huì)分配大大超過實(shí)際需要的空間。接下來的代碼會(huì)好些，并且阻止了對(duì)=操作符的調(diào)用，進(jìn)一步的來說，因?yàn)榻o出了更多的信息，非缺省構(gòu)造函數(shù)會(huì)更有效，并且編譯器可以在構(gòu)造函數(shù)函數(shù)體為空的情況下將其優(yōu)化掉。
class Vehicle
{
public
Vehicle(const std::string &name):mName(name)
{ }
private:
std::string mName;
}
1.2 要前自增不要后自增（即要++I不要I++）
當(dāng)寫x=y++時(shí)產(chǎn)生的問題是自增功能將需要制造一個(gè)保持y的原值的拷貝，然后y自增，并把原始的值返回。后自增包括了一個(gè)臨時(shí)對(duì)象的構(gòu)造，而前自增則不要。對(duì)于整數(shù)，這沒有額外的負(fù)擔(dān)，但對(duì)于用戶自定義類型，這就是浪費(fèi)，你應(yīng)該在有可能的情況下運(yùn)用前自增，在循環(huán)變量中，你會(huì)常遇到這種情形。
不使用有返回值的操作符 在C++中經(jīng)常看到這樣寫頂點(diǎn)的加法：
Vector operator+(const Vector &v1,const Vector &v2)
這個(gè)操作將引起返回一個(gè)新的Vector對(duì)象，它還必須被以值的形式返回。雖然這樣可以寫v=v1+v2這樣的表達(dá)式，但象構(gòu)造臨時(shí)對(duì)象和對(duì)象的拷貝這樣的負(fù)擔(dān)，對(duì)于象頂點(diǎn)加法這樣常被調(diào)用的事情來說太大了一點(diǎn)。有時(shí)候是可以好好規(guī)劃代碼以使編譯器可以把臨時(shí)對(duì)象優(yōu)化掉（這一點(diǎn)就是所謂的返回值優(yōu)化）。但是更普遍的情形下，你最好放下架子，寫一點(diǎn)難看但更快速的代碼：
void Vector::Add(const Vector &v1,const Vector &v2)
注意+=操作符并沒有同樣的問題，它只是修改第一個(gè)參數(shù)，并不需要返回一個(gè)臨時(shí)對(duì)象，所以，可能的情況下，你也可以用+=代替+。
1.3 使用輕量級(jí)的構(gòu)造函數(shù)
在上一個(gè)例子中Vector的構(gòu)造函數(shù)是否需要初始化它的元素為0？這個(gè)問題可能在你的代碼中會(huì)有好幾處出現(xiàn)。如果是的話，它使得無(wú)論是否必要，所有的調(diào)用都要付初始化的代價(jià)。典型的來說，臨時(shí)頂點(diǎn)以及成員變量就會(huì)要無(wú)辜的承受這些額外的開銷。
一個(gè)好的編譯器可以很好的移除一些這種多余的代碼，但是為什么要冒這個(gè)險(xiǎn)呢？作為一般的規(guī)則，你希望構(gòu)造函數(shù)初始化所有的成員變量，因?yàn)槲闯跏蓟臄?shù)據(jù)將產(chǎn)生錯(cuò)誤。但是，在頻繁實(shí)例化的小類中，特別是一些臨時(shí)對(duì)象，你應(yīng)該準(zhǔn)備向效率規(guī)則妥協(xié)。首選的情況就是在許多游戲中有的vector和Matrix類，這些類顯然應(yīng)當(dāng)提供一些方法置0和識(shí)別，但它的缺省構(gòu)造函數(shù)卻應(yīng)當(dāng)是空的。
這個(gè)概念的推論就是你應(yīng)當(dāng)為這種類提供另一個(gè)構(gòu)造函數(shù)。如果我們的第二個(gè)例子中的Vebicle類是這樣寫的話：
class Vehicle
{
public:
vehicle()
{
}
void SetName(const std::string &name)
{
mName=name;
}
private:
std::string mName
};
我們省去了構(gòu)造mName的開銷，而在稍后用SetName方法設(shè)置了其值。相似的，使用拷貝構(gòu)造函數(shù)將比構(gòu)造一個(gè)對(duì)象然后用=操作符要好一些。寧愿這樣來構(gòu)造：Vebicle V1(V2)也不要這樣來構(gòu)造：
Vehicle v1;v1=v2;
如果你需要阻止編譯器幫你拷貝對(duì)象，把拷貝構(gòu)造函數(shù)和操作符=聲明為私有的，但不要實(shí)現(xiàn)其中任何一個(gè)。這樣，任何企圖對(duì)該對(duì)象的拷貝都將產(chǎn)生一個(gè)編譯時(shí)錯(cuò)誤。最好也養(yǎng)成定義單參數(shù)構(gòu)造函數(shù)的習(xí)慣，除非你是要做類型轉(zhuǎn)換。這樣可以防止編譯器在做類型轉(zhuǎn)換時(shí)產(chǎn)生的隱藏的臨時(shí)對(duì)象。
1.4 預(yù)分配和Cache對(duì)象
一個(gè)游戲一般會(huì)有一些類會(huì)頻繁的分配和釋放，比如武器什么的。在C程序中，你會(huì)分配一個(gè)大數(shù)組然后在需要的時(shí)候使用。在C++中，經(jīng)過小小的規(guī)劃以后，你也可以這樣干。這個(gè)方法是不要一直構(gòu)造和析構(gòu)對(duì)象而是請(qǐng)求一個(gè)新而把舊的返回給Cache。Cache可以實(shí)現(xiàn)成一個(gè)模板，它就可以為所有的有一個(gè)缺省構(gòu)造函數(shù)的類工作。Cache模板的Sample可以在附帶的CD中找到。
你也可以在需要時(shí)分配一些對(duì)象來填充Cache，或者預(yù)先分配好。如果你還要對(duì)這些對(duì)象維護(hù)一個(gè)堆棧的話（表示在你刪除對(duì)象X之前，你先要?jiǎng)h除所有在X后面分配的對(duì)象），你可以把Cache分配在一個(gè)連續(xù)的內(nèi)存塊中。
2、內(nèi)存管理
C++應(yīng)用程序一般要比C程序更深入到內(nèi)存管理的細(xì)節(jié)。在C中，所有的分配都簡(jiǎn)單的通過malloc和free來進(jìn)行，而C++則還可以通過構(gòu)造臨時(shí)對(duì)象和成員變量來隱式的分配內(nèi)存。很多C++游戲程序需要自己的內(nèi)存管理程序。 由于C++游戲程序要執(zhí)行很多的分配，所以要特別小心堆的碎片。一個(gè)方法是選擇一條復(fù)雜的路：要么在游戲開始后根本不分配任何內(nèi)存，要么維護(hù)一個(gè)巨大的連續(xù)內(nèi)存塊，并按期釋放（比如在關(guān)卡之間）。在現(xiàn)代機(jī)器上，如果你想對(duì)你的內(nèi)存使用很警惕的話，很嚴(yán)格的規(guī)則是沒必要的。
第一步是重載new和Delete操作符，使用自己實(shí)現(xiàn)的操作符來把游戲最經(jīng)常的內(nèi)存分配從malloc定向到預(yù)先分配好的內(nèi)存塊去，例如，你發(fā)現(xiàn)你任何時(shí)候最多有10000個(gè)4字節(jié)的內(nèi)存分配，你可以先分配好40000字節(jié)，然后在需要時(shí)引用出來。為了跟蹤哪些塊是空的，可以維護(hù)一個(gè)由每一個(gè)空的塊指向下一個(gè)空的塊的列表free list。在分配的時(shí)候，把前面的block移掉，在釋放的時(shí)候，把這個(gè)空塊再放到前面去。圖1描述了這個(gè)free list如何在一個(gè)連續(xù)的內(nèi)存塊中，與一系列的分配和釋放協(xié)作的情形。
圖1 A linked free list
[img]http://
http://www.linuxeden.com/edu/mays.soage.com/develop/optimize/200112/image/Other/OptFORCGame.gif[/img] 你可以很容易的發(fā)現(xiàn)一個(gè)游戲是有著許多小小的生命短暫的內(nèi)存分配，你也許希望為很多小塊保留空間。為那些現(xiàn)在沒有使用到的東西保留大內(nèi)存塊會(huì)浪費(fèi)很多內(nèi)存。在一定的尺寸上，你應(yīng)當(dāng)把內(nèi)存分配交給一支不同的大內(nèi)存分配函數(shù)或是直接交給malloc()。
3、虛函數(shù)
C++游戲程序的批評(píng)者總是把矛頭對(duì)準(zhǔn)虛函數(shù)，認(rèn)為它是一個(gè)降低效率的神秘特性。概念性的說，虛函數(shù)的機(jī)制很簡(jiǎn)單。為了完成一個(gè)對(duì)象的虛函數(shù)調(diào)用，編譯器訪問對(duì)象的虛函數(shù)表，獲得一個(gè)成員函數(shù)的指針，設(shè)置調(diào)用環(huán)境，然后跳轉(zhuǎn)到該成員函數(shù)的地址上。相對(duì)于C程序的函數(shù)調(diào)用，C程序則是設(shè)置調(diào)用環(huán)境，然后跳轉(zhuǎn)到一個(gè)既定的地址上。一個(gè)虛函數(shù)調(diào)用的額外負(fù)擔(dān)是虛函數(shù)表的間接指向；由于事先并不知道將要跳轉(zhuǎn)的地址，所以也有可能造成處理器不能命中Cache。
所有真正的C++程序都對(duì)虛函數(shù)有大量的使用，所以主要的手段是防止在那些極其重視效率的地方的虛函數(shù)調(diào)用。這里有一個(gè)典型的例子：
Class BaseClass
{
public:
virtual char *GetPointer()=0;
};
Class Class1: public BaseClass
{
virtual char *GetPointer();
};
Class Class2:public BaseClass
{
virtual char *GetPointer();
};
void Function(BaseClass *pObj)
{
char *ptr=pObj->GetPointer();
}
如果Function()極其重視效率，我們應(yīng)當(dāng)把GetPointer從一個(gè)虛函數(shù)改成內(nèi)聯(lián)函數(shù)。一種方式是給BaseClass增加一個(gè)新的保護(hù)的數(shù)據(jù)成員，在每一個(gè)類中設(shè)置該成員的值，在GetPointer這個(gè)內(nèi)聯(lián)函數(shù)中返回該成員給調(diào)用者：
Class BaseClass
{
public:
inline char GetPointerFast()
{
return mpPointer;
}
protected:
inline void SetPointer(char *pData)
{
mpData = pData;
}
private:
char *mpData;
};
void Function(BaseClass *pObj)
{
char *ptr= pObj->GetPointerFast();
}
一個(gè)更激進(jìn)的方法是重新規(guī)劃你的類繼承樹，如果Class1和Class2只有一點(diǎn)點(diǎn)不同，那么可以把它們捆綁到同一個(gè)類中去，而用一個(gè)Flag來表明它將象Class1還是象Class2一樣工作，同時(shí)在BaseClass中把純虛函數(shù)去掉。這樣的話，也可以象前面的例子一樣把GetPointer寫成內(nèi)聯(lián)。這種變通看起來不是很高雅，但是在缺少Cache的機(jī)器上跑內(nèi)循環(huán)時(shí)，你可能會(huì)很愿意為了去掉虛函數(shù)調(diào)用而把事情做得更加難看。
雖然每一個(gè)新的虛函數(shù)都只給每個(gè)類的虛表增加了一個(gè)指針的尺寸（通常是可以忽略的代價(jià)），第一個(gè)虛函數(shù)還是在每一個(gè)對(duì)象上要求了一個(gè)指向虛表的指針。這就是說你在很小的、頻繁使用的類上使用任何虛函數(shù)而造成了額外的負(fù)擔(dān)，這些都是不能接受的。由于繼承一般都要用到一個(gè)或幾個(gè)虛函數(shù)（至少有一個(gè)虛的析構(gòu)函數(shù)），所以你沒必要在小而頻繁使用的對(duì)象上使用任何繼承。
4、代碼尺寸
編譯器因?yàn)镃++產(chǎn)生冗長(zhǎng)的代碼而臭名昭著。由于內(nèi)存有限，而小的東西往往是快的，所以使你的可執(zhí)行文件盡可能的小是非常重要的。首先可以做的事情是拿一個(gè)編譯器來研究。如果你的編譯器會(huì)在可執(zhí)行文件中保存Debug信息的話，那么把它們移除掉。（注意MS VC會(huì)把Debug信息放在可執(zhí)行文件外部，所以沒關(guān)系）異常處理會(huì)產(chǎn)生額外的代碼，盡可能的去除異常處理代碼。確保連接器配置為去除無(wú)用的函數(shù)和類。開啟編譯器的最高優(yōu)化級(jí)別，并嘗試設(shè)置為尺寸最小化而不是速度最大化 — 有時(shí)候，由于Cache命中的提高，會(huì)產(chǎn)生更好的運(yùn)行效果。（注意在使用這項(xiàng)設(shè)置時(shí)檢查instrinsic功能是否也處于打開狀態(tài)）去掉所有Debug輸出狀態(tài)下的浪費(fèi)空間的字符串，使編譯器把多個(gè)相同的字符串捆綁成一個(gè)實(shí)例。
內(nèi)聯(lián)通常是造成大函數(shù)的首犯。編譯器可以自由的選擇注意或忽略你寫的inline關(guān)鍵字，而且它們還會(huì)背著你制造一些內(nèi)聯(lián)。這是另一個(gè)要你保持輕量級(jí)的構(gòu)造函數(shù)的原因，這樣堆棧中的對(duì)象就不會(huì)因?yàn)橛写罅康膬?nèi)聯(lián)代碼而膨脹。同時(shí)也要小心重載運(yùn)算符，即使是最簡(jiǎn)短的表達(dá)式如m1=m2*m3如果m2和m3是矩陣的話，也可能產(chǎn)生大量的內(nèi)聯(lián)代碼。一定要深入了解你的編譯器對(duì)于內(nèi)聯(lián)的設(shè)置。
啟用運(yùn)行時(shí)類型信息（RTTI）需要編譯器為每一個(gè)類產(chǎn)生一些靜態(tài)信息。RTTI一般來說是缺省啟用的，這樣我們的代碼可以調(diào)用dynamic_cast以及檢測(cè)一個(gè)對(duì)象的類型，考慮完全禁止使用RTTI和dynamic_cast以節(jié)省空間（進(jìn)一步的說，有時(shí)候dynamic_cast在某些實(shí)現(xiàn)中需要付出很高的代價(jià)）另一方面，當(dāng)你真的需要有基于類型的不同行為的時(shí)候，增加一個(gè)不同行為的虛函數(shù)。這是更好的面向?qū)ο笤O(shè)計(jì)（注意static_cast與這不同，它的效率和C語(yǔ)言的類型轉(zhuǎn)換一樣）。
5、標(biāo)準(zhǔn)類庫(kù)（STL）
標(biāo)準(zhǔn)類庫(kù)是一套實(shí)現(xiàn)了常見的結(jié)構(gòu)和算法的模板，例如dynamic arrays（稱為vector），set，map等等。使用STL可以節(jié)省你很多時(shí)間來寫和調(diào)試那些容器。和之前談到的一樣，如果希望系統(tǒng)的效率最大化，你必須要注意你的STL的具體實(shí)現(xiàn)的細(xì)節(jié)。
為了能夠?qū)?yīng)于最大范圍的應(yīng)用，STL標(biāo)準(zhǔn)在內(nèi)存分配這個(gè)領(lǐng)域保持了沉默。在STL容器中的每一個(gè)操作都有一定的效率保證，例如，給一個(gè)set進(jìn)行插入操作只要O(log n)的時(shí)間，但是，對(duì)一個(gè)容器的內(nèi)存使用沒有任何保證。
讓我們來仔細(xì)了解游戲開發(fā)中的一個(gè)非常普遍的問題：你希望保存一組對(duì)象，（我們會(huì)稱其為對(duì)象列表，雖然不一定要保存在STL的列表中）通常你會(huì)要求每個(gè)對(duì)象在這個(gè)表有且僅有一個(gè)，這樣你就不用擔(dān)心一個(gè)偶然產(chǎn)生的在容器中插入一個(gè)已存在單元的操作了。STL的set忽略副本，所有的插入、刪除和查詢的速度都是O(log n)，這是不是就是很好的選擇呢？
雖然在set上的大多數(shù)操作的速度都是O(log n)，但是這里面依然存在著潛在的危機(jī)。雖然容器的內(nèi)存使用依賴于實(shí)現(xiàn)，但很多實(shí)現(xiàn)還是在紅黑樹的基礎(chǔ)上實(shí)現(xiàn)的。在紅黑樹上，樹的每一個(gè)節(jié)點(diǎn)都是容器的一個(gè)元素。常見的實(shí)現(xiàn)方法是在每一個(gè)元素被加入到樹時(shí)，分配一個(gè)節(jié)點(diǎn)，而當(dāng)每個(gè)元素被移出樹時(shí)，釋放一個(gè)節(jié)點(diǎn)。根據(jù)你插入和刪除的頻繁程度，在內(nèi)存管理器上所花費(fèi)的時(shí)間將或多或少的影響你通過使用set而獲得的好處。
另外一個(gè)解決方案是使用vector來存儲(chǔ)元素，vector保證在容器的末端添加元素有很高的效率。這表示實(shí)際上vector只在很偶然的情況下才重新分配內(nèi)存，也就是說，當(dāng)滿的時(shí)候擴(kuò)容一倍。當(dāng)使用vector來保存一個(gè)不同元素列表的時(shí)候，你首先要檢查元素是否已經(jīng)存在，如果沒有，那么加入。而對(duì)整個(gè)vector檢查一遍需要花費(fèi)O(n)的時(shí)間，但是但實(shí)際牽涉到的部分應(yīng)該比較少，這是因?yàn)関ector的每個(gè)元素都在內(nèi)存中連續(xù)存放，所以檢查整個(gè)vector實(shí)際上是一個(gè)易于cache的操作。檢查整個(gè)set將造成cache不命中，這是因?yàn)樵诩t黑樹上分別存放的元素可能散布在內(nèi)存的各個(gè)角落。同時(shí)，我們也注意到set必須額外維護(hù)一組標(biāo)記以設(shè)置整個(gè)樹。如果你要保存的是對(duì)象的指針，set可能要花費(fèi)vector所要花費(fèi)的內(nèi)存的3到4倍。
Set的刪除操作消耗時(shí)間O(log n)，看起來是很快，如果你不考慮可能對(duì)free()的調(diào)用的話。Vector的刪除操作消耗O(n)，這是因?yàn)閺谋粍h除的那個(gè)元素開始到結(jié)尾處的元素，每一個(gè)元素都要被拷貝到前一個(gè)位置上。如果元素都只是指針的話，那么這個(gè)拷貝將可以依靠一個(gè)簡(jiǎn)單的memcpy()來完成，而這個(gè)函數(shù)是相當(dāng)快的。（這也是為什么通常都把對(duì)象的指針儲(chǔ)存在STL的容器中的一個(gè)原因，而不是儲(chǔ)存對(duì)象本身。如果你直接保存了對(duì)象本身，將會(huì)在很多操作中造成許多額外的構(gòu)造函數(shù)的調(diào)用，例如刪除等）。
set和map通常來說麻煩大于有用，如果你還沒有意識(shí)到這一點(diǎn)的話，考慮遍歷一個(gè)容器的代價(jià)，例如：
for(Collection::iterator it = Collection.begin(); it != Collection.end(); ++it)
如果Collection是vector，那么++it就是一個(gè)指針自增。但是當(dāng)Collection是一個(gè)set或者是一個(gè)map的話，++it包括了訪問紅黑樹上的下一個(gè)節(jié)點(diǎn)。這個(gè)操作相當(dāng)復(fù)雜而且很容易造成cache不命中，因?yàn)闃涞墓?jié)點(diǎn)幾乎遍布內(nèi)存的各處。
當(dāng)然，如果你要在容器中保存大量的元素，并且進(jìn)行許多的成員請(qǐng)求，那么set的O(log n)的效率完全可以抵消那些內(nèi)存方面的消耗。近似的，如果你偶爾才使用容器，那么這里的效率差別就非常的小。你應(yīng)該做一些效率評(píng)估以了解多大的n會(huì)使set變得更快。也許你會(huì)驚奇的發(fā)現(xiàn)在游戲的大多數(shù)典型應(yīng)用下vector的所有效率都比set要高。
這還不是STL內(nèi)存使用的全部。一定要了解當(dāng)你使用clear方法時(shí)，容器是否真的釋放掉了它的內(nèi)存。如果沒有，就可能產(chǎn)生內(nèi)存碎片。比如，如果你開始游戲的時(shí)候建立了一個(gè)空的vector，在游戲過程中增加元素，然后在游戲restart時(shí)調(diào)用clear，這時(shí)vector未必釋放它的全部?jī)?nèi)存。這個(gè)空的vector，可能依然占據(jù)了堆中的內(nèi)存，并使其變成碎片。如果你真的需要這樣來實(shí)現(xiàn)游戲的話，對(duì)這個(gè)問題有兩種解法。一是你可以在創(chuàng)建vector時(shí)調(diào)用reserve()，為你可能需要的最大數(shù)量的元素保留足夠的空間。如果這不可行的話，你可以強(qiáng)迫vector完全釋放內(nèi)存：
Vector V;
// … elements are inserted into V here
Vector().swap(v); // causes v to free its memory
Set、list以及map都沒有這個(gè)問題，這是因?yàn)樗麄優(yōu)槊總€(gè)元素分別分配和釋放內(nèi)存。
6、高級(jí)特性
編程語(yǔ)言的某些特性你可能沒必要用到。看上去簡(jiǎn)單的特性可能會(huì)導(dǎo)致低下的效率。而看起來復(fù)雜的特性沒準(zhǔn)執(zhí)行得很好。C++的這些黑暗角落異常依賴于編譯器。當(dāng)你要使用它們時(shí)，必須了解它們的代價(jià)。
C++的string就是一個(gè)看起來不錯(cuò)的例子，但是在效率極其重要的場(chǎng)合應(yīng)該避免使用，考慮下面的代碼。
Void Function(const std::string &str)
{
}
Function("hello");
對(duì)Function()的調(diào)用包括了對(duì)給定const char*參數(shù)的構(gòu)造函數(shù)的調(diào)用。在普遍的實(shí)現(xiàn)中，這個(gè)構(gòu)造函數(shù)執(zhí)行了一個(gè)malloc()，一個(gè)strlen()，以及一個(gè)memcpy()，而析構(gòu)函數(shù)立刻上來做了一些無(wú)意義的事情。（由于該例子中的string沒有被更多的應(yīng)用）然后又跟了一個(gè)free()。這里的內(nèi)存分配完全是浪費(fèi)，因?yàn)樽址癶ello”早就在程序的數(shù)據(jù)段中了。我們?cè)缇陀兴趦?nèi)存中的副本了。如果Function定義了一個(gè)const char*的參數(shù)，那么完全沒有了上面所說的那些額外的調(diào)用。這就是為了使用方便的string而付出的高昂代價(jià)。
模板是效率的對(duì)立面的一個(gè)例子，根據(jù)語(yǔ)言標(biāo)準(zhǔn)，編譯器在模板實(shí)例化為一個(gè)具體的類型時(shí)產(chǎn)生代碼。理論上，看上去是聲明了一個(gè)模板，但卻實(shí)際產(chǎn)生了大量的相似的代碼。如果你有了class1的指針的vector，也有class2的指針的vector，你就在你的可執(zhí)行文件中做了兩份的vector的拷貝。
事實(shí)上，大多數(shù)的編譯器做得更好，首先，只有實(shí)際被使用到的模板成員函數(shù)被產(chǎn)生代碼。其次，如果事先了解了正確的行為，編譯器可以只產(chǎn)生一份代碼的拷貝。你可以從vector的例子發(fā)現(xiàn)這一點(diǎn)，確實(shí)只產(chǎn)生了一份代碼（一般是vector）。有了好的編譯器，模板還是可以在保持高效的同時(shí)提供你一般編程的好處。
C++的一些特性，比如初始化列表以及前自增，一般來說可以提高效率。而象其它的一些特性比如運(yùn)算符重載以及RTTI則看起來似乎是清白的，但卻有時(shí)帶來嚴(yán)重的效率問題。STL的容器則描述了盲目相信函數(shù)的算法運(yùn)行時(shí)間可以如何讓你誤入歧途。避免使用潛在的低效率的語(yǔ)言或類庫(kù)特性，同時(shí)花些時(shí)間來了解你的編譯器的各種選項(xiàng)。你會(huì)很快的學(xué)會(huì)設(shè)計(jì)高效的代碼，并且解決掉你的游戲中的效率問題。
談到優(yōu)化，很多人都會(huì)直接想到匯編。難道優(yōu)化只能在匯編層次嗎？當(dāng)然不是，C++層次一樣可以作代碼優(yōu)化，其中有些常常是意想不到的。在C++層次進(jìn)行優(yōu)化，比在匯編層次優(yōu)化具有更好的移植性，應(yīng)該是優(yōu)化中的首選做法。
確定浮點(diǎn)型變量和表達(dá)式是 float 型
為了讓編譯器產(chǎn)生更好的代碼(比如說產(chǎn)生3DNow! 或SSE指令的代碼)，必須確定浮點(diǎn)型變量和表達(dá)式是 float 型的。要特別注意的是，以 "；F"； 或 "；f"； 為后綴（比如：3.14f）的浮點(diǎn)常量才是 float 型，否則默認(rèn)是 double 型。為了避免 float 型參數(shù)自動(dòng)轉(zhuǎn)化為 double，請(qǐng)?jiān)诤瘮?shù)聲明時(shí)使用 float。
使用32位的數(shù)據(jù)類型
編譯器有很多種，但它們都包含的典型的32位類型是：int，signed，signed int，unsigned，unsigned int，long，signed long，long int，signed long int，unsigned long，unsigned long int。盡量使用32位的數(shù)據(jù)類型，因?yàn)樗鼈儽?6位的數(shù)據(jù)甚至8位的數(shù)據(jù)更有效率。
明智使用有符號(hào)整型變量
在很多情況下，你需要考慮整型變量是有符號(hào)還是無(wú)符號(hào)類型的。比如，保存一個(gè)人的體重?cái)?shù)據(jù)時(shí)不可能出現(xiàn)負(fù)數(shù)，所以不需要使用有符號(hào)類型。但是，如果是要保存溫度數(shù)據(jù)，就必須使用到有符號(hào)的變量。
在許多地方，考慮是否使用有符號(hào)的變量是必要的。在一些情況下，有符號(hào)的運(yùn)算比較快；但在一些情況下卻相反。
比如：整型到浮點(diǎn)轉(zhuǎn)化時(shí)，使用大于16位的有符號(hào)整型比較快。因?yàn)閤86構(gòu)架中提供了從有符號(hào)整型轉(zhuǎn)化到浮點(diǎn)型的指令，但沒有提供從無(wú)符號(hào)整型轉(zhuǎn)化到浮點(diǎn)的指令。看看編譯器產(chǎn)生的匯編代碼：
不好的代碼：
編譯前 編譯后
double x； mov [foo + 4], 0
unsigned int i； mov eax, i
x = i； mov [foo], eax
flid qword ptr [foo]
fstp qword ptr [x]
上面的代碼比較慢。不僅因?yàn)橹噶顢?shù)目比較多，而且由于指令不能配對(duì)造成的FLID指令被延遲執(zhí)行。最好用以下代碼代替：
推薦的代碼：
編譯前 編譯后
double x； fild dword ptr [i]
int i； fstp qword ptr [x]
x = i；
在整數(shù)運(yùn)算中計(jì)算商和余數(shù)時(shí)，使用無(wú)符號(hào)類型比較快。以下這段典型的代碼是編譯器產(chǎn)生的32位整型數(shù)除以4的代碼：
不好的代碼 推薦的代碼
編譯前 編譯后
int i； mov eax, i
i = i / 4； cdq
and edx, 3
add eax, edx
sar eax, 2
mov i, eax
編譯前 編譯后
unsigned int i； shr i, 2
i = i / 4；
總結(jié)：
無(wú)符號(hào)類型用于：
除法和余數(shù)
循環(huán)計(jì)數(shù)
數(shù)組下標(biāo)
有符號(hào)類型用于：
整型到浮點(diǎn)的轉(zhuǎn)化
while VS. for
在編程中，我們常常需要用到無(wú)限循環(huán)，常用的兩種方法是while (1) 和 for (；；)。這兩種方法效果完全一樣，但那一種更好呢？然我們看看它們編譯后的代碼：
編譯前 編譯后
while (1)； mov eax,1
test eax,eax
je foo+23h
jmp foo+18h
編譯前 編譯后
for (；；)； jmp foo+23h
一目了然，for (；；)指令少，不占用寄存器，而且沒有判斷跳轉(zhuǎn)，比while (1)好。
使用數(shù)組型代替指針型
使用指針會(huì)使編譯器很難優(yōu)化它。因?yàn)槿狈τ行У闹羔槾a優(yōu)化的方法，編譯器總是假設(shè)指針可以訪問內(nèi)存的任意地方，包括分配給其他變量的儲(chǔ)存空間。所以為了編譯器產(chǎn)生優(yōu)化得更好的代碼，要避免在不必要的地方使用指針。一個(gè)典型的例子是訪問存放在數(shù)組中的數(shù)據(jù)。C++ 允許使用操作符 [] 或指針來訪問數(shù)組，使用數(shù)組型代碼會(huì)讓優(yōu)化器減少產(chǎn)生不安全代碼的可能性。比如，x[0] 和x[2] 不可能是同一個(gè)內(nèi)存地址，但 *p 和 *q 可能。強(qiáng)烈建議使用數(shù)組型，因?yàn)檫@樣可能會(huì)有意料之外的性能提升。
不好的代碼 推薦的代碼
typedef struct
{
float x,y,z,w；
} VERTEX；
typedef struct
{
float m[4][4]；
} MATRIX；
void Xform(float* res, const float* v, const float* m, int nNumVerts)
{
float dp；
int i；
const VERTEX* vv = (VERTEX *)v；
for (i = 0； i <； nNumVerts； i++)
{
dp = vv->；x * *m ++；
dp += vv->；y * *m ++；
dp += vv->；z * *m ++；
dp += vv->；w * *m ++；
*res ++ = dp； // 寫入轉(zhuǎn)換了的 x
dp = vv->；x * *m ++；
dp += vv->；y * *m ++；
dp += vv->；z * *m ++；
dp += vv->；w * *m ++；
*res ++ = dp； // 寫入轉(zhuǎn)換了的 y
dp = vv->；x * *m ++；
dp += vv->；y * *m ++；
dp += vv->；z * *m ++；
dp += vv->；w * *m ++；
*res ++ = dp； // 寫入轉(zhuǎn)換了的 z
dp = vv->；x * *m ++；
dp += vv->；y * *m ++；
dp += vv->；z * *m ++；
dp += vv->；w * *m ++；
*res ++ = dp； // 寫入轉(zhuǎn)換了的 w
vv ++； // 下一個(gè)矢量
m -= 16；
}
}
typedef struct
{
float x,y,z,w；
} VERTEX；
typedef struct
{
float m[4][4]；
} MATRIX；
void Xform (float* res, const float* v, const float* m, int nNumVerts)
{
int i；
const VERTEX* vv = (VERTEX*)v；
const MATRIX* mm = (MATRIX*)m；
VERTEX* rr = (VERTEX*)res；
for (i = 0； i <； nNumVerts； i++)
{
rr->；x = vv->；x * mm->；m[0][0] + vv->；y * mm->；m[0][1]
+ vv->；z * mm->；m[0][2] + vv->；w * mm->；m[0][3]；
rr->；y = vv->；x * mm->；m[1][0] + vv->；y * mm->；m[1][1]
+ vv->；z * mm->；m[1][2] + vv->；w * mm->；m[1][3]；
rr->；z = vv->；x * mm->；m[2][0] + vv->；y * mm->；m[2][1]
+ vv->；z * mm->；m[2][2] + vv->；w * mm->；m[2][3]；
rr->；w = vv->；x * mm->；m[3][0] + vv->；y * mm->；m[3][1]
+ vv->；z * mm->；m[3][2] + vv->；w * mm->；m[3][3]；
}
}
注意: 源代碼的轉(zhuǎn)化是與編譯器的代碼發(fā)生器相結(jié)合的。從源代碼層次很難控制產(chǎn)生的機(jī)器碼。依靠編譯器和特殊的源代碼，有可能指針型代碼編譯成的機(jī)器碼比同等條件下的數(shù)組型代碼運(yùn)行速度更快。明智的做法是在源代碼轉(zhuǎn)化后檢查性能是否真正提高了，再選擇使用指針型還是數(shù)組型。
[充分分解小的循環(huán)]
要充分利用CPU的指令緩存，就要充分分解小的循環(huán)。特別是當(dāng)循環(huán)體本身很小的時(shí)候，分解循環(huán)可以提高性能。BTW:很多編譯器并不能自動(dòng)分解循環(huán)。
不好的代碼 推薦的代碼
// 3D轉(zhuǎn)化：把矢量 V 和 4x4 矩陣 M 相乘
for (i = 0； i <； 4； i ++)
{
r[i] = 0；
for (j = 0； j <； 4； j ++)
{
r[i] += M[j][i]*V[j]；
}
}
r[0] = M[0][0]*V[0] + M[1][0]*V[1] + M[2][0]*V[2] + M[3][0]*V[3]；
r[1] = M[0][1]*V[0] + M[1][1]*V[1] + M[2][1]*V[2] + M[3][1]*V[3]；
r[2] = M[0][2]*V[0] + M[1][2]*V[1] + M[2][2]*V[2] + M[3][2]*V[3]；
r[3] = M[0][3]*V[0] + M[1][3]*V[1] + M[2][3]*V[2] + M[3][3]*v[3]；
[避免沒有必要的讀寫依賴]
當(dāng)數(shù)據(jù)保存到內(nèi)存時(shí)存在讀寫依賴，即數(shù)據(jù)必須在正確寫入后才能再次讀取。雖然AMD Athlon等CPU有加速讀寫依賴延遲的硬件，允許在要保存的數(shù)據(jù)被寫入內(nèi)存前讀取出來，但是，如果避免了讀寫依賴并把數(shù)據(jù)保存在內(nèi)部寄存器中，速度會(huì)更快。在一段很長(zhǎng)的又互相依賴的代碼鏈中，避免讀寫依賴顯得尤其重要。如果讀寫依賴發(fā)生在操作數(shù)組時(shí)，許多編譯器不能自動(dòng)優(yōu)化代碼以避免讀寫依賴。所以推薦程序員手動(dòng)去消除讀寫依賴，舉例來說，引進(jìn)一個(gè)可以保存在寄存器中的臨時(shí)變量。這樣可以有很大的性能提升。下面一段代碼是一個(gè)例子：
不好的代碼 推薦的代碼
float x[VECLEN], y[VECLEN], z[VECLEN]；
......
for (unsigned int k = 1； k <； VECLEN； k ++)
{
x[k] = x[k-1] + y[k]；
}
for (k = 1； k <； VECLEN； k++)
{
x[k] = z[k] * (y[k] - x[k-1])；
}
float x[VECLEN], y[VECLEN], z[VECLEN]；
......
float t(x[0])；
for (unsigned int k = 1； k <； VECLEN； k ++)
{
t = t + y[k]；
x[k] = t；
}
t = x[0]；
for (k = 1； k <； VECLEN； k ++)
{
t = z[k] * (y[k] - t)；
x[k] = t；
}
Switch 的用法
Switch 可能轉(zhuǎn)化成多種不同算法的代碼。其中最常見的是跳轉(zhuǎn)表和比較鏈/樹。推薦對(duì)case的值依照發(fā)生的可能性進(jìn)行排序，把最有可能的放在第一個(gè)，當(dāng)switch用比較鏈的方式轉(zhuǎn)化時(shí)，這樣可以提高性能。此外，在case中推薦使用小的連續(xù)的整數(shù)，因?yàn)樵谶@種情況下，所有的編譯器都可以把switch 轉(zhuǎn)化成跳轉(zhuǎn)表。
不好的代碼 推薦的代碼
int days_in_month, short_months, normal_months, long_months；
......
switch (days_in_month)
{
case 28:
case 29:
short_months ++；
break；
case 30:
normal_months ++；
break；
case 31:
long_months ++；
break；
default:
cout <；<； "；month has fewer than 28 or more than 31 days"； <；<； endl；
break；
}
int days_in_month, short_months, normal_months, long_months；
......
switch (days_in_month)
{
case 31:
long_months ++；
break；
case 30:
normal_months ++；
break；
case 28:
case 29:
short_months ++；
break；
default:
cout <；<； "；month has fewer than 28 or more than 31 days"； <；<； endl；
break；
}
所有函數(shù)都應(yīng)該有原型定義
一般來說，所有函數(shù)都應(yīng)該有原型定義。原型定義可以傳達(dá)給編譯器更多的可能用于優(yōu)化的信息。
[盡可能使用常量(const)]
盡可能使用常量(const)。C++ 標(biāo)準(zhǔn)規(guī)定，如果一個(gè)const聲明的對(duì)象的地址不被獲取，允許編譯器不對(duì)它分配儲(chǔ)存空間。這樣可以使代碼更有效率，而且可以生成更好的代碼。
提升循環(huán)的性能
要提升循環(huán)的性能，減少多余的常量計(jì)算非常有用（比如，不隨循環(huán)變化的計(jì)算）。
不好的代碼(在for()中包含不變的if()) 推薦的代碼
for( i ... )
{
if( CONSTANT0 )
{
DoWork0( i )； // 假設(shè)這里不改變CONSTANT0的值
}
else
{
DoWork1( i )； // 假設(shè)這里不改變CONSTANT0的值
}
}
if( CONSTANT0 )
{
for( i ... )
{
DoWork0( i )；
}
}
else
{
for( i ... )
{
DoWork1( i )；
}
}
如果已經(jīng)知道if()的值，這樣可以避免重復(fù)計(jì)算。雖然不好的代碼中的分支可以簡(jiǎn)單地預(yù)測(cè)，但是由于推薦的代碼在進(jìn)入循環(huán)前分支已經(jīng)確定，就可以減少對(duì)分支預(yù)測(cè)的依賴。 把本地函數(shù)聲明為靜態(tài)的(static)
如果一個(gè)函數(shù)在實(shí)現(xiàn)它的文件外未被使用的話，把它聲明為靜態(tài)的(static)以強(qiáng)制使用內(nèi)部連接。否則，默認(rèn)的情況下會(huì)把函數(shù)定義為外部連接。這樣可能會(huì)影響某些編譯器的優(yōu)化——比如，自動(dòng)內(nèi)聯(lián)。
考慮動(dòng)態(tài)內(nèi)存分配
動(dòng)態(tài)內(nèi)存分配（C++中的"；new"；）可能總是為長(zhǎng)的基本類型（四字對(duì)齊）返回一個(gè)已經(jīng)對(duì)齊的指針。但是如果不能保證對(duì)齊，使用以下代碼來實(shí)現(xiàn)四字對(duì)齊。這段代碼假設(shè)指針可以映射到 long 型。
例子
double* p = (double*)new BYTE[sizeof(double) * number_of_doubles+7L]；
double* np = (double*)((long(p) + 7L) &； –8L)；
現(xiàn)在，你可以使用 np 代替 p 來訪問數(shù)據(jù)。注意：釋放儲(chǔ)存空間時(shí)仍然應(yīng)該用delete p。
使用顯式的并行代碼
盡可能把長(zhǎng)的有依賴的代碼鏈分解成幾個(gè)可以在流水線執(zhí)行單元中并行執(zhí)行的沒有依賴的代碼鏈。因?yàn)楦↑c(diǎn)操作有很長(zhǎng)的潛伏期，所以不管它被映射成 x87 或 3DNow! 指令，這都很重要。很多高級(jí)語(yǔ)言，包括C++，并不對(duì)產(chǎn)生的浮點(diǎn)表達(dá)式重新排序，因?yàn)槟鞘且粋€(gè)相當(dāng)復(fù)雜的過程。需要注意的是，重排序的代碼和原來的代碼在代數(shù)上一致并不等價(jià)于計(jì)算結(jié)果一致，因?yàn)楦↑c(diǎn)操作缺乏精確度。在一些情況下，這些優(yōu)化可能導(dǎo)致意料之外的結(jié)果。幸運(yùn)的是，在大部分情況下，最后結(jié)果可能只有最不重要的位（即最低位）是錯(cuò)誤的。
不好的代碼 推薦的代碼
double a[100], sum；
int i；
sum = 0.0f；
for (i=0； i<；100； i++)
sum += a[i]；
double a[100], sum1, sum2, sum3, sum4, sum；
int i；
sum1 = sum2 = sum3 = sum4 = 0.0；
for (i = 0； i <； 100； i += 4)
{
sum1 += a[i]；
sum2 += a[i+1]；
sum3 += a[i+2]；
sum4 += a[i+3]；
}
sum = (sum4+sum3)+(sum1+sum2)；
要注意的是：使用4 路分解是因?yàn)檫@樣使用了4階段流水線浮點(diǎn)加法，浮點(diǎn)加法的每一個(gè)階段占用一個(gè)時(shí)鐘周期，保證了最大的資源利用率。
提出公共子表達(dá)式
在某些情況下，C++編譯器不能從浮點(diǎn)表達(dá)式中提出公共的子表達(dá)式，因?yàn)檫@意味著相當(dāng)于對(duì)表達(dá)式重新排序。需要特別指出的是，編譯器在提取公共子表達(dá)式前不能按照代數(shù)的等價(jià)關(guān)系重新安排表達(dá)式。這時(shí)，程序員要手動(dòng)地提出公共的子表達(dá)式（在VC.net里有一項(xiàng)“全局優(yōu)化”選項(xiàng)可以完成此工作，但效果就不得而知了）。
推薦的代碼
float a, b, c, d, e, f；
...
e = b * c / d；
f = b / d * a；
float a, b, c, d, e, f；
...
const float t(b / d)；
e = c * t；
f = a * t；
推薦的代碼
float a, b, c, e, f；
...
e = a / c；
f = b / c；
float a, b, c, e, f；
...
const float t(1.0f / c)；
e = a * t；
f = b * t；
結(jié)構(gòu)體成員的布局
很多編譯器有“使結(jié)構(gòu)體字，雙字或四字對(duì)齊”的選項(xiàng)。但是，還是需要改善結(jié)構(gòu)體成員的對(duì)齊，有些編譯器可能分配給結(jié)構(gòu)體成員空間的順序與他們聲明的不同。但是，有些編譯器并不提供這些功能，或者效果不好。所以，要在付出最少代價(jià)的情況下實(shí)現(xiàn)最好的結(jié)構(gòu)體和結(jié)構(gòu)體成員對(duì)齊，建議采取這些方法：
按類型長(zhǎng)度排序
把結(jié)構(gòu)體的成員按照它們的類型長(zhǎng)度排序，聲明成員時(shí)把長(zhǎng)的類型放在短的前面。
把結(jié)構(gòu)體填充成最長(zhǎng)類型長(zhǎng)度的整倍數(shù)
把結(jié)構(gòu)體填充成最長(zhǎng)類型長(zhǎng)度的整倍數(shù)。照這樣，如果結(jié)構(gòu)體的第一個(gè)成員對(duì)齊了，所有整個(gè)結(jié)構(gòu)體自然也就對(duì)齊了。下面的例子演示了如何對(duì)結(jié)構(gòu)體成員進(jìn)行重新排序：
不好的代碼，普通順序 推薦的代碼，新的順序并手動(dòng)填充了幾個(gè)字節(jié)
struct
{
char a[5]；
long k；
double x；
} baz；
struct
{
double x；
long k；
char a[5]；
char pad[7]；
} baz；
這個(gè)規(guī)則同樣適用于類的成員的布局。
按數(shù)據(jù)類型的長(zhǎng)度排序本地變量
當(dāng)編譯器分配給本地變量空間時(shí)，它們的順序和它們?cè)谠创a中聲明的順序一樣，和上一條規(guī)則一樣，應(yīng)該把長(zhǎng)的變量放在短的變量前面。如果第一個(gè)變量對(duì)齊了，其它變量就會(huì)連續(xù)的存放，而且不用填充字節(jié)自然就會(huì)對(duì)齊。有些編譯器在分配變量時(shí)不會(huì)自動(dòng)改變變量順序，有些編譯器不能產(chǎn)生4字節(jié)對(duì)齊的棧，所以4字節(jié)可能不對(duì)齊。下面這個(gè)例子演示了本地變量聲明的重新排序：
不好的代碼，普通順序 推薦的代碼，改進(jìn)的順序
short ga, gu, gi；
long foo, bar；
double x, y, z[3]；
char a, b；
float baz；
double z[3]；
double x, y；
long foo, bar；
float baz；
short ga, gu, gi；
避免不必要的整數(shù)除法
整數(shù)除法是整數(shù)運(yùn)算中最慢的，所以應(yīng)該盡可能避免。一種可能減少整數(shù)除法的地方是連除，這里除法可以由乘法代替。這個(gè)替換的副作用是有可能在算乘積時(shí)會(huì)溢出，所以只能在一定范圍的除法中使用。
不好的代碼 推薦的代碼
int i, j, k, m；
m = i / j / k；
int i, j, k, m；
m = i / (j * k)；
把頻繁使用的指針型參數(shù)拷貝到本地變量
避免在函數(shù)中頻繁使用指針型參數(shù)指向的值。因?yàn)榫幾g器不知道指針之間是否存在沖突，所以指針型參數(shù)往往不能被編譯器優(yōu)化。這樣是數(shù)據(jù)不能被存放在寄存器中，而且明顯地占用了內(nèi)存帶寬。注意，很多編譯器有“假設(shè)不沖突”優(yōu)化開關(guān)（在VC里必須手動(dòng)添加編譯器命令行/Oa或/Ow），這允許編譯器假設(shè)兩個(gè)不同的指針總是有不同的內(nèi)容，這樣就不用把指針型參數(shù)保存到本地變量。否則，請(qǐng)?jiān)诤瘮?shù)一開始把指針指向的數(shù)據(jù)保存到本地變量。如果需要的話，在函數(shù)結(jié)束前拷貝回去。 不好的代碼 推薦的代碼
?/ 假設(shè) q != r
void isqrt(unsigned long a, unsigned long* q, unsigned long* r)
{
*q = a；
if (a >； 0)
{
while (*q >； (*r = a / *q))
{
*q = (*q + *r) >；>； 1；
}
}
*r = a - *q * *q；
}
// 假設(shè) q != r
void isqrt(unsigned long a, unsigned long* q, unsigned long* r)
{
unsigned long qq, rr；
qq = a；
if (a >； 0)
{
while (qq >； (rr = a / qq))
{
qq = (qq + rr) >；>； 1；
}
}
rr = a - qq * qq；
*q = qq；
*r = rr；
}
賦值與初始化
先看看以下代碼：
class CInt
{
int m_i；
public:
CInt(int a = 0):m_i(a) { cout <；<； "；CInt"； <；<； endl； }
~CInt() { cout <；<； "；~CInt"； <；<； endl； }
CInt operator + (const CInt&； a) { return CInt(m_i + a.GetInt())； }
void SetInt(const int i) { m_i = i； }
int GetInt() const { return m_i； }
}；
不好的代碼 推薦的代碼
void main()
{
CInt a, b, c；
a.SetInt(1)；
b.SetInt(2)；
c = a + b；
}
void main()
{
CInt a(1), b(2)；
CInt c(a + b)；
}
這兩段代碼所作的事都一樣，但那一個(gè)更好呢？看看輸出結(jié)果就會(huì)發(fā)現(xiàn)，不好的代碼輸出了四個(gè)"；CInt"；和四個(gè)"；~CInt"；，而推薦的代碼只輸出三個(gè)。也就是說，第二個(gè)例子比第一個(gè)例子少生成一次臨時(shí)對(duì)象。Why? 請(qǐng)注意，第一個(gè)中的c用的是先聲明再賦值的方法，第二個(gè)用的是初始化的方法，它們有本質(zhì)的區(qū)別。第一個(gè)例子的"；c = a + b"；先生成一個(gè)臨時(shí)對(duì)象用來保存a + b的值，再把該臨時(shí)對(duì)象用位拷貝的方法給c賦值，然后臨時(shí)對(duì)象被銷毀。這個(gè)臨時(shí)對(duì)象就是那個(gè)多出來的對(duì)象。第二個(gè)例子直接用拷貝構(gòu)造函數(shù)的方法對(duì)c初始化，不產(chǎn)生臨時(shí)對(duì)象。所以，盡量在需要使用一個(gè)對(duì)象時(shí)才聲明，并用初始化的方法賦初值。
盡量使用成員初始化列表
在初始化類的成員時(shí)，盡量使用成員初始化列表而不是傳統(tǒng)的賦值方式。
不好的代碼 推薦的代碼
籧lass CMyClass
{
string strName；
public:
CMyClass(const string&； str)；
}；
CMyClass::CMyClass(const string&； str)
{
strName = str；
}
class CMyClass
{
string strName；
int i；
public:
CMyClass(const string&； str)；
}；
CMyClass::CMyClass(const string&；str)
: strName(str)
{
}
不好的例子用的是賦值的方式。這樣，strName會(huì)先被建立（調(diào)用了string的默認(rèn)構(gòu)造函數(shù)），再由參數(shù)str賦值。而推薦的例子用的是成員初始化列表，strName直接構(gòu)造為str，少調(diào)用一次默認(rèn)構(gòu)造函數(shù)，還少了一些安全隱患。