C++ 代碼優(yōu)化

2019-11-17 05:40:18

字體：大中小

供稿：網(wǎng)友

　　談到優(yōu)化，很多人都會(huì)直接想到匯編。難道優(yōu)化只能在匯編層次嗎？當(dāng)然不是，C++層次一樣可以作代碼優(yōu)化，其中有些經(jīng)常是意想不到的。在C++層次進(jìn)行優(yōu)化，比在匯編層次優(yōu)化具有更好的移植性，應(yīng)該是優(yōu)化中的首選做法。

　　確定浮點(diǎn)型變量和表達(dá)式是 float 型

　　為了讓編譯器產(chǎn)生更好的代碼(比如說(shuō)產(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ù)類(lèi)型

　　編譯器有很多種，但它們都包含的典型的32位類(lèi)型是：int，signed，signed int，unsigned，unsigned int，long，signed long，long int，signed long int，unsigned long，unsigned long int。盡量使用32位的數(shù)據(jù)類(lèi)型，因?yàn)樗鼈儽?6位的數(shù)據(jù)甚至8位的數(shù)據(jù)更有效率。

　　明智使用有符號(hào)整型變量

　　在很多情況下，你需要考慮整型變量是有符號(hào)還是無(wú)符號(hào)類(lèi)型的。比如，保存一個(gè)人的體重?cái)?shù)據(jù)時(shí)不可能出現(xiàn)負(fù)數(shù)，所以不需要使用有符號(hào)類(lèi)型。但是，假如是要保存溫度數(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)型的指令，但沒(méi)有提供從無(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)類(lèi)型比較快。以下這段典型的代碼是編譯器產(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)類(lèi)型用于：
　　除法和余數(shù)
　　循環(huán)計(jì)數(shù)
　　數(shù)組下標(biāo)
　　有符號(hào)類(lèi)型用于：
　　整型到浮點(diǎn)的轉(zhuǎn)化
　　while VS. for

　　在編程中，我們經(jīng)常需要用到無(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 (；；)指令少，不占用寄存器，而且沒(méi)有判定跳轉(zhuǎn)，比while (1)好。
　　使用數(shù)組型代替指針型

　　使用指針會(huì)使編譯器很難優(yōu)化它。因?yàn)槿狈τ行У闹羔槾a優(yōu)化的方法，編譯器總是假設(shè)指針可以訪問(wèn)內(nèi)存的任意地方，包括分配給其他變量的儲(chǔ)存空間。所以為了編譯器產(chǎn)生優(yōu)化得更好的代碼，要避免在不必要的地方使用指針。一個(gè)典型的例子是訪問(wèn)存放在數(shù)組中的數(shù)據(jù)。C++ 答應(yīng)使用操作符 [] 或指針來(lái)訪問(wèn)數(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；　　　　　　// 寫(xiě)入轉(zhuǎn)換了的 x
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　　// 寫(xiě)入轉(zhuǎn)換了的 y
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　// 寫(xiě)入轉(zhuǎn)換了的 z
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　// 寫(xiě)入轉(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]；
　　避免沒(méi)有必要的讀寫(xiě)依靠

　　當(dāng)數(shù)據(jù)保存到內(nèi)存時(shí)存在讀寫(xiě)依靠，即數(shù)據(jù)必須在正確寫(xiě)入后才能再次讀取。雖然AMD Athlon等CPU有加速讀寫(xiě)依靠延遲的硬件，答應(yīng)在要保存的數(shù)據(jù)被寫(xiě)入內(nèi)存前讀取出來(lái)，但是，假如避免了讀寫(xiě)依靠并把數(shù)據(jù)保存在內(nèi)部寄存器中，速度會(huì)更快。在一段很長(zhǎng)的又互相依靠的代碼鏈中，避免讀寫(xiě)依靠顯得尤其重要。假如讀寫(xiě)依靠發(fā)生在操作數(shù)組時(shí)，許多編譯器不能自動(dòng)優(yōu)化代碼以避免讀寫(xiě)依靠。所以推薦程序員手動(dòng)去消除讀寫(xiě)依靠，舉例來(lái)說(shuō)，引進(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)化成多種不同算法的代碼。其中最常見(jiàn)的是跳轉(zhuǎn)表和比較鏈/樹(shù)。推薦對(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)該有原型定義

　　一般來(lái)說(shuō)，所有函數(shù)都應(yīng)該有原型定義。原型定義可以傳達(dá)給編譯器更多的可能用于優(yōu)化的信息。

　　盡可能使用常量(const)

　　盡可能使用常量(const)。C++ 標(biāo)準(zhǔn)規(guī)定，假如一個(gè)const聲明的對(duì)象的地址不被獲取，答應(yīng)編譯器不對(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)單地猜測(cè)，但是由于推薦的代碼在進(jìn)入循環(huán)前分支已經(jīng)確定，就可以減少對(duì)分支猜測(cè)的依靠。　　把本地函數(shù)聲明為靜態(tài)的(static)

　　假如一個(gè)函數(shù)在實(shí)現(xiàn)它的文件外未被使用的話(huà)，把它聲明為靜態(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)的基本類(lèi)型（四字對(duì)齊）返回一個(gè)已經(jīng)對(duì)齊的指針。但是假如不能保證對(duì)齊，使用以下代碼來(lái)實(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 來(lái)訪問(wèn)數(shù)據(jù)。注重：釋放儲(chǔ)存空間時(shí)仍然應(yīng)該用delete p。

　　使用顯式的并行代碼

　　盡可能把長(zhǎng)的有依靠的代碼鏈分解成幾個(gè)可以在流水線執(zhí)行單元中并行執(zhí)行的沒(méi)有依靠的代碼鏈。因?yàn)楦↑c(diǎn)操作有很長(zhǎng)的潛伏期，所以不管它被映射成 x87 或 3DNow! 指令，這都很重要。很多高級(jí)語(yǔ)言，包括C++，并不對(duì)產(chǎn)生的浮點(diǎn)表達(dá)式重新排序，因?yàn)槟鞘且粋€(gè)相當(dāng)復(fù)雜的過(guò)程。需要注重的是，重排序的代碼和原來(lái)的代碼在代數(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ì)齊，建議采取這些方法：

　　按類(lèi)型長(zhǎng)度排序

　　把結(jié)構(gòu)體的成員按照它們的類(lèi)型長(zhǎng)度排序，聲明成員時(shí)把長(zhǎng)的類(lèi)型放在短的前面。

　　把結(jié)構(gòu)體填充成最長(zhǎng)類(lèi)型長(zhǎng)度的整倍數(shù)

　　把結(jié)構(gòu)體填充成最長(zhǎng)類(lèi)型長(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ī)則同樣適用于類(lèi)的成員的布局。

　　按數(shù)據(jù)類(lèi)型的長(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)化開(kāi)關(guān)（在VC里必須手動(dòng)添加編譯器命令行/Oa或/Ow），這答應(yīng)編譯器假設(shè)兩個(gè)不同的指針總是有不同的內(nèi)容，這樣就不用把指針型參數(shù)保存到本地變量。否則，請(qǐng)?jiān)诤瘮?shù)一開(kāi)始把指針指向的數(shù)據(jù)保存到本地變量。假如需要的話(huà)，在函數(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è)。也就是說(shuō)，第二個(gè)例子比第一個(gè)例子少生成一次臨時(shí)對(duì)象。Why? 請(qǐng)注重，第一個(gè)中的c用的是先聲明再賦值的方法，第二個(gè)用的是初始化的方法，它們有本質(zhì)的區(qū)別。第一個(gè)例子的"；c = a + b"；先生成一個(gè)臨時(shí)對(duì)象用來(lái)保存a + b的值，再把該臨時(shí)對(duì)象用位拷貝的方法給c賦值，然后臨時(shí)對(duì)象被銷(xiāo)毀。這個(gè)臨時(shí)對(duì)象就是那個(gè)多出來(lái)的對(duì)象。第二個(gè)例子直接用拷貝構(gòu)造函數(shù)的方法對(duì)c初始化，不產(chǎn)生臨時(shí)對(duì)象。所以，盡量在需要使用一個(gè)對(duì)象時(shí)才聲明，并用初始化的方法賦初值。

　　盡量使用成員初始化列表

　　在初始化類(lèi)的成員時(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ù)，還少了一些安全隱患。

上一篇：C/C++中數(shù)組和指針類(lèi)型的關(guān)系的入門(mén)教程

下一篇：Perform()與SendMessage()的不同