目錄

????????

1、概述

? ? ? ? 本文檔參考林銳博士《高質(zhì)量C++ C編程指南》及自己的心得編寫，如有侵權(quán)，立刻刪除！

2 、編程指南

2.1文章結(jié)構(gòu)

? ? ? ? 每個(gè)C++/C程序通常分為兩個(gè)文件。一個(gè)文件用于保存程序的聲明，我們稱之為頭文件。另一個(gè)文件用于保存程序的實(shí)現(xiàn)，我們稱之為定義文件。

? ? ? ? C++/C程序的頭文件以“.h”為后綴，C程序的定義文件以“.c”為后綴，C++程序的定義文件通常以“.cpp”為后綴（也有一些系統(tǒng)以“.cc”或“.cxx”為后綴）。

2.1.1版權(quán)和版本的聲明

? ? ? ? 版權(quán)和版本的聲明位于頭文件和定義文件的開頭，主要內(nèi)容有：

• ? ? ? ? 版本信息
• ? ? ? ? 文件名稱，標(biāo)識(shí)符，摘要
• ? ? ? ? 當(dāng)前版本號(hào)，作者/修改著，完成日期
• ? ? ? ? 版本歷史信息

/*

*Copyright(c) 2024

*All rights reserved.

*

*文件名稱：filename.h

*文件標(biāo)識(shí)：見配置管理計(jì)劃

*摘????????要：簡(jiǎn)要描述文本內(nèi)容

*

*當(dāng)前版本：1.1

*作????????者：輸入作者（或修改者）名字

*完成日期：xxxx年xx月xx日

*

*取代版本：1.0

*原作者? ? ：輸入原作者（或修改者）名字

*完成日期：xxxx年xx月xx日

*/

2.1.2頭文件的結(jié)構(gòu)?

? ? ? ? 頭文件由三部分組成：

? ? ? ? （1）頭文件開頭處的版權(quán)和版本聲明（見2.1.1）；

? ? ? ? （2）預(yù)處理塊；?

? ? ? ? （3）函數(shù)和類結(jié)構(gòu)聲明等。

? ? ? ? 假設(shè)頭文件的名稱為header.h，頭文件的結(jié)構(gòu)參見如下：

• 規(guī)則1：為了防止頭文件被重復(fù)引用，應(yīng)當(dāng)用ifndef/define/endif結(jié)構(gòu)產(chǎn)生預(yù)處理塊。
• 規(guī)則2：用#include <header.h>格式來(lái)引用標(biāo)準(zhǔn)庫(kù)的頭文件（編譯器將從標(biāo)準(zhǔn)庫(kù)目錄開始搜索）。
• 規(guī)則3：用#include "header.h" 格式來(lái)引用非標(biāo)準(zhǔn)庫(kù)的頭文件（編譯器將從用戶的工作目錄開始搜索）。

?????????建議1：頭文件中只存放“聲明”而不存放“定義”

? ? ? ? 在C++語(yǔ)法中，類的成員函數(shù)可以在聲明的同時(shí)被定義，并且自動(dòng)成為內(nèi)聯(lián)函數(shù)。這雖然會(huì)帶來(lái)書寫上的方便，卻造成了風(fēng)格不一致，弊大于利。建議將成員函數(shù)的定義與聲明分開，不論函數(shù)體有多小。

?????????建議2：不提倡使用全局變量，盡量不要在頭文件中出現(xiàn)像extern int value這類聲明

//版權(quán)和版本聲明見2.1.1,此處省略


#ifndef? ? ? ? HEADER_H? ? //防止header.h被重復(fù)引用

#define? ? ? ?HEADER_H


#include? <math.h>? ? ? ? //引用標(biāo)準(zhǔn)庫(kù)的頭文件

...

#include "myheader.h"? ? //引用非標(biāo)準(zhǔn)庫(kù)的頭文件

...


void Funtion(...);? ? ? ? ? ? ?//全局函數(shù)聲明

...


class Box? ? ? ? ? ? ? ? ? ? ? ? //類結(jié)構(gòu)聲明

{
    ...
};


#endif

2.1.3定義文件的結(jié)構(gòu)?

? ? ? ? 定義文件有三部分內(nèi)容：?

（1）定義文件開頭處的版權(quán)和版本聲明；

（2）對(duì)一些頭文件的使用；

（3）程序的實(shí)現(xiàn)體（包括數(shù)據(jù)和代碼）

? ? ? ? 假設(shè)定義文件的名稱為header.cpp，定義文件的結(jié)構(gòu)參見如下：?

//版權(quán)和版本說明見2.1.1，此處省略

#include "header.h"        //引用頭文件

...

//全局函數(shù)的實(shí)現(xiàn)體
void Funtion(...)
{
    ...
}

//類成員函數(shù)的實(shí)現(xiàn)體
void Box::Draw(...)
{
    ...
}

?2.1.4頭文件的作用

? ? ? ? 早期的編程語(yǔ)言如Basic、Fortran沒有頭文件的概念，C++/C語(yǔ)言的初學(xué)者雖然會(huì)使用頭文件，但常常不明其理。這里對(duì)頭文件的作用略作解釋：

（1）通過頭文件來(lái)調(diào)用庫(kù)功能。在很多場(chǎng)合，源代碼不便（不準(zhǔn)）向用戶公布，只要向用戶提供頭文件和二進(jìn)制的庫(kù)即可。用戶只需要按照文件中的接口聲明來(lái)調(diào)用庫(kù)功能，而不必關(guān)心接口怎么實(shí)現(xiàn)的。編譯器會(huì)從庫(kù)中提取相應(yīng)的代碼。

（2）頭文件能加強(qiáng)類型安全檢查。如果某個(gè)接口被實(shí)現(xiàn)或被使用時(shí)，其方式與頭文件的聲明不一致，編譯器就會(huì)指出錯(cuò)誤，這一簡(jiǎn)單的規(guī)則能大大減輕程序員調(diào)試、改錯(cuò)的負(fù)擔(dān)。

2.1.5目錄結(jié)構(gòu)?

? ? ? ? 如果一個(gè)軟件的頭文件數(shù)目比較多（如果超過10個(gè)），通常應(yīng)將頭文件和定義文件分別保存于不同的目錄，以便于維護(hù)。

? ? ? ? 例如可將頭文件保存在include目錄，將定義文件保存于source目錄（可以是多級(jí)目錄）。

? ? ? ? 如果某些頭文件時(shí)是私有的，它不會(huì)被用戶的程序直接引用，則沒有必要公開其“聲明”。為了加強(qiáng)信息隱藏，這些私有的頭文件可以和定義文件文件存放于同一目錄。?

2.2程序的板式?

? ? ? ? 板式雖然不會(huì)影響程序的功能，但會(huì)影響程序的可讀性。程序的板式追求清晰、美觀，是程序風(fēng)格的重要構(gòu)成因素。

? ? ? ? 可以把程序的板式比喻為“書法”。好的“書法”可以讓人對(duì)程序一目了然，看得興致勃勃。差的程序“書法”如螃蟹爬行，讓人看的索然無(wú)味，更令維護(hù)者煩惱有加。請(qǐng)程序員們學(xué)習(xí)程序的“書法”，彌補(bǔ)大學(xué)計(jì)算機(jī)教育的漏洞，實(shí)在很有必要。?

2.2.1空行?

? ? ? ? 空行起著分隔程序段落的作用。空行得體（不過多也不過少）將使程序的布局更加清晰?？招胁粫?huì)浪費(fèi)內(nèi)存，雖然打印含有空行的程序是會(huì)多消耗一些紙張，但是值得，所以不要舍不得用空行。

• 規(guī)則1：在每個(gè)類聲明之后、每個(gè)函數(shù)體定義結(jié)束之后都要加上空行
• 規(guī)則2：在一個(gè)函數(shù)體內(nèi)，邏輯上密切相關(guān)的語(yǔ)句之間不加空行，其他地方應(yīng)加上空行分隔?

//函數(shù)之間的空行
//空行
void Funtion1(...)
{
    ...
}
//空行
void Funtion2(...)
{
    ...
}
//空行
void Funtion(...)
{
    ...
}

//函數(shù)內(nèi)部的空行
while(1)
{
    statement1;
    //空行
    if(1)
    {
        statement2;
    }
    else
    {
        statement3;
    }
    //空行
    statement4;
}

2.2.2代碼行?

• 規(guī)則1：一行代碼只做一件事，如只定義一個(gè)變量，或只寫一條語(yǔ)句。這樣代碼容易閱讀，并且方便于寫注釋。
• 規(guī)則2:if、for、while、do等語(yǔ)句自占一行，執(zhí)行語(yǔ)句不得緊跟其后。不論執(zhí)行語(yǔ)句有多少都要加{}，這樣可以防止書寫失誤。?

? ? ? ? 先看看風(fēng)格不良的代碼行：?

int nWidth, nHeight, nDepth;    //寬度高度深度


x = a + b; y = c + d; z = e + f;


if(nWIdth < nHeight) dosomething();


for(initialization; condition; updata)
    dosomething();
other();

? ? ? ? 在看看良好的代碼行：

int nWidth;    //寬度
int nHeight;   //高度
int nDepth;    //深度

X = a + b;
y = c + d;
z = e + f;

if(nWidth < nHeight)
{
    dosomething();
}

for(initialization; condition; updata)
{
    dosomething();
}

建議：盡可能在定義變量的同時(shí)初始化該變量（就近原則）?

? ? ? ? 如果變量的引用處和其定義處相隔比較遠(yuǎn)，變量的初始化很容易被忘記。如果引用了未被初始化的變量，可能會(huì)導(dǎo)致程序錯(cuò)誤，此條建議可減少隱患，例如：

int nWidth = 10;    //定義并初始化nWidth
int nHeight = 10;   //定義并初始化nHeight
int nDepth = 10;    //定義并初始化nDepth

2.2.3代碼行內(nèi)的空格?

• 規(guī)則1：關(guān)鍵字后要留有空格。像const、virtual、inline、case等關(guān)鍵字之后至少要留有一個(gè)空格，否則無(wú)法辨析關(guān)鍵字。像if、for、while等關(guān)鍵字之后應(yīng)留有一個(gè)空格再跟左括號(hào)‘（’，以突出關(guān)鍵字。
• 規(guī)則2：函數(shù)名之后不要留有空格，緊跟左括號(hào)‘（’，以與關(guān)鍵字區(qū)別。
• 規(guī)則3：‘（’向后緊跟‘）’、‘，’、‘；’向前緊跟，緊跟處不留空格。
• 規(guī)則4：‘，’之后要留空格，如Funtion(x, y, z)。如果‘；’不是一行的結(jié)束符號(hào)，其后要留空格，如for(initialization; condition; updata)。?
• 規(guī)則5：賦值操作符、比較操作符、算術(shù)操作符、邏輯操作符、位域操作符，如“=”、“+=”、“>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”、“^”等二元操作符的前后應(yīng)當(dāng)加空格。
• 規(guī)則6：一元操作符“！”、“~”、“++”、“--”、“&”（地址運(yùn)算符）等前后不加空格。
• 規(guī)則7：像“[ ]”、“.”、“->”這類操作符前后不加空格。

????????建議：?對(duì)于表達(dá)式比較長(zhǎng)的for語(yǔ)句和if語(yǔ)句，為了緊湊起見可以適當(dāng)?shù)厝サ粢恍┛崭?，如or（i=0; i<10; i++）和for((a<=b) && (c<=d))。

void Func1(int x, int y, int z);        //良好的風(fēng)格
void Func1(int x,int y,int z);          //不良的風(fēng)格

if(year >= 2000)                        //良好的風(fēng)格
if(year>=2000)                          //不良的風(fēng)格

if((a>=b) && (c<=d))                    //良好的風(fēng)格
if(a>=b&&c<=d)                          //不良的風(fēng)格

for(i=0; i<10; i++)                     //良好的風(fēng)格
{
    ...
}

for(i=0;i<10;i++)                      //不良的風(fēng)格
{
    ...
}

for(i = 0; i < 10; i++)                //過多的空格
{
    ...
}

x = a < b ? a : b;                    //良好的風(fēng)格
x=a<b?a:b;                            //不良的風(fēng)格

int *p = &y;                          //良好的風(fēng)格
int * p = & y;                        //不良的風(fēng)格

array[5] = 0;                         //不要寫成array [ 5 ] = 0;
a.Funtion();                          //不要寫成a . Funtion();
b->Funtion();                         //不要寫成b -> Funtion();

2.2.4對(duì)齊?

• 規(guī)則1：程序的分界符‘{‘ 和 ’}’應(yīng)獨(dú)占一行并且位于同一列，同時(shí)與引用他們的語(yǔ)句左對(duì)齊。
• 規(guī)則2：{}之內(nèi)的代碼塊在‘{’右邊數(shù)格處左對(duì)齊，縮進(jìn)為空格數(shù)4。?

//不良的代碼行
void Funtion(int x){
    ...//program code
}

if(condition){
    ...//program code
}
else{
    ...//program code
}

for(initialization; condition; updata){
    ...//program code
}

while(condition){
    ...//program code
}


//良好的代碼行
void Funtion(int x)
{
    ...//program code
}

if(condition)
{
    ...//program code
}
else
{
    ...//program code
}

for(initialization; condition; update)
{
    ...//program code
}

while(condition)
{
    ...//program code
}

//如果出現(xiàn)嵌套的{}，則使用縮進(jìn)對(duì)齊，如：
    {
        ...

        {
            ...    
        }

        ...
    }

2.2.5長(zhǎng)行拆分?

• ?規(guī)則1：代碼行最大長(zhǎng)度控制在70至80個(gè)字符以內(nèi)。代碼行不要過長(zhǎng)，否則眼睛看不過來(lái)，也不便于打印。
• 規(guī)則2：長(zhǎng)表達(dá)式要在低優(yōu)先級(jí)操作符處拆分成新行，操作符放在新行之首（以便突出操作符）。拆分出新行要進(jìn)行適當(dāng)?shù)目s進(jìn)，使排版整齊，語(yǔ)句可讀。

if((very_longer_variable1 >= very_longer_variable2)
    &&(very_longer_variable3 >= very_longer_variable4)
    &&(very_longer_variable5 >= very_longer_variable6))
{
    donsomething();
}

virtual CMatrix CMultiplyMatrix(CMatrix leftMatrix,
                                CMatrix rightMatrix);

for(very_longer_initialization;
    very_longer_condition;
    very_longer_update)
{
    dosomething();
}

2.2.6修飾符的位置?

? ? ? ? 修飾符 * 和 & 應(yīng)該靠近數(shù)據(jù)類型還是該靠近變量名，是個(gè)有爭(zhēng)議的話題。

? ? ? ? 若將修飾符 * 靠近數(shù)據(jù)類型，例如：int*? x;從語(yǔ)義上講此寫法比較直觀，及x是int類型的指針。

? ? ? ? 上述寫法的弊端是容易引起誤解，例如：int*? x,y;此處y容易被誤解為指針變量。雖然x和y分行定義可以避免誤解，但并不是人人都愿意這樣做。?

• 規(guī)則1：應(yīng)當(dāng)將修飾符 * 和 & 靠近變量名?

? ? ? ?

例如：char? *pName;

? ? ? ? ? ?int? ? ?*x,y;? ? ? ? //此處y不會(huì)被誤解為指針??

2.2.7注釋?

? ? ? ? ?C語(yǔ)言的注釋為“/*...*/”。C++語(yǔ)言中，程序塊的注釋常采用“/*...*/”,行注釋一般采用“//...”。注釋通常用于：

? ? ? ? （1）版本、版權(quán)說明；

? ? ? ? （2）函數(shù)接口說明；

? ? ? ? （3）重要的代碼行或段落提示。

? ? ? ? 雖然注釋有助于理解代碼，但注意不可過多的使用注釋。

• 規(guī)則1：注釋是對(duì)代碼的“提示”，而不是文檔。程序中的注釋不可喧賓奪主，注釋太多了會(huì)讓人眼花繚亂。注釋的花樣要少。
• 規(guī)則2：如果代碼本來(lái)就是清楚的，則不必加注釋。否則多此一舉，令人煩厭。?

例如：i++;//i加1，多余的注釋?

• 規(guī)則3：編寫代碼邊注釋，修改代碼同時(shí)修改相應(yīng)注釋，以保證注釋與代碼的一致性。不再有用的注釋要?jiǎng)h除。
• 規(guī)則4：注釋應(yīng)當(dāng)準(zhǔn)確、易懂，防止注釋有二義性。錯(cuò)誤的注釋不但無(wú)益反而有害。
• 規(guī)則5：盡量避免在注釋中使用縮寫，特別是不常用縮寫。
• 規(guī)則6：注釋的位置應(yīng)與被描述的代碼相領(lǐng)，可以放在代碼的上方或右方，不可放在下方。
• 規(guī)則7：當(dāng)代碼比較長(zhǎng)，特別是有多重嵌套時(shí)，應(yīng)當(dāng)在一些段落的結(jié)束處加注釋，便于閱讀。

/*
*函數(shù)介紹:
*輸入?yún)?shù):
*輸出參數(shù):
*返回值:
*/
void Function(float x, float y, float z)
{
    ...
}


if(...)
{
    ...

    while(...)
    {
        ...
    }//end of while
    
    ...
}//end of if

2.2.8類的板式?

? ? ? ? 類可以將數(shù)據(jù)和函數(shù)封裝在一起，其中函數(shù)表示了類的行為（或稱服務(wù)）。類提供關(guān)鍵字public、protect和private，分別用于聲明哪些數(shù)據(jù)和函數(shù)是公開的、受保護(hù)的和私有的。這樣可以達(dá)到信息隱藏的目的，既讓類僅僅公開必須要讓外界知道的內(nèi)容，而隱藏其他的一切內(nèi)容。我們不可以濫用類的封裝功能，不能把它當(dāng)成火鍋，什么東西都往里面扔。

? ? ? ? 類的板式主要有兩種方式：

? ? ? ? （1）將private類型的數(shù)據(jù)寫在最前面，而將public類型的函數(shù)寫在最后面，采用這種板式的程序員主張類的設(shè)計(jì)以“以數(shù)據(jù)位核心”，重點(diǎn)關(guān)注類的內(nèi)部結(jié)構(gòu)。

? ? ? ? （2）將public類型的函數(shù)寫在最前面，而將private類型的數(shù)據(jù)寫在后面，采用這種板式的程序員主張類的設(shè)計(jì)“以行為為中心”，重點(diǎn)關(guān)注的是類應(yīng)該提供什么樣的接口(或服務(wù))。

? ? ? ? 我建議讀者采用“以行為為中心”的書寫方式，即首先考慮類應(yīng)該提供什么樣的函數(shù)。這也是很多人的經(jīng)驗(yàn)--“這樣做不僅讓自己在設(shè)計(jì)類時(shí)思路清晰，而且方便別人閱讀。因?yàn)橛脩糇铌P(guān)心的是接口，誰(shuí)愿意先看到一堆私有的數(shù)據(jù)成員”。?

//以數(shù)據(jù)為中心的板式
class A
{
    private:
        int i, j;
        float x, y;
        ...

    public:
        void Function1(void);
        void Function2(void);
        ...
}



//以行為為中心的板式
class A
{
    public:
        void Function1(void);
        void Function2(void);
        ...

    private:
        int i, j;
        float x, y;
        ...
}

2.3命名規(guī)則?

2.3.1?縮寫

? ? ? ? 縮寫的幾種技術(shù)：

? ? ? ? （1）去掉所有的不再詞頭的元音字母。如screen寫成scrn， primtive寫成prmv;

? ? ? ? （2）使用單詞的頭一個(gè)或幾個(gè)字母。如Channel Activation寫成ChanActiv， Release Indication寫成RelInd;

? ? ? ? （3）使用變量名中每個(gè)有典型意義的單詞。如Count of Failure寫成Failcnt;

? ? ? ? （4）去掉無(wú)用的單詞后綴ing, ed等。如Paging Request寫成PaReq;

? ? ? ? （5）使用標(biāo)準(zhǔn)的或慣用的縮寫方式（包括協(xié)議文件中出現(xiàn)的縮寫方式）。如BSIC(Base Station Identification Code)、MAP（Mobile Application Part）。

? ? ? ? 縮寫的準(zhǔn)測(cè)：

? ? ? ? （1）縮寫應(yīng)保持一致性。如Channel不要有時(shí)縮寫成Chan,有時(shí)縮寫成Ch。

? ? ? ? （2）在源代碼頭部加入注釋來(lái)說明協(xié)議相關(guān)的、非通用縮寫。

? ? ? ? （3）表示符的長(zhǎng)度不超過32個(gè)字符。

2.3.2變量命名約定?

? ? ? ? 參照匈牙利命名法，即

? ? ? ? ? ? ? ? 【作用范圍域前綴】 + 【前綴】 + 基本類型 + 變量名

? ? ? ? 其中：

? ? ? ? （1）前綴是可選項(xiàng)，以小寫字母表示；

? ? ? ? （2）基本類型是必選項(xiàng)，以小寫字母表示；

? ? ? ? （3）變量名是必選項(xiàng)，可多個(gè)單詞（或縮寫）合在一起，每個(gè)單詞首字母大寫。

2.3.3宏與常量命名?

? ? ? ? 宏與常量的命名規(guī)則：?jiǎn)卧~的字母全部大寫，個(gè)單詞之間用下劃線隔開。命名舉例：

#define? ? ? ? MAX_SLOT_NUM? ? ? ? 8
#define? ? ? ? EI_ENCR_INFO? ? ? ? 0x07

const? int? MAX_ARRAY = 100;?

2.3.4結(jié)構(gòu)和結(jié)構(gòu)成員命名?

? ? ? ? 要求結(jié)構(gòu)體名稱后加_ST或者_(dá)st，表示是結(jié)構(gòu)體，如：

typedef struct _IC_VG_CONFIG_ST_
{
    XBUS_WORD iPortStart;
    XBUS_BYTE reserved;
    XBUS_BYTE ContinueNum;

}IcVgRange_st, *pIcVgRange_st;

? ? ? ? 結(jié)構(gòu)成員的命名同變量的命名規(guī)則。

2.3.4函數(shù)的命名?

? ? ? ? 單詞首字母為大寫，其余均為小寫，單詞之間不用下劃線。函數(shù)名應(yīng)以一個(gè)動(dòng)詞開頭，即函數(shù)名應(yīng)類似“動(dòng)賓結(jié)構(gòu)”。命名舉例：

extern int __stdcall BackMemToMemPool(pMenPoolMng_st pPool, pMemPoolIndex pIndexNide);

extern void __stdcall UninitMemPool(pMemPoolMng_st pPool);

2.4表達(dá)式和基本語(yǔ)句?

? ? ? ? 讀者可能懷疑：連if、for、while、goto、swicth這樣簡(jiǎn)單的東西也要探討編程風(fēng)格，是不是有點(diǎn)小題大做了？

? ? ? ? 我真的發(fā)覺很多程序員用隱含錯(cuò)誤的方式寫表達(dá)式和基本語(yǔ)句，我自己也犯過類似的錯(cuò)誤。表達(dá)式和語(yǔ)句都屬于C++/C的短于機(jī)構(gòu)語(yǔ)法。他們看似簡(jiǎn)單，但使用是隱患比較多。本節(jié)歸納了正確使用表達(dá)式和語(yǔ)句的一些規(guī)則與建議。

2.4.1運(yùn)算符的優(yōu)先級(jí)

? ? ? ? C++/C語(yǔ)言的運(yùn)算符有數(shù)十個(gè)，運(yùn)算符的優(yōu)先級(jí)與結(jié)合律如下表所示。注意一元運(yùn)算符 +、-、*的優(yōu)先級(jí)高于對(duì)應(yīng)的二元運(yùn)算符。?

• 規(guī)則1：如果代碼行中的運(yùn)算符比較多，用括號(hào)確定表達(dá)式的操作順序，避免使用默認(rèn)的操作順序。?

? ? ? ? 由于將上表熟記比較困難，為了防止產(chǎn)生歧義并提高可讀性，應(yīng)當(dāng)用括號(hào)確定表達(dá)式的操作順序。

例如：

word = (high << 8) | low

if((a | b) && (a & c))?

2.4.2復(fù)合表達(dá)式?

? ? ? ? 如a = b = c這樣的表達(dá)式稱為復(fù)合表達(dá)式。允許復(fù)合表達(dá)式存在的理由是：（1）書寫簡(jiǎn)潔；（2）可以提高編譯效率。但要防止濫用復(fù)合表達(dá)式。?

• 規(guī)則1：不要編寫太復(fù)雜的復(fù)合表達(dá)式。?

例如：i = a >= b && c < d && c + f <= g + h;//復(fù)合表達(dá)式過于復(fù)雜?

• 規(guī)則2：不要有多用途的復(fù)合表達(dá)式。?

例如：d = (a = b + c) + r;

該表達(dá)式即求a值又求d值。應(yīng)拆分為兩個(gè)獨(dú)立的語(yǔ)句：

? ? ? ? a = b + c;

? ? ? ? d = a + r;?

• 規(guī)則3：不要把程序中的復(fù)合表達(dá)式與“真正的數(shù)學(xué)表達(dá)式”混淆。?

例如：if(a < b < c)? ? ? ? //a < b < c是數(shù)學(xué)表達(dá)式而不是程序表達(dá)式?

? ? ? ? 并不表示

? ? ? ? if((a < b) && (b < c))

? ? ? ? 而是成了令人費(fèi)解的

? ? ? ? if((a < b) < c)?

2.4.3if語(yǔ)句?

? ? ? ? if語(yǔ)句是C++/C語(yǔ)言中最簡(jiǎn)單、最常用的語(yǔ)句，然而很多程序員用隱含錯(cuò)誤的方式寫if語(yǔ)句。本小節(jié)以“與零值比較”為例，展開討論。?

2.4.3.1布爾值與零值比較?

• 規(guī)則1：不可將布爾變量直接與TRUE、FALSE或1、0進(jìn)行比較。?

? ? ? ? 根據(jù)布爾類型的語(yǔ)義，零值為“假”（記為FALSE），任何非零值都是“真”（記為TRUE）。TRUE的值究竟是什么并沒有同一的標(biāo)準(zhǔn)。例如Visual C++將TRUE定義為1，而Visual Basic則將TRUE定義為-1。

?????????假設(shè)布爾變量名字為flag，它與零值比較的標(biāo)準(zhǔn)if語(yǔ)句如下：

????????if(flag)? ? ? ? //表示flag為真

? ? ? ? if(!flag)? ? ? ? //表示flag為假

其他用法都屬于不良風(fēng)格，例如：

? ? ? ? if(flag == TRUE)

? ? ? ? if(flag == 1)

? ? ? ? if(flag == FALSE)

? ? ? ? if(flag == 0)

2.4.3.2整形變量與零值的比較?

• 規(guī)則2：應(yīng)當(dāng)將整形變量用“==”或“!=”直接與0進(jìn)行比較。?

假設(shè)整形變量的名字為Value,它與零值比較的標(biāo)準(zhǔn)if語(yǔ)句如下：

? ? ? ? if(0 == value)

? ? ? ? if(0 != value)

不可模仿布爾變量的風(fēng)格而寫成

? ? ? ? if(value)? ? ? ? //會(huì)讓人誤解Value是布變量

? ? ? ? if(!value)?

2.4.3.3浮點(diǎn)變量與零值比較?

• 規(guī)則3：不可將浮點(diǎn)變量用“==”或“!=”與任何數(shù)字比較?

? ? ? ? 千萬(wàn)要留意，無(wú)論是float還是double類型的變量，都有進(jìn)度限制。所以一定要避免將浮點(diǎn)數(shù)變量用“==”或“!=”與數(shù)字比較，應(yīng)設(shè)法轉(zhuǎn)化成“>=”或“<=”形式。

假設(shè)浮點(diǎn)變量的名字為x，應(yīng)當(dāng)將

? ? ? ? if(x == 0.0)? ? ? ? //隱含錯(cuò)誤的比較

轉(zhuǎn)化為

? ? ? ? if((x >= -EPSINON) && (x <= EPSINON))

其中EPSINON是允許的誤差（即精度）。

2.4.3.4指針變量與零值的比較?

• 規(guī)則4：應(yīng)當(dāng)將指針變量用“==”或“!=”與NULL比較。?

? ? ? ? 指針變量的零值是“空”（記為NULL）。盡管NULL的值與0相同，但兩者的意義不同。假設(shè)指針變量的名字為p,它與零值的比較的表準(zhǔn)if語(yǔ)句如下：

? ? ? ? if(NULL == p)? ? ? ? //p與NULL現(xiàn)實(shí)比較，強(qiáng)調(diào)p是指針變量

? ? ? ? if(p != NULL)

不要寫成

? ? ? ? if(p == 0)? ? ? ? //容易讓人誤解p是整形變量

? ? ? ? if(p != 0)

或者

? ? ? ? if(p)? ? ? ? //容易讓人誤解p是布爾變量

? ? ? ? if（!p）

2.4.3.5對(duì)if語(yǔ)句的補(bǔ)充說明?

? ? ? ? 有時(shí)候我們可能會(huì)看到if(NULL == p)這樣古怪的形式，我上面就是這樣寫的。不是程序?qū)戝e(cuò)了，是程序員為了防止將if(p == NULL) 誤寫成if(p = NULL)，而有意把p和NULL顛倒。編譯器認(rèn)為if(p = NULL)是合法的，但是會(huì)指出if(NULL = p)是錯(cuò)誤的，因?yàn)镹ULL不能被賦值。

? ? ? ? 程序中有時(shí)會(huì)遇到if/else/return的組合，應(yīng)當(dāng)將如下不良風(fēng)格的程序

//不良的代碼行
if(condition)
    return x;
return y;

//良好的代碼風(fēng)格
if(condition)
{
    return x;
}
else
{
    return y;
}

//另外一種簡(jiǎn)單的風(fēng)格
return (condition ? x : y);

2.4.4循環(huán)語(yǔ)句的效率?

? ? ? ? C++/C循環(huán)語(yǔ)句中，for語(yǔ)句使用頻率最高，while語(yǔ)句其次，do語(yǔ)句很少用。本小節(jié)重點(diǎn)論述循環(huán)體的效率。提高循環(huán)體的效率的基本辦法是降低循環(huán)體的復(fù)雜性。?

????????建議1：在多重循環(huán)中，如果有可能，應(yīng)當(dāng)將最長(zhǎng)的循環(huán)放在最內(nèi)層，最短的循環(huán)放在最層，以減少CPU跨切循環(huán)層的次數(shù)。?

//低效率的循環(huán)體
for(row=0; row<100; row++)
{
    for(col=0; col<5; col++)
    {
        sum = sum + a[row][col];
    }
}

//高效率的循環(huán)體
for(col=0; col<5; col++)
{
    for(row=0; row<100; row++)
    {
        sum = sum + a[row][col];
    }
}

? ? ? ? 建議2：如果循環(huán)體內(nèi)存在邏輯判斷，并且循環(huán)次數(shù)很大，宜將邏輯判斷移到循環(huán)體的外面。?

? ? ? ? 如下所示，如果N非常小，兩者效率差別并不明顯，采用簡(jiǎn)潔的書寫比較方便。

//效率低但程序簡(jiǎn)潔
for(i=0; i<N; i++)
{
    if(condition)
    {
        Dosomething();
    }
    else
    {
        DoOtherthing();
    }
}

//效率高但程序不簡(jiǎn)潔
if(condition)
{
    for(i=0; i<N; i++)
    {
        DoSomething();
    }
}
else
{
    for(i=0; i<N; i++)
    {
        DoOtherthing();
    }
}

2.4.5for語(yǔ)句的循環(huán)控制變量?

• 規(guī)則1：不可再for循環(huán)體內(nèi)修改循環(huán)變量，防止for循環(huán)失去控制。?

? ? ? ? 建議1：建議for語(yǔ)句的循環(huán)控制變量的取值采用“半開半閉區(qū)間”寫法。?

? ? ? ? 示例1中的x值屬于半開半閉區(qū)間“0 =< x < N”,起點(diǎn)到終點(diǎn)的間隔為N,循環(huán)次數(shù)為N。

? ? ? ? 示例2中的x值屬于閉區(qū)間“0 =< x <= N-1”，起點(diǎn)到終點(diǎn)的間隔為N-1，循環(huán)次數(shù)為N。

? ? ? ? 相比之下，示例1的寫法更加直觀，盡管兩者的功能是相同的。

//示例1
for(int x=0; x<N; x++)
{
    ...
}

//示例2
for(int x=0; x <= N - 1; x++)
{
    ...
}

2.4.6switch語(yǔ)句?

? ? ? ? 有了if語(yǔ)句為什么還要Switch語(yǔ)句？

? ? ? ? switch是多分支選擇語(yǔ)句，而if語(yǔ)句只有兩個(gè)分支可供選擇。雖然可以用嵌套的if語(yǔ)句來(lái)實(shí)現(xiàn)多分支選擇，但那樣的程序冗長(zhǎng)難讀。這是switch語(yǔ)句存在的理由。

? ? ? ? switch語(yǔ)句的基本格式是：

? ? ? ? switch(variable)

????????{

? ? ? ? ? ? ? ? case value1:

? ? ? ? ? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? ? ? ? ? break;

? ? ? ? ? ? ? ? case value2:

? ? ? ? ? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? ? ? ? ? break;

? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? default:

? ? ? ? ? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? ? ? ? ? break;

????????}

• ?規(guī)則1：每個(gè)case語(yǔ)句的結(jié)尾不要忘記加break，否則將導(dǎo)致多個(gè)分支重疊（除非有意使多個(gè)分支重疊）。
• 規(guī)則2：不要忘記最后那個(gè)default分支。即使程序真的不需要default處理，也應(yīng)該保留語(yǔ)句default:break;這樣做并非多此一舉，而是為了防止別人誤以為你忘了default處理。

2.4.7goto語(yǔ)句?

? ? ? ? 自從提倡結(jié)構(gòu)化設(shè)計(jì)以來(lái)，goto就成了有爭(zhēng)議的語(yǔ)句。首先，由于goto語(yǔ)句可以靈活跳轉(zhuǎn)，如果不加限制，它的確會(huì)破壞結(jié)構(gòu)化設(shè)計(jì)的風(fēng)格。其次，goto語(yǔ)句經(jīng)常帶來(lái)錯(cuò)誤或隱患。它可能跳過了某些對(duì)象的構(gòu)造、變量的初始化、重要的計(jì)算語(yǔ)句等，例如：

goto state;

String s1, s2;? ? ? ? //被goto跳過

int num = 0;? ? ? ? ? //被goto跳過

...

state:

...

如果編譯器不能發(fā)覺此類錯(cuò)誤，每用一次goto語(yǔ)句都可能留下隱患。

? ? ? ? 很多人建議廢除C++/C的goto語(yǔ)句，以絕后患。但實(shí)事求是的說，錯(cuò)誤是程序員自己造成的，不是goto的過錯(cuò)。goto語(yǔ)句至少有一處可顯神通，它能從多重循環(huán)體咻地一下子跳到外面，用不著寫很多次的break語(yǔ)句，例如：

{

? ? ? ? ...

????????{

? ? ? ? ? ? ? ? ...

????????????????{

? ? ? ? ? ? ? ? ? ? ? ? goto error;

????????????????}? ? ? ??

????????}

}?

error:

...

? ? ? ? 就像樓房著火了，來(lái)不及從樓梯一級(jí)一級(jí)往下走，可從窗口跳出火坑。所以我們主張少用 、慎用goto語(yǔ)句，而不是禁用。?

2.5常量?

? ? ? ? ?常量是一種標(biāo)識(shí)符，它的值在運(yùn)行期間恒定不變。C語(yǔ)言用#define來(lái)定義常量（稱為宏常量）。C++語(yǔ)言除了用#define外還可以用const來(lái)定義常量（稱為const常量）。

2.5.1為什么需要常量?

? ? ? ? 如果不使用常量，直接在程序中填寫數(shù)字或字符串，將會(huì)有什么麻煩？?

（1）程序的可讀性（可理解性）變差。程序員自己會(huì)忘記哪些數(shù)字或字符串是什么意思，用戶則更加不知道它們從何來(lái)、表示什么。

（2）在程序的很多地方輸入同樣的數(shù)字或字符串，難保不發(fā)生書寫錯(cuò)誤。

（3）如果要修改數(shù)字或者字符串，則會(huì)在很多地方改動(dòng)，即麻煩又容易出錯(cuò)。

• 規(guī)則1：盡量使用含義 比較直觀的常量來(lái)表示那些將在程序中多次出現(xiàn)的數(shù)字或字符串。?

?例如：

? ? ? ? #define? ? ? ? ? ? ? ? MAX? ? ? ? 100? ? ? ? //C語(yǔ)言的宏常量

? ? ? ? const? ?int? ? ? ? ? ? ?MAX = 100;? ? ? ? ? //C++語(yǔ)言的const常量

? ? ? ? const? ?float? ? ? ? ? PI = 3.14159? ? ? ? //C++語(yǔ)言的const常量

2.5.2const與#define比較?

? ? ? ? C++語(yǔ)言可以用const來(lái)定義常量，也可以用#define來(lái)定義常量。但是前者比后者有更多的優(yōu)點(diǎn)：

（1）const常量有數(shù)據(jù)類型，而宏常量沒有數(shù)據(jù)類型。編譯器可以對(duì)前者進(jìn)行類型安全檢查。而對(duì)后者只進(jìn)行字符替換，沒有類型安全檢查，并且在字符替換可能會(huì)產(chǎn)生意料不到的錯(cuò)誤（邊際效應(yīng)）。

（2）有些集成化的調(diào)試工具可以對(duì)const常量進(jìn)行調(diào)試，但是不能對(duì)宏常量進(jìn)行調(diào)試。?

• 規(guī)則1：在C++程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。?

2.5.3常量定義規(guī)則?

• 規(guī)則1：需要對(duì)外部公開的常量放在頭文件中，不需要對(duì)外公開的常量放在定義文件頭部。為便于管理，可以把不同模塊的常量集中存放在一個(gè)公共的頭文件中。
• 規(guī)則2：如果某一些常量與其他常量密切相關(guān)，應(yīng)在定義中包含這種關(guān)系，而不應(yīng)該給出一些孤立的值。?

例如：

? ? ? ? const? ?float? ? RADIUS = 100;

? ? ? ? const? ?float? ? DIAMETER =??RADIUS * 2;

2.5.4類中的常量?

? ? ? ? 有時(shí)我們希望某些常量只存放在類中有效。由于#define定義的宏常量是全局的，不能達(dá)到目的，于是想當(dāng)然地覺得應(yīng)該用const修飾數(shù)據(jù)成員來(lái)實(shí)現(xiàn)。const數(shù)據(jù)成員的確是存在的，但其含義卻不是我們所期待的。const數(shù)據(jù)成員只在某個(gè)對(duì)象的生存期內(nèi)是常量，而對(duì)于整個(gè)類而言是可變的，因?yàn)轭惪梢詣?chuàng)建多個(gè)對(duì)象，不同的對(duì)象其const數(shù)據(jù)成員的值可以不同。

? ? ? ? 不能再類聲明中初始化const數(shù)據(jù)成員。以下用法是錯(cuò)誤的，因?yàn)轭惖膶?duì)象未被創(chuàng)建時(shí)，編譯器不知道SIZE的值是什么。

? ? ? ? class? A

? ? ? ? {

? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? const? int SIZE = 100;//錯(cuò)誤，企圖在類聲明中初始化const數(shù)據(jù)成員

? ? ? ? ? ? ? ? int? array[SIZE];? ? ? ? ?//錯(cuò)誤，未知的SIZE

????????}；

????????

? ? ? ? const數(shù)據(jù)成員的初始化只能在類的構(gòu)造函數(shù)的初始化列表中進(jìn)行，例如：

? ? ? ? class? A

????????{

? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? A(int size);? ? ? ? //構(gòu)造函數(shù)

? ? ? ? ? ? ? ? const? int? SIZE;

????????};

? ? ? ? A::A(int size) : SIZE(size)//構(gòu)造函數(shù)的初始化表

????????{

? ? ? ? ? ? ? ? ...

????????}

? ? ? ? A? ? ? a(100);? ? ? ? //對(duì)象a的SIZE值為100

? ? ? ? A? ? ? b(200);? ? ? ? //對(duì)象b的SIZE值為200

? ? ? ? 怎樣才能建立在整個(gè)類中都恒定的常量呢？別指望const數(shù)據(jù)成員了，應(yīng)該用類中的枚舉常量來(lái)實(shí)現(xiàn)。例如：

? ? ? ? class? ?A

????????{

? ? ? ? ? ? ? ? enum{SIZE1 = 100，SIZE2 = 200 };//枚舉常量

????????????????

? ? ? ? ? ? ? ? int? array[SIZE1];

? ? ? ? ? ? ? ? int? array[SIZE2];

????????} ;

? ? ? ? ?枚舉常量不會(huì)占用對(duì)象的存儲(chǔ)空間，它們?cè)诰幾g時(shí)被全部求值。枚舉常量的缺點(diǎn)是：它的隱含數(shù)據(jù)類型是整數(shù)，其最大值有限，且不能表示浮點(diǎn)數(shù)（如PI = 3.14159）。

2.6函數(shù)設(shè)計(jì)?

? ? ? ? 函數(shù)是C++/C程序的基本功能單元，其重要性不言而喻。函數(shù)設(shè)計(jì)的細(xì)微缺點(diǎn)很容易導(dǎo)致該函數(shù)被錯(cuò)用，所以光使函數(shù)的功能正確是不夠的。本小節(jié)重點(diǎn)論述函數(shù)的接口設(shè)計(jì)和內(nèi)部實(shí)現(xiàn)的一些規(guī)則。

? ? ? ? 函數(shù)接口的兩個(gè)要素是參數(shù)和返回值。C語(yǔ)言中，函數(shù)的參數(shù)和返回值的傳遞方式有兩種：值傳遞和指針傳遞。C++語(yǔ)言中多了引用傳遞。由于引用傳遞的性質(zhì)像指針傳遞，而使用方式卻像值傳遞，初學(xué)者常常迷惑不解，容易引起混亂，請(qǐng)先閱讀2.6.6節(jié)“引用和指針的比較”。

2.6.1參數(shù)的規(guī)則

• 規(guī)則1：參數(shù)的書寫要完善，不要貪圖省事只寫參數(shù)的類型而省略參數(shù)的名字。如果函數(shù)沒有參數(shù)?，則用void填充。例如：

//良好的風(fēng)格代碼
void SetValue(int nWidth, int nHeight);
//不良的風(fēng)格代碼
void SetValue(int , int);

//良好的風(fēng)格代碼
float GetValue(void);
//不良的風(fēng)格代碼
float GetValue();

• 規(guī)則2：參數(shù)命名要恰當(dāng)，順序要合理。?

? ? ? ? 例如編寫字符串拷貝函數(shù)StringCopy,它有兩個(gè)參數(shù)。如果把參數(shù)名字起為str1和str2，例如：

? ? ? ? void? StringCopy(char *str1, tinationchar *str2);?

? ? ? ? 那么我們很難搞清楚究竟是把str1拷貝到str2中，還是剛好倒過來(lái)。

? ? ? ? 可以把參數(shù)名字起的更有意義，如叫strSource和strDestination。這樣從名字上就可以看出應(yīng)該把strSource拷貝到strDestination。

? ? ? ? 還有一個(gè)問題，這兩個(gè)參數(shù)哪一個(gè)該在前哪一個(gè)該在后？參數(shù)的順序要遵循程序員的習(xí)慣。一般地，應(yīng)將目的參數(shù)放在前面，源參數(shù)放在后面。

? ? ? ? 如果將函數(shù)聲明為：

? ? ? ? void? StringCopy(char *strSource, char *strDestination);

? ? ? ? 別人在使用時(shí)可能會(huì)不假思索地寫成如下形式：

? ? ? ? char? str[20];

? ? ? ? StringCopy(str, "hello World");?//參數(shù)順序顛倒

• 規(guī)則3：如果參數(shù)是指針，且僅作輸入作用，則應(yīng)在類型前加const，以防止指針在函數(shù)體內(nèi)被任意修改。

例如：

? ? ? ? void? StringCopy(char *strDestination, const char *strSource);?

• 規(guī)則4：如果輸入?yún)?shù)以值傳遞的方式傳遞對(duì)象，則宜改為“const &”方式來(lái)傳遞，這樣可以省略去臨時(shí)對(duì)象的構(gòu)造和析構(gòu)過程，從而提高效率。?

????????建議1：避免函數(shù)有太多的參數(shù)，參數(shù)的個(gè)數(shù)盡量控制在5個(gè)以內(nèi)。如果參數(shù)太多，在使用時(shí)容易將參數(shù)類型或順序搞錯(cuò)。

? ? ? ? 建議2：盡量不要使用類型和數(shù)目不確定的參數(shù)。

? ? ? ? C標(biāo)準(zhǔn)庫(kù)函數(shù)printf是采用不確定參數(shù)的典型代表，其原型為：

? ? ? ? ? ? ? ? int? ?printf(const char *format[, argument]...);

? ? ? ? 這種風(fēng)格的函數(shù)在編譯時(shí)喪失了嚴(yán)格的類型安全檢查。

2.6.2返回值規(guī)則?

• 規(guī)則1：不要省略返回值的類型。

? ? ? ? 在C語(yǔ)言中，凡不加類型說明的函數(shù)，一律自動(dòng)按整形處理。這樣不會(huì)有什么好處，卻容易被誤解為void類型。

? ? ? ? C++語(yǔ)言有嚴(yán)格的類型安全檢查，不允許上述情況發(fā)生。由于C++程序可以調(diào)用C函數(shù)，為了避免混亂，規(guī)定任何C++/C函數(shù)都必須有類型。如果函數(shù)沒有返回值，那么應(yīng)該聲明為void類型。

• 規(guī)則2：函數(shù)名字與返回值類型在語(yǔ)義上不可沖突。?

? ? ? ? 違反這條規(guī)定的典型代表是C標(biāo)準(zhǔn)庫(kù)函數(shù)getchar。

? ? ? ? 例如：char? c;

? ? ? ? ? ? ? ? c = getchar();

? ? ? ? ? ? ? ? if(c == EOF)

? ? ? ? ? ? ? ? ...?

? ? ? ?按照getchar名字的意思，將變量c聲明為char類型是很自然的事情。但不幸的是getchar的確不是char類型，而是int類型，其原型如下：

? ? ? ? int? getchar(void);?

? ? ? ? 由于c是char類型，取值范圍是[-128, 127]，如果宏EOF的值在char的取值范圍之外，那么。if語(yǔ)句將總是失敗，這種“危險(xiǎn)”人們一般哪里能料得到！導(dǎo)致本例錯(cuò)誤的責(zé)任并不在用戶，是函數(shù)getchar誤導(dǎo)了使用者。?

• 規(guī)則 3：不要將正常值和錯(cuò)誤標(biāo)志混在一起返回。正常值用輸出參數(shù)獲取，而錯(cuò)誤標(biāo)志用return語(yǔ)句返回。

? ? ? ? 回顧上例，C標(biāo)準(zhǔn)庫(kù)函數(shù)的設(shè)計(jì)者為什么要將getchar聲明為令人迷糊的int類型呢？他會(huì)那么傻嗎?

? ? ? ? 在正常情況下，getchar的確返回單個(gè)字符。但如果getchar碰到文件結(jié)束標(biāo)志或發(fā)生讀錯(cuò)誤，它必須返回一個(gè)標(biāo)志EOF。為了區(qū)別于正常的字符，只好將EOF定義為負(fù)數(shù)（通常為-1）。因此函數(shù)getchar就成了int類型。

? ? ? ? 我們?cè)趯?shí)際工作中，經(jīng)常會(huì)碰到上述令人為難得問題。為了避免出現(xiàn)誤解，我們應(yīng)該將正常值和錯(cuò)誤標(biāo)志分開。即：正常值用輸出參數(shù)獲得，而錯(cuò)誤標(biāo)志用return語(yǔ)句返回。

? ? ? ? 函數(shù)getchar可以改寫成?BOOL GetChar(char *c);

? ? ? ? 雖然getchar比GetChar靈活，例如putchar(getchar());但是如果getchar用錯(cuò)了，它的靈活性又有什么用呢？

????????建議1：有時(shí)候函數(shù)原本不需要返回值，但為了增加靈活性如支持鏈?zhǔn)奖磉_(dá)式，可以附加返回值。

? ? ? ? 例如字符串拷貝函數(shù)strcpy的原型：

? ? ? ????????? char *strcpy(char *strDest, char *strSrc);

? ? ? ? strcpy函數(shù)將strSrc拷貝至輸出參數(shù)strDest中，同時(shí)函數(shù)的返回值又是strDest。這樣做并非多此一舉，可以獲得如下靈活性：

? ? ? ? char? ?str[20];

? ? ? ? int? ?lenth = strlen(strcpy(str, "hello world"));

? ? ? ? 建議2：如果函數(shù)的返回值是一個(gè)對(duì)象，有些場(chǎng)合用“引用傳遞”替換“值傳遞”可以提高效率。而有些場(chǎng)合只能用“值傳遞”而不能用“引用傳遞”，否則會(huì)出錯(cuò)。?

? ? ? ? 例如：

? ? ? ? class? String

????????{

? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? //賦值函數(shù)

? ? ? ? ? ? ? ? String & operate=(const String &other);

? ? ? ? ? ? ? ? //相加函數(shù)，如果沒有fried修飾則只允許有一個(gè)右側(cè)參數(shù)

? ? ? ? ? ? ? ? fried? String? ?operate+(const String &s1, const String &s2);

? ? ? ? private:

? ? ? ? ? ? ? ? char *m_pData;

????????}?

????????

? ? ? ? String的賦值函數(shù)operate=的實(shí)現(xiàn)如下：

? ? ? ? String & String::operate=(const String &other)

????????{

? ? ? ? ? ? ? ? if(this == &other)

? ? ? ? ? ? ? ? {

? ? ? ? ? ? ? ? ? ? ? ? return *this;

????????????????}

????????????????

? ? ? ? ? ? ? ? delete m_pData;

? ? ? ? ? ? ? ? m_pData = new char[strlen(other.data) + 1];

? ? ? ? ? ? ? ? strcpy(m_pData, other.data);

? ? ? ? ? ? ? ? return *this;? ? ? ? //返回的是*this的引用，無(wú)需拷貝過程

????????}

? ? ? ? 對(duì)于賦值函數(shù)，應(yīng)當(dāng)用“引用傳遞”的方式返回String對(duì)象。如果用“值傳遞”的方式，雖然功能任然正確，但由于return語(yǔ)句要把*this拷貝到保存返回值的外部存儲(chǔ)單元之中，增加了不必要的開銷，降低了函數(shù)賦值的效率。例如：

? ? ? ? String? ?a, b, c;

? ? ? ? ...

? ? ? ? a = b;? ? ? ? ? ? ? ? //如果用“值傳遞”，將產(chǎn)生一次*this拷貝

? ? ? ? a = b = c;? ? ? ? ? //如果用“值傳遞”，將產(chǎn)生兩次*this拷貝

????????

? ? ? ? String的相加函數(shù)operate+的實(shí)現(xiàn)如下：

? ? ? ? String operate+(const String &s1, const String &s2)

????????{

? ? ? ? ? ? ? ? String strTemp;

? ? ? ? ? ? ? ? delete strTemp.data;//strTemp.data是僅包含‘\0’的字符串

? ? ? ? ? ? ? ? strTemp.data = new char[strlen(s1.data) + strlen(s2.data) + 1];

? ? ? ? ? ? ? ? strcpy(strTemp.data, s1.data);

? ? ? ? ? ? ? ? strcat(strTemp.data, s2.data);

? ? ? ? ? ? ? ? return strTemp;

????????}

? ? ? ? 對(duì)于相加函數(shù)，應(yīng)當(dāng)用“值傳遞”的方式返回String對(duì)象。如果改用“引用傳遞”，那么函數(shù)返回值是一個(gè)指向局部對(duì)象strTemp的“引用”。由于strTemp在函數(shù)結(jié)構(gòu)體時(shí)被自動(dòng)銷毀，將導(dǎo)致返回的“引用”無(wú)效。例如：

? ? ? ? c = a + b;

此時(shí)a+b并不是返回期待值，c什么也得不到，留下了隱患。?

2.6.3函數(shù)內(nèi)部實(shí)現(xiàn)的規(guī)則?

? ? ? ? 不同功能的函數(shù)其內(nèi)部實(shí)現(xiàn)各不相同，看起來(lái)似乎無(wú)法就“內(nèi)部實(shí)現(xiàn)”達(dá)成一致的觀點(diǎn)。但根據(jù)經(jīng)驗(yàn)，我們可以在函數(shù)體的“入口處”和“出口處”從嚴(yán)把關(guān)，從而提高函數(shù)的質(zhì)量?。

• 規(guī)則1：在函數(shù)體的“入口處”，對(duì)參數(shù)的有效性進(jìn)行檢查。

? ? ? ? 很多程序錯(cuò)誤是由非法參數(shù)引起的，我們應(yīng)該充分理解并正確使用“斷言”（assert）來(lái)防止此類錯(cuò)誤。詳見2.6.5節(jié)“使用斷言”。?

• 規(guī)則2：在函數(shù)體的“出口處”，對(duì)return語(yǔ)句的正確性和效率進(jìn)行檢查。?

? ? ? ? 如果函數(shù)有返回值，那么函數(shù)的“出口處”是return語(yǔ)句。我們不要輕視r(shí)eturn語(yǔ)句，如果return語(yǔ)句寫的不好，函數(shù)要么出錯(cuò)，要么效率低下。

? ? ? ? 注意事項(xiàng)如下：

? ? ? ? （1）return語(yǔ)句不可返回指向“棧內(nèi)存”的“指針”或者“引用”，因?yàn)樵搩?nèi)存在函數(shù)體結(jié)束時(shí)被自動(dòng)銷毀。例如：

? ? ? ? char? * Func(void)

? ? ? ? {

? ? ? ? ? ? ? ? char str[] = "hello world";? //str的內(nèi)存位于棧上

? ? ? ? ? ? ? ? ...

? ? ? ? ? ? ? ? return str;? ? ? ? //將導(dǎo)致錯(cuò)誤

????????}?

? ? ? ? （2）要搞清楚返回的究竟是“值”、“指針”還是“引用”。

? ? ? ? （3）如果函數(shù)返回值是一個(gè)對(duì)象，要考慮return語(yǔ)句的效率。例如：

? ? ? ? ? ? ? ? return String（str1 + str2);?

? ? ? ? ? ? ? ? 這是臨時(shí)對(duì)象的語(yǔ)法，表示“創(chuàng)建一個(gè)臨時(shí)對(duì)象并返回它”。不要以為它與“先創(chuàng)建一個(gè)局部對(duì)象Temp并返回它的結(jié)果”是等價(jià)的，如

? ? ? ? ? ? ? ? String temp(s1 + s2);

? ? ? ? ? ? ? ? return? temp;

? ? ? ? ? ? ? ? 實(shí)質(zhì)不然，上述代碼將發(fā)生三件事。首先，temp對(duì)象被創(chuàng)建，同時(shí)完成初始化；然后拷貝構(gòu)造函數(shù)把temp拷貝到保存返回值的外部存儲(chǔ)單元中；最后，temp在函數(shù)結(jié)束時(shí)被銷毀（調(diào)用析構(gòu)函數(shù)）。然而“創(chuàng)建一個(gè)臨時(shí)對(duì)象并返回它”的過程是不同的，編譯器直接把臨時(shí)對(duì)象創(chuàng)建并初始化在外部存儲(chǔ)單元，省去了拷貝和析構(gòu)的花費(fèi)，提高了效率。

? ? ? ? 類似地，我們不要將

? ? ? ? ? ? ? ? return int(x + y);? ? ? ? //創(chuàng)建一個(gè)臨時(shí)變量并返回它

? ? ? ? 寫成

? ? ? ? ? ? ? ? int temp = x + y;

? ? ? ? ? ? ? ? return temp;

? ? ? ? 由于內(nèi)部數(shù)據(jù)類型如int，float, double的變量不存在構(gòu)造函數(shù)和析構(gòu)函數(shù)，雖然該“臨時(shí)變量的語(yǔ)法”不會(huì)提高多少效率，但是程序更加簡(jiǎn)易讀。

2.6.4其它建議

????????建議1：函數(shù)的功能要單一，不要設(shè)計(jì)度用途的函數(shù)；

? ? ? ? 建議2：函數(shù)體的規(guī)模要小，盡量控制在150行代碼以內(nèi)；

? ? ? ? 建議3：盡量避免函數(shù)帶有“記憶”功能。相同的輸入應(yīng)當(dāng)產(chǎn)生相同的輸出；?

? ? ? ? 帶有“記憶”功能的函數(shù)，其行為是不可預(yù)測(cè)的，因?yàn)樗男袨榭赡苋Q于某種“記憶狀態(tài)”。這樣的函數(shù)即不易理解又不利于測(cè)試和維護(hù)。在C/C++語(yǔ)言中，函數(shù)的static局部變量是函數(shù)的“記憶存儲(chǔ)器”。建議盡量少用static局部變量，除非必須。

? ? ? ? 建議4：不僅要檢查輸入?yún)?shù)的有效性，還要檢查通過其它途徑進(jìn)入函數(shù)體內(nèi)的變量的有效性，例如全局變量、文件句柄等。

? ? ? ? 建議5：用于出錯(cuò)處理的返回值一定要清楚，然使用者不容易忽視或誤解錯(cuò)誤情況。?

2.6.5使用斷言?

? ? ? ? 程序一般分為Debug版本和Release版本，Debug版本用于內(nèi)部調(diào)試，Release版本發(fā)行給用戶使用。

? ? ? ? 斷言assert是僅在Debug版本起作用的宏，它用于檢查“不應(yīng)該”發(fā)生的情況。如下例所示是一個(gè)內(nèi)存賦值函數(shù)。在運(yùn)行過程中，如果assert的參數(shù)為假，那么程序就會(huì)終止（一般地還會(huì)出現(xiàn)提示對(duì)話框，說明在什么地方引發(fā)了assert）。

void  *memcpy(void *pvTo, const void *pvFrom, size_t size)
{
    assert((pvTo != NULL) && (pvFrom != NULL));    //使用斷言
    byte  *pbTo = (byte *)pvTo;    //防止改變pvTo的地址
    byte  *pbFrom = (byte  *)pvFrom    //防止改變pvFrom的地址
    while(size-- > 0)
    {
        *pbTo++ == *pbFrom++;
    }

    return pvTo;
}

? ? ? ? assert不是一個(gè)倉(cāng)促拼湊起來(lái)的宏。為了不再程序的Debug版本和Release版本引起差別，assert不應(yīng)該產(chǎn)生任何副作用。所以assert不是函數(shù)，而是宏。程序員可以把a(bǔ)ssert看成在任何系統(tǒng)狀態(tài)下都可以安全使用的無(wú)害測(cè)試手段。如果程序在assert處終止了，并不是說明含有該assert的函數(shù)有錯(cuò)誤而是調(diào)用者出了差錯(cuò)，assert可以幫助我們找到發(fā)生錯(cuò)誤的原因。?

• 規(guī)則1：使用斷言捕捉不應(yīng)該發(fā)生的非法情況。不要混淆非法情況與錯(cuò)誤情況之間的區(qū)別，后者是必然 存在的并且是一定要做出處理的。
• 規(guī)則2：在函數(shù)的入口處，使用斷言檢查參數(shù)的有效性（合法性）。?

????????建議1：在編寫函數(shù)時(shí)，要進(jìn)行反復(fù)的考查，并且自問：“我打算做哪些假定？”一旦確定了的假定，就要使用斷言對(duì)假定進(jìn)行檢查。

? ? ? ? 建議2：一般教科書都鼓勵(lì)程序員們進(jìn)行放錯(cuò)設(shè)計(jì)，但要記住這種編程風(fēng)格可能會(huì)隱瞞錯(cuò)誤。當(dāng)進(jìn)行放錯(cuò)設(shè)計(jì)時(shí)，如果“不可能發(fā)生”的事情的確發(fā)生了，則要使用斷言進(jìn)行報(bào)警。?

2.6.6應(yīng)用與指針的比較?

? ? ? ? 引用是C++中的概念，初學(xué)者容易把引用和指針混淆一起。下面程序中，n是m的一個(gè)引用，m是被引用物。

? ? ? ? int? ?m;

? ? ? ? int? &n = m;?

? ? ? ? n相當(dāng)于m的別名（綽號(hào)）,對(duì)n的任何操作就是對(duì)m的操作。例如有人名叫王小毛，他的綽號(hào)是“三毛”。說“三毛”怎么怎么的，其實(shí)就是對(duì)王小毛說三到四。所以n即不是m的拷貝，也不是指向m的指針，其實(shí)n就是m她自己。

? ? ? ? 引用的一些規(guī)則如下：

（1）引用被創(chuàng)建的同時(shí)必須被初始化（指針則可以再任何時(shí)候被初始化）；

（2）不能有NULL引用，引用必須與合法的存儲(chǔ)單元關(guān)聯(lián) （指針則可以是NULL）;

（3）一旦引被初始化，就不能改變引用的關(guān)系（指針可以隨時(shí)改變所指向的對(duì)象）?。

? ? ? ? 以下示例程序中，k被初始化為i的引用。語(yǔ)句k = j并不能將k修改成為j的引用，只是把k的值改變成為6。由于k是i的引用，所以i的值也變成了6。

? ? ? ? int i = 5;

? ? ? ? int j = 6;

? ? ? ? int &k = i;

? ? ? ? k = j;? ? ? ? //k和i的值都變成了6

上面程序看起來(lái)像在玩文字游戲，沒有體現(xiàn)出引用的價(jià)值。引用的主要功能是傳遞函數(shù)的參數(shù)和返回值。C++語(yǔ)言中，函數(shù)的參數(shù)和返回值的傳遞方式有三種：值傳遞、指針傳遞和引用傳遞。

? ? ? ? 以下是“值傳遞”的示例程序。由于Func1函數(shù)體的x是外部變量n的一份拷貝，改變x的值不會(huì)影響n,所以n的值仍然是0。

? ? ? ? void? Func1(int x)

? ? ? ? {

? ? ? ? ? ? ? ? x = x + 10

????????}?

? ? ? ? ...

????????

? ? ? ? int n = 0;

? ? ? ? Func1(n);

? ? ? ? cout << "n=? ?" << n << endl;//n = 0

? ? ? ? 以下是“指針傳遞”的示例程序。由于Func2函數(shù)體的x是指向外部變量n的指針，改變?cè)撝羔樀膬?nèi)容將導(dǎo)致n的值改變，所以n的值成了10。

? ? ? ? void Func(int *x)

? ? ? ? {

? ? ? ? ? ? ? ? (*x) = (*x) + 10;

????????}?

? ? ? ? ...

????????

? ? ? ? int n = 0;

? ? ? ? Func2(&n);

? ? ? ? cout << "n=? " << n << endl;//n = 10

? ? ? ? 以下是“引用傳遞”的示例程序。由于Func3函數(shù)體的x是外部變量n的引用，x和n是同一個(gè)東西，改變x等于改變n,所以n的值成為了10。

? ? ? ? void? Func3(int &x)

? ? ? ? {

? ? ? ? ? ? ? ? x = x + 10;

????????}?

? ? ? ? ...

????????

? ? ? ? int n = 0;

? ? ? ? Func3(n);

? ? ? ? cout << "n=? " << n << endl;//n = 10;

? ? ? ? 對(duì)比上述三個(gè)示例程序，會(huì)發(fā)現(xiàn)“引用傳遞”的性質(zhì)像“指針傳遞”，而書寫方式像“值傳遞”。實(shí)際上“引用”可以做的任何事情“指針”也能夠做，為什么還要“引用”這東西？

? ? ? ? 答案是“用適當(dāng)?shù)墓ぞ咦銮∪缙浞值墓ぷ鳌薄?/p>

? ? ? ? 指針能夠毫無(wú)約束的操作內(nèi)存中的任何東西，盡管指針功能強(qiáng)大，但是非常危險(xiǎn)。就像一把刀，它可以用來(lái)砍樹、裁紙、修指甲、理發(fā)等，誰(shuí)敢這樣用？

? ? ? ? 如果的確只需要借用一下某個(gè)對(duì)象的“別名”，那么就用“引用”，而不是要用“指針”，以免發(fā)生意外。比如說，某人需要一份證明，本來(lái)在文件上 蓋上公章的印子就行了，如果把取公章的鑰匙交給他，那么他就獲得了不該有的權(quán)利。??

2.7內(nèi)存管理?

? ? ? ? 歡迎進(jìn)入內(nèi)存這片雷區(qū)。程序員們經(jīng)常編寫內(nèi)存管理程序，往往提心吊膽。如果不想觸雷，唯一的解決辦法就是發(fā)現(xiàn)所有潛伏的地雷并且排除它們，躲是躲不了的。本小節(jié)的內(nèi)容比一般教科書要深入的多，讀者需細(xì)心閱讀，做到真正地通曉內(nèi)存管理。

2.7.1內(nèi)存分配方式?

? ? ? ? 內(nèi)存分配方式有三種：

（1）從靜態(tài)存儲(chǔ)區(qū)域分配。內(nèi)存在程序編譯的時(shí)候就已經(jīng)分配好了，這塊內(nèi)存在程序的整個(gè)運(yùn)行期間都 存在。例如全局變量、static變量；

（2）在棧上創(chuàng)建。在執(zhí)行函數(shù)時(shí)，函數(shù)內(nèi)局部變量的存儲(chǔ)單元都可以在棧上創(chuàng)建，函數(shù)執(zhí)行結(jié)束時(shí)這些存儲(chǔ)單元自動(dòng)釋放。棧內(nèi)存分配運(yùn)算內(nèi)置于處理器的指令集中，效率很高，但是分配的內(nèi)存容量有限；

（3）從堆上分配，亦稱動(dòng)態(tài)內(nèi)存分配。程序在運(yùn)行的時(shí)候用malloc或new申請(qǐng)任意多少的內(nèi)存，程序員自己負(fù)責(zé)在何時(shí)用free或delete釋放內(nèi)存。動(dòng)態(tài)內(nèi)存的生存期由我們決定，使用非常靈活 ，但問題也最多。?

2.7.2常見的內(nèi)存錯(cuò)誤及其對(duì)策?

? ? ? ? 發(fā)生內(nèi)存錯(cuò)誤是件非常麻煩的事。編譯器不能自動(dòng)發(fā)現(xiàn)這些錯(cuò)誤，通常是在程序運(yùn)行時(shí)才能捕捉到。而這些錯(cuò)誤大多沒有明顯的癥狀，時(shí)隱時(shí)現(xiàn)，增加了改錯(cuò)的難度。有時(shí)候用戶怒氣沖沖地把你找來(lái)，程序卻沒有發(fā)生任何問題，你一走，錯(cuò)誤又發(fā)作了。

? ? ? ? 常見的內(nèi)存錯(cuò)誤及其對(duì)策如下：

• 內(nèi)存分配未成功，卻使用了它。?

? ? ? ? 編程新手常犯這種錯(cuò)誤，因?yàn)樗麄?沒有意識(shí)到內(nèi)存分配會(huì)不成功。常用解決辦法是，在使用內(nèi)存之前檢查指針是否為NULL。如果指針p是函數(shù)的參數(shù)，那么在函數(shù)的入口處用assert(p != NULL)進(jìn)行檢查。如果是用malloc或new來(lái)申請(qǐng)內(nèi)存，應(yīng)該用if(p == NULL)或if(p != NULL)來(lái)進(jìn)行防錯(cuò)處理。

• ?內(nèi)存分配雖然成功，但是尚未初始化就引用它。

? ? ? ? 犯這種錯(cuò)誤的主要有兩個(gè)原因：一是沒有初始化的觀念；二是誤以為內(nèi)存的缺省初值全為零，導(dǎo)致引用初值錯(cuò)誤（例如數(shù)組）。

? ? ? ? 內(nèi)存的缺省初值究竟是什么并沒有統(tǒng)一的標(biāo)準(zhǔn)，盡管有些時(shí)候?yàn)榱阒?，我們寧可信其無(wú)不可信其有。所有不論用何種方式創(chuàng)建數(shù)組，別忘了賦初值，即便是賦靈芝也不可省略， 不要嫌麻煩。

• 內(nèi)存分配成功并且已經(jīng)初始化，但是操作越過了內(nèi)存邊界。?

? ? ? ? 例如在使用數(shù)組時(shí)經(jīng)常發(fā)生下標(biāo)“多1”或者“少1”的操作。特別是在for循環(huán)語(yǔ)句中，循環(huán)次數(shù)很容易搞錯(cuò)，導(dǎo)致數(shù)組操作越界。?

• 忘記了釋放內(nèi)存，造成內(nèi)存泄漏

? ? ? ? 含有這種錯(cuò)誤的函數(shù)每被調(diào)一次就丟失一塊內(nèi)存。剛開始系統(tǒng)的內(nèi)存充足，你看不到錯(cuò)誤。終有一次程序突然死掉，系統(tǒng)出現(xiàn)提示：內(nèi)存耗盡。

? ? ? ? 動(dòng)態(tài)內(nèi)存的申請(qǐng)與釋放必須配隊(duì)，程序中malloc與free的使用次數(shù)一定要相同，否則肯定有錯(cuò)誤（new/delete同理）。

• 釋放了內(nèi)存卻繼續(xù)使用它

? ? ? ? 有三種情況：

? ? ? ? （1）程序中的調(diào)用關(guān)系過于復(fù)雜，是在難以搞清楚某個(gè)對(duì)象是否已經(jīng)被釋放了內(nèi)存，此時(shí)應(yīng)該寵幸設(shè)計(jì)數(shù)據(jù)結(jié)構(gòu)，從根本上解決對(duì)象管理的混亂局面。

? ? ? ? （2）函數(shù)的return語(yǔ)句寫錯(cuò)了，注意不要返回指向“棧內(nèi)存”的“指針”或者“引用”，因?yàn)樵搩?nèi)存在函數(shù)體結(jié)束時(shí)被自動(dòng)銷毀。

? ? ? ? （3）使用free或delete釋放了內(nèi)存后，沒有將指針設(shè)置為NULL。導(dǎo)致產(chǎn)生“野指針”。

• 規(guī)則1：用malloc或new申請(qǐng)內(nèi)存之后，應(yīng)該立即檢查指針值是否為NULL。防止使用指針值為NULL的內(nèi)存。
• 規(guī)則2：不要忘記為數(shù)組和動(dòng)態(tài)內(nèi)存賦初值。防止將未被初始化的內(nèi)存作為右值使用。
• 規(guī)則3：避免數(shù)組或指針的下標(biāo)越界，特別要當(dāng)心發(fā)生“多1”或者“少1”操作。
• 規(guī)則4：動(dòng)態(tài)內(nèi)存的申請(qǐng)與釋放必須配對(duì)，防止內(nèi)存泄漏。
• 規(guī)則5：用free或delete釋放內(nèi)存之后，立即將指針設(shè)置為NULL，防止產(chǎn)生“野指針”。?

2.7.3指針與數(shù)組的對(duì)比?

? ? ?? ?C++/C程序中，指針和數(shù)組在不少地方可以相互替換著使用，讓人產(chǎn)生一種錯(cuò)覺，以為兩者是等價(jià)的。

? ? ? ? 數(shù)組要么在靜態(tài)存儲(chǔ)區(qū)被創(chuàng)建（如全局?jǐn)?shù)組），要么在棧上被創(chuàng)建。數(shù)組名對(duì)應(yīng)著（而不是指向）一塊內(nèi)存，其地址與容量在生命周期內(nèi)保持不變，只有數(shù)組的內(nèi)容可以改變。

? ? ? ? 指針可以隨意指向任意類型的內(nèi)存塊，它的特征是“可變”，所以我們常用指針來(lái)操作動(dòng)態(tài)內(nèi)存?。指針遠(yuǎn)比數(shù)組靈活，但也更危險(xiǎn)。

? ? ? ? 下面以字符串為例比較指針與數(shù)組的特性。

2.7.3.1修改內(nèi)容

? ? ? ? 示例1中，字符數(shù)組a的容量是6個(gè)字符，其內(nèi)容為hello\0。a的內(nèi)容可以改變，如a[0] = 'X'。指針p指向常量字符串“world”(位于靜態(tài)存儲(chǔ)區(qū)，內(nèi)容為world\0)，常量字符串的內(nèi)容是不可以被修改的。從語(yǔ)法上看，編譯器并不覺得語(yǔ)句p[0] = 'X'有什么不妥，但是該語(yǔ)句企圖修改常量字符串的內(nèi)容導(dǎo)致運(yùn)行錯(cuò)誤。

//示例1
char a[] = "hello";
a[0] = 'X';
cout << a << endl;

char *p = "world";    //注意p指向的是常量字符串
p[0] = 'X';           //編譯器不能發(fā)現(xiàn)該錯(cuò)誤
cout << p << endl;

2.7.3.2內(nèi)容賦值與對(duì)比?

? ? ? ? 不能對(duì)數(shù)組名進(jìn)行直接復(fù)制與比較。示例2中，若想把數(shù)組a的內(nèi)容賦值給數(shù)組b，不能用語(yǔ)句 b = a，否則將產(chǎn)生編譯錯(cuò)誤。應(yīng)該用標(biāo)準(zhǔn)庫(kù)函數(shù)strcpy進(jìn)行復(fù)制。同理，比較b和a的內(nèi)容是否相同，不能用if(b == a)來(lái)判斷，應(yīng)該用標(biāo)準(zhǔn)庫(kù)函數(shù)strcmp進(jìn)行比較。

? ? ? ? 語(yǔ)句p = a并不能把a(bǔ)的內(nèi)容復(fù)制指針p，而是把a(bǔ)的地址賦給了p。想要復(fù)制a的內(nèi)容，可以先用庫(kù)函數(shù)malloc為p申請(qǐng)一塊容量為strlen(a) + 1?個(gè)字符的內(nèi)存，在用strcpy進(jìn)行字符串復(fù)制。同理，語(yǔ)句if(p == a)比較的不是內(nèi)存而是地址，應(yīng)該用庫(kù)函數(shù)strcmp來(lái)比較。

//數(shù)組...
char a[] = "hello";
char b[10];
strcpy(b, a);    //不能使用b = a;
if(strcmp(b, a) == 0)    //不能用if(b == a)
{
    ...
}

//指針...
int len = strlen(a);
char *p = (char *)malloc(sizeof(char) * (len + 1));
strcpy(p, a);        //不要用 p = a;
if(strcmp(p, a) == 0)    //不要用if(p == a)
{
    ...
}

2.7.3.3計(jì)算內(nèi)存容量?

? ? ? ? 用運(yùn)算符sizeof可以計(jì)算數(shù)組的容量（字節(jié)數(shù)）。示例3a中，sizeof(a)的值是12（注意別忘了‘\0’）。指針p指向a，但是sizeof(p)的值卻是4。這是因?yàn)閟izeof(p)得到的是一個(gè)指針變量的字節(jié)數(shù)，相當(dāng)于sizeof(char *)，而不是p所指的內(nèi)存容量。C++/C語(yǔ)言沒有辦法知道指針?biāo)傅膬?nèi)存容量，除非在申請(qǐng)內(nèi)存時(shí)記住它。?

? ? ? ? 注意當(dāng)數(shù)組作為函數(shù)的參數(shù)進(jìn)行傳遞時(shí)，該數(shù)組自動(dòng)退化為同類型的指針。示例3b中，不論數(shù)組a的容量是多少，sizeo(a)始終等于sizeof(char *)。

//示例3a
//計(jì)算數(shù)組和指針的內(nèi)存容量
char a[] = "hello world";
char *p = a;
cout << sizeof(a) << endl;     //12字節(jié)
cout << sizeof(p) << endl;     //4字節(jié)

//示例3b
//數(shù)組退化為指針
void Func(char a[100])
{
    cout << sizeof(a) << endl;    //4字節(jié)而不是100字節(jié)
}

2.7.4指針參數(shù)是如何傳遞內(nèi)存的？?

? ? ? ? 如果函數(shù)的參數(shù)是一個(gè)指針，不要指望用該指針去申請(qǐng)動(dòng)態(tài)內(nèi)存。示例4中，Test函數(shù)的語(yǔ)句GetMemory(str, 200)并沒有使str獲得期望的內(nèi)存，str依舊是NULL，為什么？

void GetMemory(char *p, int num)
{
    p = (char *)malloc(sizeof(char) * num);
}

void Test(void)
{
    char *str = NULL;
    GetMemory(str, 100);    //str仍然為NULL
    strcpy(str, "hello");   //運(yùn)行錯(cuò)誤
}

? ? ? ? 毛病出在函數(shù)GetMemory中。編譯器總是要為函數(shù)的每個(gè)參數(shù)制作臨時(shí)副本，指針參數(shù)p的副本是_p，編譯器使_p = p。如果函數(shù)體內(nèi)的程序修改了_p的內(nèi)容 ，就導(dǎo)致參數(shù)p的內(nèi)容做相應(yīng)的修改。這就是指針可以用作輸出參數(shù)的原因。在本例中，_p申請(qǐng)了新的內(nèi)存，只是把_p所指的內(nèi)存地址改變了，但是p絲毫未變。所以函數(shù)GetMemory并不能輸出任何東西。事實(shí)上，每執(zhí)行一次GetMemory就會(huì)泄漏一塊內(nèi)存，因?yàn)闆]有用free釋放內(nèi)存。

? ? ? ? 如果非得要用指針參數(shù)去申請(qǐng)內(nèi)存，那么應(yīng)該改用“指向指針的指針”，見下例。

void GetMemory2(char **p, int num)
{
    *p = (char *)malloc(sizeof(char) *num);
}

void Test2(void)
{
    char *str = NULL;
    GetMemory2(&str, 100);    //注意參數(shù)是&str, 而不是str
    strcpy(str, "hello");
    cout << str << endl;
    free(str);
}

? ? ? ? 由于“指向指針的指針”這個(gè)概念不容易理解，我們可以用函數(shù)的返回值來(lái)傳遞動(dòng)態(tài)內(nèi)存。這種方法更加簡(jiǎn)單，見下例。

void *GetMemory3(int num)
{
    char *p = (char *)malloc(sizeof(char) *num);
    return p;
}

void Test3(void)
{
    char *str = NULL;
    str = GetMemory3(100);
    strcpy(str, "hello");
    cout << str << endl;
    free(str);
}

? ? ? ? 用函數(shù)返回值來(lái)傳遞內(nèi)存這種方法雖然好用，但是常常有人把return語(yǔ)句用錯(cuò)了。這里強(qiáng)調(diào)不要用return語(yǔ)句返回指向“棧內(nèi)存”的指針，因?yàn)樵搩?nèi)存存在函數(shù)結(jié)束時(shí)自動(dòng)消亡。見下例。

char *GetString(void)
{
    char p[] = "hello world";
    return p;    //編譯器將提出警告
}

void Test4(void)
{
    char *str = NULL;
    str = GetMemory();    //str的內(nèi)容是垃圾
    cout << str << endl;
}

? ? ? ? 用調(diào)試器逐步跟蹤Test4，發(fā)現(xiàn)執(zhí)行str = GetString語(yǔ)句后str不再是NULL指針，但是str的內(nèi)容不是“hello world”而是垃圾。

? ? ? ? 如果把示例4寫成示例5，會(huì)怎么樣？

char *GetString2(void)
{
    char *p = "hello world";
    return p;
}

void Test5(void)
{
    char *str = NULL;
    str = GetString2();
    cout << str << endl;
}

? ? ? ? 函數(shù)Test5運(yùn)行雖然不會(huì)出錯(cuò)，但是函數(shù)GetMemory2的設(shè)計(jì)概念卻是錯(cuò)誤的。因?yàn)镚etString2內(nèi)的“hello world”?是常量字符串，位于靜態(tài)存儲(chǔ)區(qū)，它在程序生命期內(nèi)恒定不變。無(wú)論什么時(shí)候調(diào)用GetString2,它返回的始終是一個(gè)“只讀”的內(nèi)存塊。

2.7.5free和delete把指針怎么啦？

? ? ? ? 別看free和delete的名字惡狠狠的（尤其是delete），他們只是把指針?biāo)赶虻膬?nèi)存給釋放掉了，但并沒有把指針本身干掉。

? ? ? ? 用調(diào)試器跟蹤示例5，發(fā)現(xiàn)指針p被free以后其地址仍然不變（非NULL），只是改地址對(duì)應(yīng)的內(nèi)存是垃圾，p成了“野指針”。如果此時(shí)不把p設(shè)置為NULL,會(huì)讓人誤會(huì)以為p是個(gè)合法指針。

? ? ? ? 如果程序比較長(zhǎng)，我們有時(shí)記不住p所指的內(nèi)存是否已經(jīng)被釋放了，再繼續(xù)使用p之前，通常會(huì)用語(yǔ)句if(p != NULL)進(jìn)行放錯(cuò)處理。很遺憾，此時(shí)if語(yǔ)句起不到防錯(cuò)作用，因?yàn)榧词筽不是NULL指針，它也不指向合法的內(nèi)存塊。

char *p = (char *)malloc(100);
strcpy(p, "hello");
free(p);    //p所指的內(nèi)存塊被釋放，但是p所指的地址仍然不變
...
if(p != NULL)
{
    strcpy(p, "world");    //出錯(cuò)
}

2.7.6動(dòng)態(tài)內(nèi)存會(huì)被自動(dòng)釋放嗎？?

? ? ? ? 函數(shù)體內(nèi)的局部變量在函數(shù)結(jié)束時(shí)自動(dòng)消亡。哼很多人誤以為上述示例是正確的。理由是p是局部的指針變量，它消亡的時(shí)候會(huì)讓它所指的動(dòng)態(tài)內(nèi)存一起完蛋。這是錯(cuò)覺！

void Func(void)
{
    char *p = (char *)malloc(100);    //動(dòng)態(tài)內(nèi)存會(huì)自動(dòng)釋放嗎？
}

? ? ? ? 我們發(fā)現(xiàn)指針有一些“似是而非”的特征：

（1）指針消亡了，并表示它所指向的內(nèi)存會(huì)被自動(dòng)釋放。

（2）內(nèi)存被釋放了，并不表示指針會(huì)消亡或者成了NULL指針。

? ? ? ? 這表明釋放內(nèi)存并不是一件可以草率對(duì)待的事。也許有人不服氣，一定要找出可以草率行事的理由：

? ? ? ? 如果程序終止了運(yùn)行，一切指針都會(huì)消亡，動(dòng)態(tài)內(nèi)存會(huì)被操作系統(tǒng)回收。既然如此，在程臨終前，就可以不必釋放內(nèi)存、不必將指針設(shè)置為NULL了。終于可以偷懶不會(huì)發(fā)生錯(cuò)誤了吧？

? ? ? ? 想得美。如果別人把那段程序取出來(lái)用到其他地方怎么辦？?

2.7.7杜絕“野指針”?

? ? ? ? “野指針”不是NULL指針，是指向“垃圾”內(nèi)存的指針。人們一般不會(huì)錯(cuò)用NULL指針，因?yàn)橛胕f語(yǔ)句很容易判斷。但是“野指針”是很危險(xiǎn)的，if語(yǔ)句對(duì)它不起作用。

? ? ? ? “野指針”的成因主要有兩種：

（1）指針變量沒有被初始化。任何指針變量剛被創(chuàng)建時(shí)不會(huì)自動(dòng)成為NULL指針，它的缺省值是隨機(jī)的，它會(huì)亂指一氣。所以，指針變量在創(chuàng)建的同時(shí)應(yīng)當(dāng)被初始化，要么將指針設(shè)置為NULL，要么讓它指向合法的內(nèi)存。例如：

? ? ? ? char *p = NULL;

? ? ? ? char *str = (char *)malloc(100);

（2）指針p被free或者delete之后，沒有設(shè)置NULL，讓人誤以為p是個(gè)合法的指針。?參見2.7.5。

（3）指針操作超越了變量的作用范圍。這種情況讓人防不勝防，示例程序如下：

class A
{
public:
    void Func(void)
    {
        cout << "Func of class A" << endl;
    }
};

void Test(void)
{
    A  *p;
    {
        A  a;
        p = &a;//注意a的生命周期
    }
    p->Func();//p是野指針
}

? ? ? ? 函數(shù)Test在執(zhí)行語(yǔ)句p->Func()時(shí)，對(duì)象a已經(jīng)消失，而p是指向a的，所以p就成了“野指針”。但奇怪的是我運(yùn)行這個(gè)程序時(shí)居然沒有出錯(cuò)，這可能與編譯器有關(guān)。

2.7.8有了malloc/free為什么還要new/delete??

? ? ? ? malloc與free是C++/C語(yǔ)言的標(biāo)準(zhǔn)庫(kù)函數(shù)，new/delete是C++運(yùn)算符。它們都可以用于申請(qǐng)動(dòng)態(tài)內(nèi)存和釋放內(nèi)存。

? ? ? ? 對(duì)于非內(nèi)部數(shù)據(jù)類型的對(duì)象而言，光用malloc/free無(wú)法滿足動(dòng)態(tài)對(duì)象的要求。對(duì)象在創(chuàng)建的同時(shí)要自動(dòng)執(zhí)行構(gòu)造函數(shù)，對(duì)象在消亡之前要自動(dòng)執(zhí)行析構(gòu)函數(shù)。由于malloc/free是庫(kù)函數(shù)而不是運(yùn)算符，不再編譯器控制權(quán)限之內(nèi)，不能夠把執(zhí)行構(gòu)造函數(shù)和析構(gòu)函數(shù)的任務(wù)強(qiáng)加于malloc/free。

? ? ? ? 因此C++語(yǔ)言需要一個(gè)能完成動(dòng)態(tài)內(nèi)存分配和初始化工作的運(yùn)算符new，以及一個(gè)能完成清理于釋放工作的運(yùn)算符delete。注意new/delete不是庫(kù)函數(shù)。

? ? ? ? 我們先看一看malloc/free和new/delete如何實(shí)現(xiàn)對(duì)象的動(dòng)態(tài)內(nèi)存管理，見下例：

class  Obj
{
public:
    Obj(void){ cout << "Initialization" << endl; }
    ~Obj(void){ coud << "Destroy" << endl; }

    void Initialize(void){ cout << "Initialization" << endl; }
    void Destroy(void){ cout << "Destroy" << endl; }

};


void Usemallocfree(void)
{

    Obj *a = (Obj *)malloc(sizeof(Obj));    //申請(qǐng)動(dòng)態(tài)內(nèi)存
    a->Initialize();    //初始化
    ...
    a->Destroy();    //清除工作
    free(a);         //釋放內(nèi)存
}


void UseNewDelete(void)
{
    Obj *a = new Obj;//申請(qǐng)動(dòng)態(tài)內(nèi)存并初始化
    //...
    delete a;    //清除并且釋放內(nèi)存
}

? ? ? ? 類Obj的函數(shù)Initialize模擬了構(gòu)造函數(shù)的功能，函數(shù)Destroy模擬了析構(gòu)函數(shù)的功能。函數(shù)Usemallocfree中，由于malloc/free不能執(zhí)行構(gòu)造函數(shù)與析構(gòu)函數(shù)，必須調(diào)用成員函數(shù)Initialize和Destroy來(lái)完成初始化與清除工作。函數(shù)UseNewDelete則簡(jiǎn)單得多。

? ? ? ? 所以我們不要企圖用malloc/free來(lái)完成動(dòng)態(tài)對(duì)象的內(nèi)存管理，應(yīng)該用new/delete。由于內(nèi)部數(shù)據(jù)類型的“對(duì)象”沒有構(gòu)造與析構(gòu)的過程，對(duì)它們而言malloc/free和new/delete是等價(jià)的。

? ? ? ? 既然new/delete的功能完全覆蓋了malloc/free，為什么C++不把malloc/free淘汰出局呢？這是因?yàn)镃++程序經(jīng)常要調(diào)用C函數(shù)，而C程序只能用malloc/free管理動(dòng)態(tài)內(nèi)存。

? ? ? ? 如果用free釋放“new創(chuàng)建的動(dòng)態(tài)對(duì)象”，那么該對(duì)象因無(wú)法執(zhí)行析構(gòu)函數(shù)而可能導(dǎo)致程序出錯(cuò)。如果用delete釋放“malloc申請(qǐng)的動(dòng)態(tài)內(nèi)存”，理論上講程序不會(huì)出錯(cuò)，但是該程序的可讀性很差。所以new/delete必須配對(duì)使用，malloc/free也一樣。?

2.7.9內(nèi)存耗盡怎么辦？

? ? ? ? 如果在申請(qǐng)動(dòng)態(tài)內(nèi)存時(shí)找不到足夠大的內(nèi)存塊，malloc和new將返回NULL指針，宣告內(nèi)存申請(qǐng)失敗。通常有三種方式處理“內(nèi)存耗盡”問題。

（1）判斷指針是否為NULL，如果時(shí)則馬上用return語(yǔ)句終止本函數(shù)。例如：

void Func(void)
{
    A  *a = new A;
    if(NULL == a)
    {
        return;
    }
    
    ...
}

（2）判斷指針是否為NULL，如果是則馬上用exit(1)終止整個(gè)程序的運(yùn)行。例如：?

void Func(void)
{
    A  *a = new A;
    if(NULL == a)
    {
        cout << "Memory  Exhausted" << endl;
        exit(1);
    }
    
    ...
}

（3） 為new和malloc設(shè)置異常處理函數(shù)。例如Visual C++可以用_set_new_hander函數(shù)為new設(shè)置用戶自己定義的異常處理函數(shù)，也可以讓malloc享用與new相同的異常處理函數(shù)。詳細(xì)內(nèi)容請(qǐng)參考C++使用手冊(cè)。

? ? ? ? 上述（1）（2）方式使用最普遍。如果一個(gè)函數(shù)內(nèi)有多處需要申請(qǐng)動(dòng)態(tài)內(nèi)存，那么方式（1）就顯得力不從心（釋放內(nèi)存很麻煩），應(yīng)該用方式（2）來(lái)處理。

? ? ? ? 很多人不忍心用exit(1)，問：“不編寫出錯(cuò)處理程序，讓操作系統(tǒng)自己解決行不行？”

? ? ? ? 答案是不行，如果發(fā)生“內(nèi)存耗盡”這樣的事情，一般來(lái)說應(yīng)用程序已經(jīng)無(wú)可救藥。如果不用exit(1)把壞程序殺死，它可能會(huì)害死操作系統(tǒng)。道理如同：如果不把歹徒擊斃，歹徒在老死之前會(huì)犯下更多的罪。

? ? ? ? 有一個(gè)很重要的現(xiàn)象要告訴大家。對(duì)于32位以上的應(yīng)用程序而言，無(wú)論怎樣使用malloc與new,幾乎不可能導(dǎo)致“內(nèi)存耗盡”。我在Windows 98下用VisualC++編寫了測(cè)試程序，見下例。這個(gè)程序會(huì)無(wú)休止地運(yùn)行下去，根本不會(huì)停止。因?yàn)?2位操作系統(tǒng)支持“虛存”，內(nèi)存用完了，自動(dòng)用硬盤空間頂替。我只聽到硬盤嘎吱嘎吱的響，Windows 98已經(jīng)累的對(duì)鍵盤、鼠標(biāo)毫無(wú)反應(yīng)。

? ? ? ? 我可以得出一個(gè)結(jié)論：對(duì)于32位以上的應(yīng)用程序，“內(nèi)存耗盡”錯(cuò)誤錯(cuò)誤處理程序毫無(wú)作用。這下把Unix和Windows程序員們樂壞了：反正錯(cuò)誤處理程序不起作用，我就不寫了，省了很多麻煩。

? ? ? ? 我不想誤導(dǎo)讀者，必須強(qiáng)調(diào)：不加錯(cuò)誤處理將導(dǎo)致程序的質(zhì)量很差，千萬(wàn)不可因小失大。

void main(void)
{
    float *p = NULL;
    while(TRUE)
    {
        p = new float[1000000];
        cout << "eat memory" << endl;
        if(NULL == p)
        {
            exit(1);
        }
    }
}

2.7.10malloc/free的使用要點(diǎn)?

? ? ? ? 函數(shù)malloc的原型如下：

? ? ? ? void *malloc(size_t size);?

? ? ? ? 用malloc申請(qǐng)一塊長(zhǎng)度為length的整數(shù)類型的內(nèi)存，程序如下：

? ? ? ? int *p = (int *)malloc(sizeof(int ) * length);?

? ? ? ? 我們應(yīng)當(dāng)把注意力集中在兩個(gè)要素上：“類型轉(zhuǎn)換”和“sizeof”。

• malloc返回值的類型是void *，所以在調(diào)用malloc時(shí)要顯示地進(jìn)行類型轉(zhuǎn)換，將void *轉(zhuǎn)換成所需要的指針類型。
• malloc函數(shù)本身并不識(shí)別要申請(qǐng)的內(nèi)存是什么類型，它只關(guān)心內(nèi)存的總字節(jié)數(shù)。我們通常記不住int、float等數(shù)據(jù)類型的變量的確切字節(jié)數(shù)。例如int變量在16位系統(tǒng)下是2個(gè)字節(jié)，在32位下是4個(gè)字節(jié)；而float變量在16位系統(tǒng)下是4個(gè)字節(jié)，在32位下也是4個(gè)字節(jié)。最好用sizeof()運(yùn)算符做一下測(cè)試。
• 函數(shù)free的原型如下：

? ? ? ? void free(void * memblock);?

? ? ? ? 為什么free函數(shù)不像malloc函數(shù)那樣復(fù)雜呢？這是因?yàn)橹羔榩的類型以及它所指的內(nèi)存的容量事先都是知道的，語(yǔ)句fre(p）能正確的釋放內(nèi)存。如果指針p是NULL指針，那么free對(duì)p無(wú)論操作多少次都不會(huì)出問題。如果p不是NULL指針，那么free對(duì)p連續(xù)操作兩次就會(huì)導(dǎo)致程序運(yùn)行錯(cuò)誤。?

?2.7.11new/delete的使用要點(diǎn)

? ? ? ? 運(yùn)算符new使用起來(lái)要比函數(shù)malloc簡(jiǎn)單的多，例如：

? ? ? ? int *p1 = (int *)malloc(sizeof(int) * length);

? ? ? ? int *p2 = new int[length];?

? ? ? ? 這是因?yàn)閚ew內(nèi)置了sizeof、類型轉(zhuǎn)換和類型安全檢查功能。對(duì)于非內(nèi)部數(shù)據(jù)類型的對(duì)象而言，new在創(chuàng)建動(dòng)態(tài)內(nèi)存對(duì)象的同時(shí)完成了初始化工作。如果對(duì)象有多個(gè)構(gòu)造函數(shù)，那么new的語(yǔ)句也可以有多種形式。例如：

class  Obj
{
public:
    Obj(void);    //無(wú)參數(shù)的構(gòu)造函數(shù)    
    Obj(int x);   //帶一個(gè)參數(shù)的構(gòu)造函數(shù)
    ...
};

void Test(void)
{
    Obj *a = new Obj;
    Obj *b = new Obj(1);//初始值為1    
    ...
    delete a;
    delete b;
}

? ? ? ? 如果同new創(chuàng)建對(duì)象數(shù)組，那么只能使用對(duì)象的無(wú)參數(shù)構(gòu)造函數(shù)。例如：

? ? ? ? Obj *objects = new Obj[100];//創(chuàng)建100個(gè)動(dòng)態(tài)對(duì)象?

? ? ? ? 而不能寫成：

? ? ? ? Obj *objects = new Obj[100](1);//創(chuàng)建100個(gè)動(dòng)態(tài)對(duì)象的同時(shí)賦初值為1?

? ? ? ? 在用delete釋放對(duì)象數(shù)組時(shí)，留意不要丟了符號(hào)‘[? ]’。例如：

? ? ? ? delete []objects;//正確的寫法

? ? ? ? delete objects;//錯(cuò)誤的寫法?

? ? ? ? 后者相當(dāng)于delete objects[0],漏掉了林外99個(gè)對(duì)象。?

2.7.12一些心得體會(huì)?

? ? ? ? 我認(rèn)識(shí)不少技術(shù)不錯(cuò)的C++/C程序員，很少有人能拍拍胸脯說通曉指針與內(nèi)存管理（包括我自己）。我最初學(xué)習(xí)C語(yǔ)言是特別怕指針，導(dǎo)致我寫代碼的時(shí)候沒有使用一個(gè)指針，全用數(shù)組來(lái)頂替指針，是在蠢笨得過分。躲避指針不是辦法，后來(lái)我改寫了這個(gè)軟件，代碼量縮小到原先的一半。

? ? ? ? 我的經(jīng)驗(yàn)教訓(xùn)是：

（1）越是怕指針，就越要使用指針。不會(huì)正確使用指針，肯定算不上是合格的程序員。

（2）必須養(yǎng)成“使用調(diào)試器逐步跟蹤程序”的習(xí)慣，只有這樣才能發(fā)現(xiàn)問題的本質(zhì)。?

2.8C++函數(shù)的高級(jí)特性?

? ? ? ? 對(duì)比于C語(yǔ)言的函數(shù)，C++增加了重載、內(nèi)聯(lián)、const和virtual四種機(jī)制。其中重載和內(nèi)聯(lián)機(jī)制既可以用于全局函數(shù)也可以用于類的成員函數(shù)，const與virtual機(jī)制僅用于類的成員函數(shù)。

? ? ? ? 重載和內(nèi)聯(lián)肯定有其好處才會(huì)被C++語(yǔ)言采納，但是不可以當(dāng)成免費(fèi)的午餐而濫用。本小節(jié)將探究重載和內(nèi)聯(lián)的優(yōu)點(diǎn)與局限性，說明什么情況下應(yīng)該采用、不該采用以及要警惕使用。

2.8.1函數(shù)重載的概念

2.8.1.1重載的起源?

? ? ? ? 自然語(yǔ)言中，一個(gè)詞可以有許多不同的定義，即改詞被重載了。人們可以通過上下文來(lái)判斷該詞到底是那種含義?！霸~的重載”可以使語(yǔ)言更加簡(jiǎn)練。例如“吃飯”的含義十分廣泛，人們沒有必要每次非得說清楚具體吃什么不可。別迂腐的像孔乙己，說茴香豆的茴字有四種寫法。

? ? ? ? 在C++程序中，可以將語(yǔ)義、功能相似的幾個(gè)函數(shù)用同一個(gè)名字表示，即函數(shù)重載。這樣便于記憶，提高了函數(shù)的易用性，這是C++語(yǔ)言采用重載機(jī)制的一個(gè)理由。例如下面的例子中，函數(shù)EatBeef、Eatfish、EatChicken可以用同一個(gè)函數(shù)名Eat表示，用不同類型的參數(shù)加以區(qū)別。

void EatBeef(...);    //可改為void Eat(Beef...);
void EatFish(...);    //可改為void Eat(Fish...);
void EatChicken(...); //可改為void Eat(Chicken...);

? ? ? ? C++語(yǔ)言采用重載機(jī)制的另一個(gè)理由：類的構(gòu)造函數(shù)需要重載機(jī)制。因?yàn)镃++規(guī)定類的構(gòu)造函數(shù)于類同名（請(qǐng)參見2.9），構(gòu)造函數(shù)只能有一個(gè)名字。如果想用幾種不同的方法創(chuàng)建對(duì)象該怎么辦？別無(wú)選擇，只能用重載機(jī)制來(lái)實(shí)現(xiàn)。所以類可以有多個(gè)同名的構(gòu)造函數(shù)。

2.8.1.2重載是如何實(shí)現(xiàn)的？?

? ? ? ? 幾個(gè)同名的重載函數(shù)仍然時(shí)不同的函數(shù)，它們是如何區(qū)分的呢？我們自然想到函數(shù)接口的兩個(gè)要素：參數(shù)與返回值。

? ? ? ? 如果同名函數(shù)的參數(shù)不同（包括類型、順序不同），那么容易區(qū)別出它們是不同的函數(shù)。

? ? ? ? 如果同名函數(shù)僅僅是返回值的類型不同，有時(shí)可以區(qū)分，有時(shí)卻不能。例如：

? ? ? ? void? ? ? ? Function(void);

? ? ? ? int? ? ? ? ? ?Function(void);?

? ? ? ? 上述兩個(gè)函數(shù)，第一個(gè)沒有返回值，第二個(gè)返回值是int類型。如果這樣調(diào)用函數(shù)：

? ? ? ? int x = Function();?

? ? ? ? 則可以判斷出Function是第二個(gè)函數(shù)。問題是在C++/C程序中，我們可以忽略函數(shù)的返回值。在這種情況下，編譯器和程序員都不知道那個(gè)Function函數(shù)被調(diào)用。

? ? ? ? 所以只能靠參數(shù)而不能靠返回值類型的不同來(lái)區(qū)分重載函數(shù)。編譯器根據(jù)參數(shù)為每個(gè)重載函數(shù)產(chǎn)生不同的內(nèi)部標(biāo)識(shí)符。例如編譯器為2.8.1.1中的示例的三個(gè)Eat函數(shù)產(chǎn)生像_eat_beff、_eat_fish、_eat_chicken之類的內(nèi)部標(biāo)識(shí)符（不同的編譯器可能產(chǎn)生不同風(fēng)格的內(nèi)部標(biāo)識(shí)符）。

? ? ? ? 如果C++程序要調(diào)用已被編譯后的C函數(shù)，該怎么辦？

? ? ? ? 假設(shè)某個(gè)C函數(shù)的聲明如下：

? ? ? ? int foo(int x, int y);?

? ? ? ? 該函數(shù)被C編譯器編譯之后再庫(kù)中的名字為_foo，而C++編譯器則會(huì)產(chǎn)生像_foo_int_int之類的名字用來(lái)支持函數(shù)重載和類型安全連接。由于編譯后的名字不同，C++程序不能直接調(diào)用C函數(shù)。C++提供了一個(gè)C函數(shù)連接交換指定符號(hào)extern “C”來(lái)解決這個(gè)問題。例如：

? ? ? ? extern "C"

????????{

? ? ? ? ? ? ? ? void foo(int x, int y);

? ? ? ? ? ? ? ? ...//其它函數(shù)

????????}?

? ? ? ? 或者寫成

? ? ? ? extern "C"

? ? ? ? {

? ? ? ? ? ? ? ? #include "myheader.h"

? ? ? ? ? ? ? ? ...//其它C頭文件

????????}?

? ? ? ? 這就告訴C++編譯器，函數(shù)foo是個(gè)C連接，應(yīng)該到庫(kù)中找名字_foo而不是找_foo_int_int。C++編譯器開發(fā)商已經(jīng)對(duì)C標(biāo)準(zhǔn)庫(kù)的頭文件作了extern "C"處理，所以我們可以用#include直接引用這些頭文件。

? ? ? ? 注意并不是兩個(gè)函數(shù)的名字相同就能構(gòu)成重載。全局函數(shù)和類的成員函數(shù)同名不算重載，因?yàn)楹瘮?shù)的作用域不同。例如：

? ? ? ? void Print(...);? ? ? ? //全局函數(shù)

? ? ? ? class A
? ? ? ? {

? ? ? ? ? ? ? ? void Print(...);? ? ? ? //成員函數(shù)

????????}?

? ? ? ? 不論兩個(gè)Print函數(shù)的參數(shù)是否相同，如果類的某個(gè)成員函數(shù)要調(diào)用全局函數(shù)Print，為了與成員函數(shù)Print區(qū)別，全局函數(shù)被調(diào)用時(shí)應(yīng)加“::”標(biāo)志。如

? ? ? ? ::Print(...);? ? ? ? //表示Print是全局函數(shù)而非成員函數(shù)

2.8.1.3當(dāng)心隱式類型轉(zhuǎn)換導(dǎo)致重載函數(shù)產(chǎn)生二義性?

? ? ? ? 下面示例中，第一個(gè)output函數(shù)的函數(shù)時(shí)int類型，第二個(gè)output函數(shù)的參數(shù)是float類型。由于數(shù)字本身沒有類型，將數(shù)字當(dāng)做參數(shù)時(shí)將自動(dòng)進(jìn)行類型轉(zhuǎn)換（稱為隱式類型轉(zhuǎn)換）。語(yǔ)句output（0.5）將產(chǎn)生編譯錯(cuò)誤，因?yàn)榫幾g器不知道將0.5轉(zhuǎn)換成int還是float類型的參數(shù)。隱式類型轉(zhuǎn)換在很多地方可以簡(jiǎn)化程序的書寫，但也有可能留下隱患。

#include <iostream.h>
void output(int x);    //函數(shù)聲明
void output(float x);  //函數(shù)聲明

void output(int x)
{
    cout << "output int" << x << endl;
}

void output(float x)
{
    cout << "output float" << x << endl;
}

void main()
{
    int x = 1;
    float y = 1.0;
    output(x);    //output int 1
    output(y);    //output float 1
    output(1);    //output int 1
//    output(0.5);  //error! 因?yàn)樽詣?dòng)類型轉(zhuǎn)換
    output(int(0.5));//output int 0
    output(float(0.5));//output float 0.5
}

2.8.2成員函數(shù)的重載、覆蓋與隱藏?

? ? ? ? 成員函數(shù)的重載、覆蓋與隱藏很容易混淆，C++程序員必須要搞清楚概念，否則錯(cuò)誤將防不勝防。

2.8.2.1重載與覆蓋?

? ? ? ? 成員函數(shù)被重載的特征：

? ? ? ? （1）相同的范圍（在同一個(gè)類中）；

? ? ? ? （2）函數(shù)名字 相同；

? ? ? ? （3）參數(shù)不同；

? ? ? ? （4）virtual關(guān)鍵字可有可無(wú)。

? ? ? ? 覆蓋是指派生類函數(shù)覆蓋其基類函數(shù)，特征是：

? ? ? ? （1）不同的范圍（分別位于派生類與基類）；

? ? ? ? （2）函數(shù)名字相同；

? ? ? ? （3）參數(shù)相同；?

? ? ? ? ?（4）基類函數(shù)必須有virtual關(guān)鍵字。

? ? ? ? 下面示例中，函數(shù)Base::f(int)與Base::f(float)相互重載，而Base::g(void)被Derived::g(void)覆蓋。

#include <iostream.h>
class Base
{
public:
    void f(int x)
    {
        cout << "Base::f(int)" << x << endl;
    }
    void f(float x)
    {
        cout << "Base::f(float)" << x << endl;
    }

    virtual void g(void)
    {
        cout << "Base::g(void)" << endl;
    }
};

class Derived: public Base
{
public:
    virtual void g(void)
    {
        cout << "Derived::g(void)" << endl;
    }
};

void main()
{
    Derived d;
    Base *pb = &d;
    pb->f(42);    //Base::f(int) 42
    pb->f(3.14f); //Base::f(float) 3.14
    pb->g();      //Derived::g(void)
}

2.8.2.2令人迷惑的隱藏規(guī)則?

? ? ? ? 本來(lái)僅僅區(qū)分重載與覆蓋并不算困難，但是C++的隱藏規(guī)則使問題復(fù)雜性徒然增加。這里“隱藏”是指派生類的函數(shù)屏蔽了與其同名的基類函數(shù)，規(guī)則如下：

（1）如果派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)不同。此時(shí)，不論有無(wú)virtual關(guān)鍵字，基類的函數(shù)將被隱藏（注意別與重載混淆）；

（2）如果派生類的函數(shù)與基類的函數(shù)同名 ，并且參數(shù)也相同，但是基類函數(shù)沒有virtual關(guān)鍵字。此時(shí)，基類的函數(shù)被隱藏（注意別與覆蓋混淆）。

? ? ? ? 下面示例a中：

? ? ? ? ?（1）函數(shù)Derived::f(float)覆蓋了Base::f(float)；

? ? ? ? （2）函數(shù)Derived::g(int)隱藏了Base::g(float),而不是重載；

? ? ? ? （3）函數(shù)Derived::h(float)隱藏了Base::h(float)，而不是覆蓋。

#include <iostream.h>
class Base
{
public:
    virtual void f(float x)
    {
        cout << "Base::f(float)" << x << endl;
    }
    void g(float x)
    {
        cout << "Base::g(float)" << x << endl;
    }
    void h(float x)
    {
        cout << "Base::h(float)" << x << endl;
    }
};

class Derived : public Base
{
public:
    virtual void f(float x)
    {
        cout << "Derived::f(float)" << x << endl;
    }
    void g(int x)
    {
        cout << "Derived::g(int)" << x << endl;
    }
    void h(float x)
    {
        cout << "Derived::h(float)" << x << endl;
    }
};

? ? ? ? 根據(jù)考察，很多C++程序員沒有意識(shí)到有“隱藏”這回事。由于認(rèn)識(shí)不夠深刻，“隱藏”的發(fā)生可謂神出鬼沒，常常產(chǎn)生令人迷惑的結(jié)果。

? ? ? ? 示例b中，bp和dp指向同一地址，按理說運(yùn)行結(jié)果應(yīng)該是相同的，可事實(shí)并非這樣。?

void main()
{
    Derived d;
    Base *bp = &d;
    Derived *dp = &d;
    //Good : behavior depends solely on type of the object
    bp->f(3.14);    //Derived::f(float) 3.14
    dp->f(3.14);    //Derived::f(flaot) 3.14

    //Bad : behavior depends on type of the pointer
    bp->g(3.14f);    //Base::g(float) 3.14
    dp->g(3.14f);    //Derived::g(int) 3    (surprise!)

    //Bad : behavior depends on type of the pointer
    bp->h(3.14f);    //Base::h(float) 3.14    (surprise!)
    dp->h(3.14f);    //Derived::h(float) 3.14
}

2.8.2.3擺脫隱藏?

? ? ? ? 隱藏規(guī)則引起了不少麻煩。下面示例中pd->f(10)的本意是想調(diào)用函數(shù)Base::f(int),但是Base::f(int)不幸被Derived::f(char *)隱藏了。由于數(shù)字10不能被隱式地轉(zhuǎn)化為字符串，所以在編譯時(shí)會(huì)出錯(cuò)。

class Base
{
public:
    void f(int x);
};

class Derived : public Base
{
public:
    void f(char *);
};

void Test(void)
{
    Derived *pd = new Derived;
    pd->f(10);    //error
}

? ? ? ? 從上述示例看來(lái)，隱藏的規(guī)則似乎很愚蠢。但是隱藏規(guī)則至少有兩個(gè)純?cè)诘睦碛桑?/p>

• 寫語(yǔ)句pd->f(10)的人可能真的想調(diào)用Derived::f(char *)函數(shù)，只是他誤將參數(shù)寫錯(cuò)了。有了隱藏規(guī)則，編譯器就可以明確指出錯(cuò)誤，這未必不是見好事。否則，編譯器回靜悄悄 地將錯(cuò)就錯(cuò)，程序員將很難發(fā)現(xiàn)這個(gè)錯(cuò)誤，留下禍根。
• 假如類Derived有很多個(gè)基類（多重繼承），有時(shí)候搞不清哪些基類定義了函數(shù)f。如果沒有隱藏規(guī)則，那么pd->f(10)可能會(huì)調(diào)用一個(gè)出乎意料的基類函數(shù)f。盡管隱藏規(guī)則看起來(lái)不怎么有道理，但它的確能消滅這些意外。

? ? ? ? 上述示例中，如果語(yǔ)句pd->f(10)一定要調(diào)用函數(shù)Base::f(int)，那么將類Derived修改為如下即可。

class Derived : public Base
{
public:
    void f(char *);
    void f(int x)
    {
        Base::f(x);
    }
};

2.8.3參數(shù)的缺省?

? ? ? ? 有一些參數(shù)的值在每次函數(shù)調(diào)用時(shí)都相同，書寫這樣的語(yǔ)句會(huì)使人厭煩。C++語(yǔ)言采用參數(shù)的缺省值使書寫變得簡(jiǎn)潔（在編譯時(shí)，缺省值由編譯器自動(dòng)插入）。

? ? ? ? 參數(shù)缺省值使用規(guī)則：

• 規(guī)則1：參數(shù)的缺省值只能出現(xiàn)在函數(shù)的聲明中，而不能出現(xiàn)在定義體中。?

? ? ? ? 例如：

? ? ? ? void Foo(int x = 0, int y = 0);? ? ? ? //正確，缺省值出現(xiàn)在函數(shù)的聲明中

? ? ? ? void Foo(int x = 0, int y = 0)? ? ? ? ?//錯(cuò)誤，缺省值出現(xiàn)在函數(shù)的定義體中

????????{

? ? ? ? ? ? ? ? ...

????????}?

? ? ? ? 為什么會(huì)這樣？我想是有兩個(gè)原因：一是函數(shù)的實(shí)現(xiàn)（定義）?本來(lái)就與參數(shù)是否有缺省值無(wú)關(guān)，所以沒有必要讓缺省值出現(xiàn)在函數(shù)的定義體中。二是參數(shù)的缺省值可能會(huì)改動(dòng)，顯然修改函數(shù)的聲明比修改函數(shù)的定義要方便。

• 規(guī)則2：如果函數(shù)有多個(gè)參數(shù)，參數(shù)只能從后向前愛個(gè)缺省，否則將導(dǎo)致 函數(shù)調(diào)用語(yǔ)句怪模怪樣。

? ? ? ? 正確的示例如下：

? ? ? ? void Foo(int x, int y = 0, int z = 0);?

? ? ? ? 錯(cuò)誤的示例如下：

? ? ? ? void Foo(int x = 0, int y, int z = 0);?

? ? ? ? ?要注意，使用參數(shù)的缺省值并沒有賦予函數(shù)新的功能，僅僅是使書寫變得簡(jiǎn)潔一些。它可能會(huì)提高函數(shù)的易用性，但是也可能會(huì)降低函數(shù)的可理解性。所以我們自能適當(dāng)?shù)厥褂脜?shù)的缺省值，要防止使用不當(dāng)產(chǎn)生負(fù)面效果。下面示例中，不合理的使用參數(shù)的缺省值將導(dǎo)致重載函數(shù)output產(chǎn)生二義性。

#include <iostream.h>
void output(int x);
void output(int x, float y = 0);

void output(int x)
{
    cout << "output int " << x << endl;
}

void output(int x, float y)
{
    cout << "output int " << x << "and float" << y << endl;
}

void main()
{
    int x = 1;
    float y = 0.5;
    //output(x);    //error！ambiguous call
    output(x, y);    //output int 1 and float 0.5
}

2.8.4運(yùn)算符的重載?

2.8.4.1概念?

? ? ? ? 在C++語(yǔ)言中，可以用關(guān)鍵字operator加上運(yùn)算符來(lái)表示函數(shù)，叫做運(yùn)算符重載 。例如兩個(gè)復(fù)數(shù)相加函數(shù)：

? ? ? ? Complex Add(const Complex &a, const Complex &b);?

? ? ? ? 可以用運(yùn)算符重載來(lái)表示：

? ? ? ? Complex operator+(const Complex &a, const Complex &b);?

? ? ? ? 運(yùn)算符與普通函數(shù)在調(diào)用時(shí)的不同之處是：對(duì)于普通對(duì)象，參數(shù)出現(xiàn)在圓括號(hào)內(nèi)；而對(duì)于運(yùn)算符，參數(shù)出現(xiàn)在其左、右側(cè)。例如：

? ? ? ? Complex a, b, c;

? ? ? ? ...

? ? ? ? c = add(a, b);? ? ? ? //用普通函數(shù)

? ? ? ? c = a + b;? ? ? ? ? ? ? //用運(yùn)算符 +?

? ? ? ? 如果運(yùn)算符被重載為全局函數(shù)，那么只有一個(gè)參數(shù)的運(yùn)算符叫做一元運(yùn)算符，有兩個(gè)參數(shù)的運(yùn)算符叫做二元運(yùn)算符。

? ? ? ? 如果運(yùn)算符被重載為類的成員函數(shù)，那么一元運(yùn)算符沒有參數(shù)，二元運(yùn)算符只有一個(gè)右側(cè)參數(shù)，因?yàn)閷?duì)象自己成了左側(cè)參數(shù)。

? ? ? ? 從語(yǔ)法上將，運(yùn)算符即可以定義為全局函數(shù)，也可以定義為成員函數(shù)，其總結(jié)了如下表的規(guī)則：

? ? ? ? 由于C++語(yǔ)言支持函數(shù)的重載，才能將運(yùn)算符當(dāng)成函數(shù)來(lái)用，C語(yǔ)言就不行。我們要以平常心來(lái)對(duì)待運(yùn)算符的重載：

（1）不要過分擔(dān)心自己不會(huì)用，它的本質(zhì)仍然是程序員們熟悉的函數(shù)。

（2）不要過分熱心地使用，如果它不能使代碼變得更加易讀寫，那就別用，否則會(huì)自找麻煩。

2.8.4.2不能被重載的運(yùn)算符?

? ? ? ? 在C++運(yùn)算符集合中，有一些運(yùn)算符是不允許被重載的。這種限制是出于安全方面的考慮，可防止錯(cuò)誤與混亂。

（1）不能改變C++內(nèi)部數(shù)據(jù)類型（如int 、float等）的運(yùn)算符。

（2）不能重載‘.’，因?yàn)椤?’在類中對(duì)任何成員都有意義，已經(jīng)成為標(biāo)準(zhǔn)用法。

（3）不能重載目前C++運(yùn)算符集合中沒有的符號(hào)，如#，@，￥等。原因有兩點(diǎn)，一是難以理解，二是難以確定優(yōu)先級(jí)。

（4）對(duì)已存在的運(yùn)算符進(jìn)行重載時(shí)，不能改變優(yōu)先級(jí)規(guī)則，否則將引起混亂。?

2.8.5函數(shù)內(nèi)聯(lián)?

2.8.5.1用內(nèi)聯(lián)函數(shù)取代宏代碼?

? ? ? ? C++語(yǔ)言支持函數(shù)內(nèi)聯(lián)，其目的是為了提高函數(shù)的執(zhí)行效率（速度）。

? ? ? ? 在C程序中，可以用宏代碼提高執(zhí)行效率。宏代碼本身不是函數(shù)，但使用起來(lái)像函數(shù)。預(yù)處理器用復(fù)制宏代碼的方式代替函數(shù)調(diào)用，省去了參數(shù)壓棧、生成匯編語(yǔ)言的CALL調(diào)用、返回參數(shù)、執(zhí)行return等過程，從而提高了速度。使用宏代碼最大的缺點(diǎn)是容易出錯(cuò)，預(yù)處理器在復(fù)制宏代碼時(shí)常常產(chǎn)生意想不到的邊際效應(yīng)。例如：

? ? ? ? #define MAX(a, b)? ? ? ? ? ? ? ? (a) > (b) ? (a) : (b)?

? ? ? ? 語(yǔ)句result = MAX(i, j) + 2;

? ? ? ? 將被預(yù)處理器解釋為

? ? ? ? result = (i) > (j) ? (i) : (j) + 2;

? ? ? ? 由于運(yùn)算符“+”比運(yùn)算符“：”的優(yōu)先級(jí)高，所以上述語(yǔ)句并不等價(jià)于期望

? ? ? ? result = ( (i) > (j) ? (i) : (j) ) + 2;

? ? ? ? 如果把宏代碼改寫為

? ? ? ? #define MAX(a, b)? ? ? ? ? ? ? ? ((a) > (b) ? (a) : (b))

? ? ? ? 則可以解決優(yōu)先級(jí)引起的錯(cuò)誤。但是即使使用修改后的宏代碼也不是萬(wàn)無(wú)一失的，例如語(yǔ)句

? ? ? ? result = MAX(i++, j);

? ? ? ? 將被預(yù)處理器解釋為

? ? ? ? result = (i++) > (j) ? (i++) : (j);

? ? ? ? 對(duì)于C++而言，使用宏代碼還有另一種缺點(diǎn)：無(wú)法操作類的私有數(shù)據(jù)成員。

? ? ? ? 讓我們看看C++的內(nèi)聯(lián)函數(shù)是怎么工作的。對(duì)于任何內(nèi)聯(lián)函數(shù)，編譯器在符號(hào)表里放入函數(shù)的聲明（包括名字、參數(shù)類型、返回值類型）。如果編譯器沒有發(fā)現(xiàn)內(nèi)聯(lián)函數(shù)存在錯(cuò)誤，那么該函數(shù)的代碼也被放入符號(hào)表里。在調(diào)用一個(gè)內(nèi)聯(lián)函數(shù)時(shí)，編譯器首先檢查調(diào)用是否正確（進(jìn)行類型安全檢查，作者進(jìn)行自動(dòng)類型轉(zhuǎn)換，當(dāng)然對(duì)所有的函數(shù)都一樣）。如果正確，內(nèi)聯(lián)函數(shù)的代碼就會(huì)直接替換函數(shù)調(diào)用，于是省去了函數(shù)調(diào)用的開銷。這個(gè)過程與預(yù)處理有顯著的不同，因?yàn)轭A(yù)處理器不能進(jìn)行類型安全檢查，或者進(jìn)行自動(dòng)類型轉(zhuǎn)換。假如內(nèi)聯(lián)函數(shù)是成員函數(shù)，對(duì)象的地址（this）會(huì)被放在合適的地方，這也是預(yù)處理辦不到的。

? ? ? ? C++語(yǔ)言的函數(shù)內(nèi)聯(lián)機(jī)制即具備宏代碼的效率，又增加了安全性，而且可以只有操作類的數(shù)據(jù)成員。所以在C++程序中，應(yīng)該用內(nèi)聯(lián)函數(shù)取代所有宏代碼，“斷言assert”恐怕是唯一的例外。assert是僅在Debug版本起作用的宏，它用于檢查“不應(yīng)該”發(fā)生的情況。為了不在程序的Debug版本和Release版本引起差別，assert不應(yīng)該產(chǎn)生任何副作用。如果assert是函數(shù)，由于函數(shù)調(diào)用會(huì)引起內(nèi)存、代碼的變動(dòng)，那么將導(dǎo)致Debug版本與Release版本存在差異。所以assert不是函數(shù)，而是宏。（詳見2.6.5使用斷言）?

2.8.5.2內(nèi)聯(lián)函數(shù)的編程風(fēng)格?

? ? ? ? 關(guān)鍵字inline必須與函數(shù)定義體放在一起才能使函數(shù)成為內(nèi)聯(lián)函數(shù)，僅將inline放在函數(shù)聲明前面不起任何作用。如下風(fēng)格的函數(shù)Foo不能成為內(nèi)聯(lián)函數(shù)：

? ? ? ? inline void Foo(int x, int y);? ? ? ? //inline僅與函數(shù)聲明放在一起

? ? ? ? void Foo(int x, int y)

? ? ? ? {

? ? ? ? ? ? ? ? ...

????????}?

? ? ? ? 如下面風(fēng)格的函數(shù)Foo則成為內(nèi)聯(lián)函數(shù):

? ? ? ? void Foo(int x, int y);

? ? ? ? inline void Foo(int x, int y)//inline與函數(shù)定義體放在一起

????????{

? ? ? ? ? ? ? ? ...

????????}?

? ? ? ? 所以說，inline 是一種“用于實(shí)現(xiàn)的關(guān)鍵字”，而不是一種“用于聲明的關(guān)鍵字”。一般地，用戶可閱讀函數(shù)的聲明，但是看不到函數(shù)的定義。盡管在大多數(shù)教科書內(nèi)聯(lián)函數(shù)的聲明、定義體前面都加inline關(guān)鍵字，但我認(rèn)為inline不應(yīng)該出現(xiàn)在函數(shù)的聲明中。這個(gè)細(xì)節(jié)雖然不會(huì)影響函數(shù)的功能，但是體現(xiàn)了高質(zhì)量C++/C程序的設(shè)計(jì)風(fēng)格的一個(gè)基原則：聲明與定義不可混為一談，用戶沒有必要、也不應(yīng)該知道函數(shù)是否需要內(nèi)聯(lián)。

? ? ? ? 定義在類聲明之中的成員函數(shù)將自動(dòng)成為內(nèi)聯(lián)函數(shù)，例如

class A
{
public:
    void Foo(int x, int y)
    {
        ...
    }
};

? ? ? ? 將成員函數(shù)的定義體放在類聲明之中雖然能帶來(lái)書寫上的方便，但不是一種良好的編程風(fēng)格，上例應(yīng)該改為：

? ? ? ? //頭文件

? ? ? ? class A

? ? ? ? {

? ? ? ? public:

? ? ? ? ? ? ? ? void Foo(int x, int y);

????????};?

????????

? ? ? ? //定義文件

? ? ? ? inline void A::Foo(int x, int y)

? ? ? ? {

? ? ? ? ? ? ? ? ...

????????}

2.8.5.3慎用內(nèi)聯(lián)?

? ? ? ? 內(nèi)聯(lián)能提高函數(shù)的執(zhí)行效率，為什么不把所有的函數(shù)都定義成內(nèi)聯(lián)函數(shù)？

? ? ? ? 如果所有的函數(shù)都是內(nèi)聯(lián)函數(shù)，還用得著“內(nèi)聯(lián)”這個(gè)關(guān)鍵字嗎？

? ? ? ? 內(nèi)聯(lián)是以代碼膨脹（賦值）為代價(jià)，僅僅省去了函數(shù)調(diào)用的開銷，從而提高函數(shù)的執(zhí)行效率。如果執(zhí)行函數(shù)體內(nèi)代碼的時(shí)間，相比于函數(shù)的調(diào)用開銷較大，那么效率的收獲會(huì)很少。另一方面，每一處內(nèi)聯(lián)函數(shù)的調(diào)用都要賦值代碼，將使程序的總代碼量增大，消耗更多的內(nèi)存空間。以下情況不宜使用內(nèi)聯(lián)：

（1）如果函數(shù)體內(nèi)的代碼比較長(zhǎng)，使用內(nèi)聯(lián)將導(dǎo)致內(nèi)存消耗代價(jià)較高。

（2）如果函數(shù)體內(nèi)出現(xiàn)循環(huán)，那么執(zhí)行函數(shù)體內(nèi)代碼的時(shí)間要比函數(shù)調(diào)用的開銷大。

? ? ? ? 類的構(gòu)造函數(shù)和析構(gòu)函數(shù)容易讓人誤解成使用內(nèi)聯(lián)更有效，要當(dāng)心構(gòu)造函數(shù)和析構(gòu)函數(shù)可能會(huì)隱藏一些行為，如“偷偷地”執(zhí)行了基類或成員對(duì)象的構(gòu)造函數(shù)和析構(gòu)函數(shù)。所以不要隨便地將構(gòu)造函數(shù)和析構(gòu)函數(shù)的定義體放在類聲明中。

? ? ? ? 一個(gè)好的編譯器將會(huì)根據(jù)函數(shù)的定義體，自動(dòng)地取消不值得的內(nèi)聯(lián)（這進(jìn)一步說明了inline不應(yīng)該出現(xiàn)在函數(shù)的聲明中）。

2.8.6一些心得體驗(yàn)?

? ? ? ? C++語(yǔ)言中的重載、內(nèi)聯(lián)、缺省參數(shù)、隱式轉(zhuǎn)換等機(jī)制展現(xiàn)了很多優(yōu)點(diǎn)，但是這些優(yōu)點(diǎn)的背后都隱藏著一些隱患。正如人們的飲食，少食和暴食都不可取，應(yīng)當(dāng)恰到好處。我們要辯證地看待C++的新機(jī)制，應(yīng)該恰如其分地使用它們。雖然這會(huì)使我們編程時(shí)多費(fèi)一些心思，少了一些痛快，但這才是編程的藝術(shù)。?

2.9類的構(gòu)造函數(shù)、析構(gòu)函數(shù)與賦值函數(shù)?

? ? ? ? 構(gòu)造函數(shù)、析構(gòu)函數(shù)與賦值函數(shù)是每個(gè)類最基本的函數(shù)。它們太普通以致讓人容易麻痹大意，其實(shí)這些貌似簡(jiǎn)單的函數(shù)就像沒有頂蓋的下水道那樣危險(xiǎn)。

? ? ? ? 每個(gè)類只有一個(gè)析構(gòu)函數(shù)和一個(gè)賦值函數(shù)，但可以有多個(gè)構(gòu)造函數(shù)（包含一個(gè)拷貝構(gòu)造函數(shù)，其它的稱為普通構(gòu)造函數(shù)）。對(duì)于任意一個(gè)類A，如果不想編寫上述函數(shù)，C++編譯器將自動(dòng)為A產(chǎn)生四個(gè)缺省的函數(shù)，如

? ? ? ? A(void);? ? ? ? //缺省的無(wú)參數(shù)構(gòu)造函數(shù)

? ? ? ? A(const A&a);//缺省的拷貝構(gòu)造函數(shù)

? ? ? ? ~A(void);? ? ? ? //缺省的析構(gòu)函數(shù)

? ? ? ? A &operate =(const A&a);//缺省的賦值函數(shù)?

? ? ? ? 這不禁讓人疑惑，既然能自動(dòng)生成函數(shù)，為什么還要程序員編寫？

? ? ? ? 原因如下：

（1）如果使用“缺省的無(wú)參構(gòu)造函數(shù)”和“缺省的析構(gòu)函數(shù)”，等于放棄了自主“初始化”和“清除”的機(jī)會(huì)，C++發(fā)明人Stroustrup的好心好意白費(fèi)了。

（2）“缺省的拷貝構(gòu)造函數(shù)”和“缺省的賦值函數(shù)”均采用“位拷貝”而非“值拷貝”的方式來(lái)實(shí)現(xiàn)，倘若類中含有指針變量，這兩個(gè)函數(shù)注定將出錯(cuò)。?

? ? ? ? 對(duì)于那些沒有吃夠苦頭的C++程序員，如果他說編寫構(gòu)造函數(shù)、析構(gòu)函數(shù)與賦值函數(shù)很容易，可以不動(dòng)腦筋，表明他的認(rèn)識(shí)還比較膚淺，水平有待提高。

? ? ? ? 本小節(jié)以類String的設(shè)計(jì)與實(shí)現(xiàn)為例，深入闡釋被很多教科書忽視了的道理。String的結(jié)構(gòu)如下：

? ? ? ? class String

? ? ? ? {

? ? ? ? public:

? ? ? ? ? ? ? ? String(const char *str = NULL);? ? ? ? //普通構(gòu)造函數(shù)

? ? ? ? ? ? ? ? String(const String &other);? ? ? ? ? ? ? //拷貝構(gòu)造函數(shù)

? ? ? ? ? ? ? ? ~String(void);? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? //析構(gòu)函數(shù)

? ? ? ? ? ? ? ? String & operate =(const String &other);//賦值函數(shù)

? ? ? ? private:

? ? ? ? ? ? ? ? char *m_data;? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? //用于保存字符串

? ? ? ? };?

2.9.1構(gòu)造函數(shù)和析構(gòu)函數(shù)的起源?

? ? ? ? 作為比C更先進(jìn)的語(yǔ)言，C++提供了更好的機(jī)制來(lái)增強(qiáng)程序的安全性。C++編譯器具有嚴(yán)格的類型安全檢查功能，它幾乎能找出程序中所有的語(yǔ)法問題，這的確幫了程序員的大忙。但是程序通過了編譯檢查并不表示錯(cuò)誤已經(jīng)不存在了，在“錯(cuò)誤”的大家庭里，“語(yǔ)法錯(cuò)誤”的地位只能算是小弟弟。級(jí)別高的錯(cuò)誤通常隱藏的很深，就像狡猾的罪犯，想逮住他可不容易。

? ? ? ? 根據(jù)經(jīng)驗(yàn)，不少難以察覺的程序錯(cuò)誤是由于變量沒有正確初始化或清除造成的，而初始化和清除工作很容易被人遺忘。Stroustrup在設(shè)計(jì)C++語(yǔ)言是充分考慮了這個(gè)問題并很好地予以解決：把對(duì)象初始化工作放在構(gòu)造函數(shù)中，把清楚工作放在析構(gòu)函數(shù)中。當(dāng)對(duì)象被創(chuàng)建時(shí)，構(gòu)造函數(shù)被自動(dòng)執(zhí)行。當(dāng)對(duì)象消亡時(shí)，析構(gòu)函數(shù)被自動(dòng)執(zhí)行。這下就不用擔(dān)心忘了對(duì)象的初始化和清除工作。

? ? ? ? 構(gòu)造函數(shù)與析構(gòu)函數(shù)的名字不能隨便起，必須讓編譯器認(rèn)得出才可以被自動(dòng)執(zhí)行。Stroustrup的命名方式即簡(jiǎn)單又合理：讓構(gòu)造函數(shù)、析構(gòu)函數(shù)與類同名，由于析構(gòu)函數(shù)的目的與構(gòu)造函數(shù)相反，就加前綴‘~’以示區(qū)別。

? ? ? ? 除了名字外，構(gòu)造函數(shù)和析構(gòu)函數(shù)的另一個(gè)特別之處是沒有返回值類型，這與返回值類型為void的函數(shù)不同。構(gòu)造函數(shù)與析構(gòu)函數(shù)的使命非常明確，就像出生與死亡，光溜溜的來(lái)也光溜溜得去。如果沒有返回值類型，那么編譯器將不知所措。為了防止節(jié)外生枝，干脆規(guī)定沒有返回值類型。

2.9.2構(gòu)造函數(shù)的初始化表?

? ? ? ? 構(gòu)造函數(shù)有個(gè)特殊的初始化方式叫“初始化表達(dá)式表”（簡(jiǎn)稱初始化表）。初始化表位于函數(shù)參數(shù)表之后，卻在函數(shù)體{}之前。這說明該表里的初始化工作發(fā)生在函數(shù)體內(nèi)的任何代碼被執(zhí)行之前。

? ? ? ? 構(gòu)造函數(shù)初始化表的使用規(guī)則：

• 如果類存在繼承關(guān)系，派生類必須在其初始化表里調(diào)用基類的構(gòu)造函數(shù)。?

? ? ? ? 例如：

class A
{
    ...
    A(int x);    //A的構(gòu)造函數(shù)
};

class B : public A
{
    ...
    B(int x, int y);//B的構(gòu)造函數(shù)
};

B::B(int x, int y)
  :A(x)                //在初始化表里調(diào)用A的構(gòu)造函數(shù)
{
    ...
}

• 類的const常量只能在初始化表里備初始化，因?yàn)樗荒茉俸瘮?shù)體內(nèi)用賦值的方式來(lái)初始化（詳見2.5.4節(jié)）。
• 類的數(shù)據(jù)成員的初始化可以采用初始化表或函數(shù)體內(nèi)賦值的兩種方式，這兩種方式的效率不完全相同。?

? ? ? ? 非內(nèi)部數(shù)據(jù)類型的成員對(duì)象應(yīng)當(dāng)采用第一種方式初始化，以獲取更高的效率。例如：

class A
{
    ...
    A(void);    //無(wú)參的構(gòu)造函數(shù)
    A(const A &other);//拷貝構(gòu)造函數(shù)
    A & operate =(const A & other);//賦值函數(shù)
};

class B
{
public:
    B(const A &a);    //B的構(gòu)造函數(shù)
private:
    A m_a;            //成員對(duì)象
};

? ? ? ? 示例a中，類B的構(gòu)造函數(shù)在其初始化表里調(diào)用了類A的拷貝構(gòu)造函數(shù)，從而將成員對(duì)象m_a初始化。

? ? ? ? 示例b中，類B的構(gòu)造函數(shù)在函數(shù)體內(nèi)用賦值的方式將成員對(duì)象m_a初始化。我們看到的只是一條賦值語(yǔ)句，但實(shí)際上B的構(gòu)造函數(shù)干了兩件事：先暗地里創(chuàng)建m_a對(duì)象（調(diào)用了A的無(wú)參數(shù)構(gòu)造函數(shù)），再調(diào)用類A的賦值函數(shù)，將參數(shù)a賦給m_a。

//示例a
B::B(const A&a)
    :m_a(a)
{
    ...
}

示例b
B::B(const A&a)
{
    m_a = a;
    ...
}

? ? ? ? 對(duì)于內(nèi)部數(shù)據(jù)類型的數(shù)據(jù)成員而言，兩種初始化方式的效率幾乎沒有區(qū)別，但后者的板式似乎更加清晰些。若類F的聲明如下：?

class F
{
public:
    F(int x, int y);    //構(gòu)造函數(shù)
private:
    int m_x, m_y;
    int m_i, m_j;
};

? ? ? ? 示例c中F的構(gòu)造函數(shù)采用了第一種初始化方式，示例d中F的構(gòu)造函數(shù)采用了第二種初始化方式。

//示例c
F::F(int x, int y)
    :m_x(x), m_y(y)
{
    m_i = 0;
    m_j = 0;
}

//示例d
F::F(int x, int y)
{
    m_x = x;
    m_y = y;
    m_i = 0;
    m_j = 0;
}

2.9.3構(gòu)造和析構(gòu)的次序?

? ? ? ? 構(gòu)造從類層次的最根處開始，在每一層中，首先調(diào)用基類的構(gòu)造函數(shù)，然后調(diào)用成員對(duì)象的構(gòu)造函數(shù)。析構(gòu)則嚴(yán)格按照與構(gòu)造相反的次序，該次序是唯一的，否則編譯器將無(wú)法自動(dòng)執(zhí)行析構(gòu)過程。

? ? ? ? 一個(gè)有趣的現(xiàn)象是，成員對(duì)象初始化的次序完全不受它們?cè)诔跏蓟碇写涡虻挠绊?，只由成員對(duì)象在類中聲明的次序決定。這是因?yàn)轭惖穆暶魇俏ㄒ坏?，而類的?gòu)造函數(shù)可以有多個(gè)，因此會(huì)有多個(gè)不同次序的初始化表。如果成員對(duì)象按照初始化表的次序進(jìn)行構(gòu)造，這將導(dǎo)致析構(gòu)函數(shù)無(wú)法得到唯一的逆序。

2.9.4示例：類String的構(gòu)造函數(shù)和析構(gòu)函數(shù)

//String的普通構(gòu)造函數(shù)
String::String(const char *str)
{
    if(str == NULL)
    {
        m_data = new char[1];
        *m_data = '\0';
    }
    else
    {
        int lenth = strlen(str);
        m_data = new char[lenth + 1];
        strcpy(m_data, str);
    }
}

//String的析構(gòu)函數(shù)
String::~String(void)
{
    delete [] m_data;
    //由于m_data是內(nèi)部數(shù)據(jù)類型，也可以寫成delete m_data;
}

2.9.5不要輕視拷貝構(gòu)造函數(shù)與賦值函數(shù)?

? ? ? ? 由于并非所有的對(duì)象都會(huì)使用拷貝構(gòu)造函數(shù)和賦值函數(shù)，程序員可能對(duì)這兩個(gè)函數(shù)有些輕視。請(qǐng)先記住以下警告，在閱讀正文時(shí)就會(huì)多心：?

• 本節(jié)開頭講過，如果不主動(dòng)編寫拷貝構(gòu)造函數(shù)和賦值函數(shù)，編譯器將以“位拷貝”的方式自動(dòng)生成缺省的函數(shù)。倘若類中含有指針變量，那么這兩個(gè)缺省的函數(shù)就隱含了錯(cuò)誤。以類String的兩個(gè)對(duì)象a,b為例，假設(shè)a.m_data的內(nèi)容為“hello”，b.m_data的內(nèi)容為“world”。

? ? ? ? 現(xiàn)將a賦給b，缺省賦值函數(shù)的“位拷貝”意味著執(zhí)行b.m_data = a.m_data。這將造成三個(gè)錯(cuò)誤：一是b.m_data原有的內(nèi)存沒有釋放，造成內(nèi)存泄漏；二是b.m_data和a.m_data指向同一塊內(nèi)存，a或b任何一方變動(dòng)都會(huì)影響另一方；三是在對(duì)象被析構(gòu)是，m_data被釋放了兩次。?

• 拷貝構(gòu)造函數(shù)和賦值函數(shù)非常容易混淆，常導(dǎo)致錯(cuò)寫、錯(cuò)用?？截悩?gòu)造函數(shù)是在對(duì)象被創(chuàng)建時(shí)調(diào)用的，而賦值函數(shù)只能被已經(jīng)存在了的對(duì)象調(diào)用。在以下程序中，第三個(gè)語(yǔ)句和第四個(gè)語(yǔ)句很相似，你分的清那個(gè)調(diào)用了拷貝構(gòu)造函數(shù)，那個(gè)調(diào)用了賦值函數(shù)嗎？?

? ? ? ? String a("hello");

? ? ? ? String b("world");

? ? ? ? String c = a;? ? ? ? //調(diào)用了拷貝構(gòu)造函數(shù)，最好寫成c(a);

? ? ? ? ? ? ? ? c = b;? ? ? ? //調(diào)用了賦值函數(shù)

? ? ? ? 本例中第三個(gè)語(yǔ)句的風(fēng)格較差，宜直接寫成String c(a)以區(qū)別于第四個(gè)語(yǔ)句。?

2.9.6示例：類String的拷貝構(gòu)造函數(shù)與賦值函數(shù)?

//拷貝構(gòu)造函數(shù)
String::String(const String &other)
{
    //允許操作other的私有成員m_data
    int length = strlen(other.m_data);
    m_data = new char[length + 1];
    strcpy(m_data, other.m_data);
}

//賦值函數(shù)
String & String::operate =(const String &other)
{
    //(1)檢查自賦值
    if(this == &other)
    {
        return *this;
    }

    //(2)釋放原有的內(nèi)存資源
    delete [] m_data;

    //(3)分配新的內(nèi)存資源，并復(fù)制內(nèi)容
    int length = strlen(other.m_data);
    m_data = new char[length + 1];
    strcpy(m_data, other.m_data);

    //(4)返回本對(duì)象的引用
    return *this;
}

? ? ? ? 類String拷貝構(gòu)造函數(shù)與普通構(gòu)造函數(shù)（詳見2.9.4）的區(qū)別是：在函數(shù)入口處無(wú)需與NULL進(jìn)行比較，這是因?yàn)椤耙谩辈豢赡苁荖ULL，而“指針”可以為NULL。

? ? ? ? 類String的賦值函數(shù)比構(gòu)造函數(shù)復(fù)雜得多，分四步實(shí)現(xiàn)：

（1）第一步，檢查自賦值。你可能會(huì)認(rèn)為多此一舉，難道有人會(huì)愚蠢的寫出a = a這樣的自賦值語(yǔ)句！的確不會(huì)。但是間接的自賦值仍有可能出現(xiàn)，例如：

//內(nèi)容自賦值
b = a;
...
c = b;
...
a = c

//地址自賦值
b = &a;
...
a = *b;

? ? ? ? 也許有人會(huì)說：“即使出現(xiàn)自賦值，我也可以不理睬，發(fā)不了花點(diǎn)時(shí)間讓對(duì)象賦值自己而已，反正不會(huì)出錯(cuò)！”?

? ? ? ? 它真的說錯(cuò)了?？纯吹诙康膁elete，自殺后還能復(fù)制自己?jiǎn)?？所以，如果發(fā)現(xiàn)自賦值，應(yīng)該馬上終止函數(shù)。注意不要將檢查自賦值的if語(yǔ)句

? ? ? ? if（this == &other）錯(cuò)寫成 if(*this == other)

（2）第二步，用delete釋放原有的內(nèi)存資源。如果現(xiàn)在不釋放，以后就沒有機(jī)會(huì)了，將造成內(nèi)存泄露。

（3）第三步，分配新的內(nèi)存資源 ，并復(fù)制字符串。注意函數(shù)strlen返回的是有效字符串長(zhǎng)度，不包括'\0'。函數(shù)strcpy則連'\0'一起復(fù)制。

（4）第四步，返回本對(duì)象的引用，目的是為了實(shí)現(xiàn)像a = b = c 這樣的鏈?zhǔn)奖磉_(dá)式。注意不要將return *this錯(cuò)寫成return this。那么能否寫成return other呢？效果不是一樣嗎？

? ? ? ? 不可以！因?yàn)槲覀儾恢绤?shù)other的生命周期。有可能other是個(gè)臨時(shí)對(duì)象，在賦值結(jié)束后它馬上消失，那么return other返回的將是垃圾。

2.9.7偷懶的辦法處理拷貝構(gòu)造函數(shù)與賦值函數(shù)?

? ? ? ? 如果我們實(shí)在不想編寫拷貝構(gòu)造函數(shù)和賦值函數(shù)，又不允許別人使用編譯器生成缺省函數(shù)，怎么辦？

? ? ? ? 偷懶的辦法是：只需將拷貝構(gòu)造函數(shù)和賦值函數(shù)聲明為私有函數(shù)，不用編寫代碼。例如：

class A
{
private:
    A(const A&a);    //私有的拷貝構(gòu)造函數(shù)
    A & operate =(const A&a);//私有的賦值函數(shù)
};

? ? ? ? 如果有人試圖編寫如下程序：

? ? ? ? A? ?b(a);? ? ? ? //調(diào)用了私有的拷貝構(gòu)造函數(shù)

? ? ? ? b = a;? ? ? ? ? ?//調(diào)用了私有的賦值函數(shù)?

? ? ? ? 編譯器將指出錯(cuò)誤，因?yàn)橥饨绮豢梢圆僮鰽的私有函數(shù)。?

2.9.8如何在派生類中實(shí)現(xiàn)類的基本函數(shù)?

? ? ? ? 基類的構(gòu)造函數(shù)、析構(gòu)函數(shù)、賦值函數(shù)都不能被派生類繼承。如果類之間存在繼承關(guān)系，在編寫上述基本函數(shù)時(shí)應(yīng)該注意以下事項(xiàng)：

• 派生類的構(gòu)造函數(shù)應(yīng)在其初始化表里調(diào)用基類的構(gòu)造函數(shù)。
• 基類與派生類的析構(gòu)函數(shù)應(yīng)該為虛函數(shù)（即加上virtual關(guān)鍵字）。例如：?

#include <iostream.h>
class Base
{
public:
    virtual ~Base()
    {
        cout << "~Base" << endl;
    }
};

class Derived : public Base
{
public:
    virtual ~Derived()
    {
        cout << "~Derived" << endl;
    }
};

void main()
{
    Base * pB = new Derived;    //upcast;
    delete pB;
}

? ? ? ? 輸出結(jié)果為：

? ? ? ? ~Derived

? ? ? ? ~Base

? ? ? ? 如果析構(gòu)函數(shù)不為虛，那么輸出結(jié)果為

? ? ? ? ~Base

• 在編寫派生類的賦值函數(shù)時(shí)，注意不要忘記對(duì)基類的數(shù)據(jù)成員重新賦值。例如：

class Base
{
public:
    ...
    Base & operate =(const Base &other);    //類Base的賦值函數(shù)
private:
    int m_i, m_j, m_k;
};

class Derived : public Base
{
public:
    ...
    Derived & operate =(const Derived &other);    //類Derived的賦值函數(shù)
private:
    int m_x, m_y, m_z;
};

Derived & Derived::operate=(const Derived &other)
{
    //(1)檢查自賦值
    if(this == &other)
    {
        return *this;
    }

    //(2)對(duì)基類的數(shù)據(jù)成員重新賦值
    Base::operate =(other);    //因?yàn)椴荒苤苯硬僮魉接袛?shù)據(jù)成員

    //(3)對(duì)派生類的成員賦值
    m_x = other.m_x;
    m_y = other.m_y;
    m_z = other.m_z;

    //(4)返回本對(duì)象的引用
    return *this;
}

2.10類的繼承與組合?

? ? ? ? 對(duì)象是類的一個(gè)實(shí)例。如果將對(duì)象比作房子，那么類就是房子的設(shè)計(jì)圖紙。所以面向?qū)ο笤O(shè)計(jì)的重點(diǎn)是類的設(shè)計(jì)，而不是對(duì)象的設(shè)計(jì)。

? ? ? ? 對(duì)于C++程序而言，設(shè)計(jì)孤立的類是比較容易得，難的是正確設(shè)計(jì)基類即派生類。本小節(jié)僅僅論述“繼承”和“組合”的概念。

2.10.1繼承?

? ? ? ? 如果A是基類，B是A的派生類，那么B將繼承A的數(shù)據(jù)和函數(shù)。例如：

class A
{
public:
    void Func1(void);
    void Func2(void);
};

class B : public A
{
public:
    void Func3(void);
    void Func4(void);
};

void main()
{
    B  b;
    b.Func1();    //B從A繼承了函數(shù)Func1
    b.Func2();    //B從A繼承了函數(shù)Func2
    b.Func3();
    b.Func4();
}

? ? ? ? 這個(gè)簡(jiǎn)單的示例程序說明了一個(gè)事實(shí)：C++的“繼承”特性可以提高程序的可福永性。正因?yàn)椤袄^承”太有用 、太容易用，才要防止亂用“繼承”。我們應(yīng)當(dāng)給“繼承”立一些使用規(guī)矩。

• 規(guī)則1：如果類A和類B毫不相關(guān)，不可以為了使B的功能更多些而讓B繼承A的功能和屬性。不要覺得“白吃白不吃”，讓一個(gè)好端端的健壯青年無(wú)緣無(wú)故地吃人參補(bǔ)身體。
• 規(guī)則2：若在邏輯上B是A的一種，則允許B繼承A的功能和屬性。例如男人是人的一種，男孩是男人的一種。那么類Man可以從類Human派生，類Boy可以從類Man派生。?

class Human
{
    ...
};

class Man : public Human
{
    ...
};

class Boy : public Man
{
    ...
};

注意事項(xiàng)：

? ? ? ? 規(guī)則2看起來(lái)很簡(jiǎn)單，但是實(shí)際應(yīng)用時(shí)可能會(huì)有意外，繼承的概念在程序世界與現(xiàn)實(shí)世界并不完全相同。

? ? ? ? 例如從生物學(xué)角度講，鴕鳥是鳥的一種，按理說類Ostrich應(yīng)該可以從類Bird派生。但是鴕鳥不會(huì)飛，那么ostrich::Fly是什么東西？

class Bird
{
public:
    virtual void Fly(void);
    ...
};

class Ostrich : public Bird
{
    ...
};

? ? ? ? 例如從數(shù)學(xué)角度講，圓是一種特殊的橢圓，按理說類Circle應(yīng)該可以從類Ellipse派生。但是橢圓有長(zhǎng)軸和短軸，如果圓繼承了橢圓的長(zhǎng)軸和短軸，豈非畫蛇添足？

? ? ? ? 所以更加嚴(yán)格的繼承規(guī)則應(yīng)當(dāng)是：若在邏輯上B是A的“一種”，并且A的所有功能和屬性對(duì)B而言都有意義，則允許B繼承A的功能和屬性。

2.10.2組合?

• 規(guī)則1：若在邏輯上A是B的一部分，則不允許B從A派生，而是要用A和其它東西組合出B。?

? ? ? ? 例如眼、鼻、口、耳是頭的一部分，所以類Head應(yīng)該由類Eye、Nose、Mouth、Ear組合而成，不是派生而成。如下例所示：

class Eye
{
public:
    void Look(void);
};

class Nose
{
public:
    void Smell(void);
};

class Mouth
{
public:
    void Eat(void);
};

class Ear
{
public:
    void Listen(void);
};


//正確的設(shè)計(jì)，雖然代碼冗長(zhǎng)
class Head
{
public:
    void Look(void){ m_eye.Look();}
    void Smell(void){ m_nose.Smell();}
    void Eat(void){ m_mouth.Eat();}
    void Listen(void){ m_ear.Listen();}

private:
    Eye m_eye;
    Nose m_nose;
    Mouth m_mouth;
    Ear m_ear;
};

? ? ? ? 如果允許Head從Eye、Nose、Mouth、Ear派生而成，那么Head將自動(dòng)具有Look、Smell、Eat、Listen這些功能。下面示例十分簡(jiǎn)短并且運(yùn)行正確，但是這種設(shè)計(jì)方法卻是不對(duì)的。

//功能正確并且代碼簡(jiǎn)潔，但是設(shè)計(jì)方法不對(duì)。
class Head : public Eye, public Nose, public Mouth, public Ear
{
    
};

? ? ? ? 一只公雞使勁地追打一只剛下蛋的母雞，你知道為什么嗎？

? ? ? ? 因?yàn)槟鸽u下了鴨蛋。

? ? ? ? 很多程序員經(jīng)不起“繼承”的誘惑而犯下設(shè)計(jì)錯(cuò)誤?！斑\(yùn)行正確”的程序不見得是高質(zhì)量的程序，此處就是一個(gè)例證。?

2.11其它編程經(jīng)驗(yàn)?

2.11.1使用const提高函數(shù)的健壯性?

? ? ? ? 看到const關(guān)鍵，C++程序員首先想到的可能是const常量。這可不是良好的天劍反射。如果只知道用const定義常量，那么相當(dāng)于把火藥僅用作于制作鞭炮。const更大的魅力是它可以修飾函數(shù)的參數(shù)、返回值，甚至函數(shù)的定義體。

? ? ? ? const是constant的縮寫，“恒定不變”的意思。被const修飾的東西都受到強(qiáng)制保護(hù)，可預(yù)防意外的變動(dòng)，能提高程序的健壯性。所以很多C++程序設(shè)計(jì)書籍建議：“Use const whenever you need”。?

2.11.1.1用const修飾函數(shù)的參數(shù)?

? ? ? ? 如果參數(shù)作輸出用，不論它是什么數(shù)據(jù)類型，也不論它采用“指針傳遞”還是“引用傳遞”，都不能加const修飾，否則該參數(shù)將失去輸出功能。

? ? ? ? const只能修飾輸入?yún)?shù)：

• 如果輸入?yún)?shù)采用“指針傳遞”，那么加const修飾可以防止意外地改動(dòng)該指針，起到保護(hù)作用。例如StringCopy函數(shù)：?

? ? ? ? void StringCopy(char *strDestination,? const char * strSource)；

其中strSource是輸入?yún)?shù)，strDestination是輸出參數(shù)。給strSource加上const修飾后，如果函數(shù)體內(nèi)的語(yǔ)句試圖改動(dòng)strSource的內(nèi)容，編譯器將指出錯(cuò)誤。

• 如果輸入?yún)?shù)采用“值傳遞”，由于函數(shù)將自動(dòng)產(chǎn)生臨時(shí)變量用于復(fù)制該參數(shù)，該輸入?yún)?shù)本來(lái)就無(wú)需保護(hù)，所以不要加const修飾。?

? ? ? ? 例如不要將函數(shù)void Func1(int x)寫成void Func1(const int x)。同理不要將函數(shù)void Func2(A a)寫成void Func2(const A a)。其中A為用戶自定義的數(shù)據(jù)類型。

• 對(duì)于非內(nèi)部數(shù)據(jù)類型的參數(shù)而言，像void Func(A a)這樣聲明的函數(shù)注定效率比較低。因?yàn)楹瘮?shù)體內(nèi)將產(chǎn)生A類型的臨時(shí)對(duì)象用于復(fù)制參數(shù)a，而臨時(shí)對(duì)象的構(gòu)造、復(fù)制、析構(gòu)過程都將消耗時(shí)間。?

? ? ? ? 為了提高效率，可以將函數(shù)聲明改為 void Func(A &a),因?yàn)椤耙脗鬟f”僅借用一下參數(shù)的別名而已，不需要產(chǎn)生臨時(shí)對(duì)象。但是函數(shù)void Func(A &a)存在一個(gè)缺點(diǎn)：“引用傳遞”有可能改變參數(shù)a，這是我們不期望的。解決這個(gè)問題很容易，加上const修飾即可，因此函數(shù)最終成為void Func(const A & a)。

? ? ? ? 以此類推，是否應(yīng)將void Func(int x)改寫為void Func(const int &x)，以便提高效率？完全沒有必要，因?yàn)閮?nèi)部數(shù)據(jù)類型的參數(shù)不存在構(gòu)造、析構(gòu)的過程，而復(fù)制也非?？?，“值傳遞”和“引用傳遞”的效率幾乎相當(dāng)。

? ? ? ? 問題是如此的纏綿，我只好將“const &”修飾輸入?yún)?shù)的用法總結(jié)一下，如下表所示：

2.11.1.2用const修飾函數(shù)的返回值?

• 如果給以“指針傳遞”的方式的函數(shù)返回值加const修飾，那么函數(shù)返回值（即指針）的內(nèi)容不能被修改，該返回值只能被賦給加const修飾的同類型指針。

? ? ? ? 例如函數(shù)：const char * GetString(void);

? ? ? ? 如下語(yǔ)句將出現(xiàn)編譯錯(cuò)誤：char *str = GetString();

? ? ? ? 正確的用法是：const char *str = GetString();?

• ?如果函數(shù)返回值采用“值傳遞方式”，由于函數(shù)會(huì)把 返回值賦值到外部臨時(shí)的存儲(chǔ)單元中，加const修飾沒有任何價(jià)值。

? ? ? ? 例如不要把函數(shù)int GetInt(void)寫成const int GetInt(void)。

? ? ? ? 同理不要把函數(shù)A GetA(void)寫成const AGetA(void),其中A為用戶自定義的數(shù)據(jù)類型。

? ? ? ? 如果返回值不是內(nèi)部數(shù)據(jù)類型，將函數(shù)A GetA(void)改寫為const A &GetA(void)的確能提高效率。但此時(shí)千萬(wàn)千萬(wàn)要小心，一定要搞清楚函數(shù)究竟是想返回一個(gè)對(duì)象的“拷貝”還是僅返回“別名”就可以了，否則程序會(huì)出錯(cuò)，詳見2.6.2節(jié)“返回值的規(guī)則”。

• 函數(shù)返回值采用“引用傳遞”的場(chǎng)合并不多，這種方式一般只出現(xiàn)在類的賦值函數(shù)中，目的是為了實(shí)現(xiàn)鏈?zhǔn)奖磉_(dá)式。?

? ? ? ? 例如：

? ? ? ? class A

? ? ? ? {

? ? ? ? ? ? ? ? A & operate = (const A &other);? ? ? ? //賦值函數(shù)

????????};?

? ? ? ? A a, b, c;? ? ? ? //a,b,c為A的對(duì)象

? ? ? ? ...

? ? ? ? a = b = c;? ? ? ?//正常的鏈?zhǔn)奖磉_(dá)式

? ? ? ? (a = b) = c;? ? ? ? //不正常的鏈?zhǔn)奖磉_(dá)式，但合法

? ? ? ? 如果將賦值函數(shù)的返回值加const修飾，那么該返回值的內(nèi)容不允許被改動(dòng)。上例中，語(yǔ)句a = b = c;仍然正確，但是語(yǔ)句(a = b) = c;則是非法的。

2.11.1.3const成員函數(shù)?

? ? ? ? ?任何不會(huì)修該數(shù)據(jù)成員的函數(shù)都應(yīng)該聲明為const類型。如果在編寫const成員函數(shù)時(shí)，不慎修改了數(shù)據(jù)成員，或者調(diào)用了其它非const成員函數(shù)，編譯器將指出錯(cuò)誤，這無(wú)疑會(huì)提高程序的健壯性。以下程序中，類stack的成員函數(shù)GetCount僅用于計(jì)數(shù)，從邏輯上講GetCount應(yīng)當(dāng)為const函數(shù)。編譯器將指出GetCount函數(shù)中的錯(cuò)誤。

class Stack
{
public:
    void Push(int elem);
    int Pop(void);
    int GetCount(void) const;    //const成員函數(shù)
    
ptivate:
    int m_num;
    int m_data[100];
};

int Stack::GetCount(void) const
{
    ++m_num;    //編譯錯(cuò)誤，企圖修改數(shù)據(jù)成員m_num
    Pop();      //編譯錯(cuò)誤，企圖調(diào)用非const函數(shù)
    return m_num;
}

? ? ? ? const成員函數(shù)的聲明看起來(lái)怪怪的：const關(guān)鍵字只能放在函數(shù)聲明的尾部，大概是因?yàn)槠渌胤蕉家呀?jīng)被占用了。?

2.11.2提高程序效率?

? ? ? ? 程序的時(shí)間效率是指運(yùn)行速度，空間效率是指程序占用內(nèi)存或者外存的狀況。

? ? ? ? 全局效率是指站在整個(gè)系統(tǒng)的角度上考慮的效率，局部效率是指站在模塊或函數(shù)角度上考慮的效率。

• 規(guī)則1：不要一味地追求程序的效率，應(yīng)當(dāng)滿足正確性、可靠性、健壯性、可讀性等質(zhì)量因素的前提下，設(shè)法提高程序的效率。
• 規(guī)則2：以提高程序的全局效率為主，提高局部效率為輔。
• 規(guī)則3：在優(yōu)化程序的效率時(shí)，應(yīng)當(dāng)先找出限制效率的“瓶頸”，不要在無(wú)關(guān)緊要之處優(yōu)化。
• 規(guī)則4：先優(yōu)化數(shù)據(jù)結(jié)構(gòu)和算法，在優(yōu)化執(zhí)行代碼。
• 規(guī)則5：有時(shí)候時(shí)間效率和空間效率可能對(duì)立，此時(shí)應(yīng)當(dāng)要分析那個(gè)更重要，作出適當(dāng)?shù)恼壑小＠绺慌痘ㄙM(fèi)一些內(nèi)存來(lái)提高性能。
• 規(guī)則6：不要追求緊湊的代碼，因?yàn)榫o湊的代碼并不能產(chǎn)生高效的機(jī)器碼。?

2.11.3一些有益的建議?

????????建議1：當(dāng)心哪些視覺上不易分辨的操作符發(fā)生書寫錯(cuò)誤。?

? ? ? ? 我們經(jīng)常會(huì)把“==”誤寫成“=”，像“||”、“&&”、“<=”、“>=”這類符號(hào)也很容易出現(xiàn)丟“1”失誤。然而編譯器卻不一定能自動(dòng)指出這類錯(cuò)誤。

????????建議2：變量（指針、數(shù)組）被創(chuàng)建之后應(yīng)當(dāng)及時(shí)把它們初始化，以防止把未被初始化的變量當(dāng)成右值使用。

? ? ? ? 建議3：當(dāng)心變量的初值、缺省值錯(cuò)誤，或者精度不夠。

? ? ? ? 建議4：當(dāng)心數(shù)據(jù)類型轉(zhuǎn)換發(fā)生錯(cuò)誤。盡量使用顯式的數(shù)據(jù)類型轉(zhuǎn)換（讓人們知道發(fā)生了什么事），避免讓編譯器輕悄悄地進(jìn)行隱式的數(shù)據(jù)類型轉(zhuǎn)換。

? ? ? ? 建議5：當(dāng)心變量發(fā)生上溢或下溢，數(shù)組的下標(biāo)越界。

? ? ? ? 建議6：當(dāng)心忘記編寫錯(cuò)誤處理程序，當(dāng)心錯(cuò)誤處理程序本身有誤。

? ? ? ? 建議7：當(dāng)心文件I/O有錯(cuò)誤。

? ? ? ? 建議8：避免編寫技巧性很高的代碼。

? ? ? ? 建議9：不要設(shè)計(jì)面面俱到、非常靈活的數(shù)據(jù)結(jié)構(gòu)。

? ? ? ? 建議10：如果原有的代碼質(zhì)量比較好，盡量復(fù)用它。但是不要修補(bǔ)很差勁的代碼，應(yīng)當(dāng)重新編寫。

? ? ? ? 建議11：盡量使用標(biāo)準(zhǔn)庫(kù)函數(shù)，不要“發(fā)明”已經(jīng)存在的庫(kù)函數(shù)。

? ? ? ? 建議12：盡量不要使用與具體硬件或軟件環(huán)境關(guān)系密切的變量。

? ? ? ? 建議13：把編譯器的選擇項(xiàng)設(shè)置為最嚴(yán)格狀態(tài)。

? ? ? ? 建議14：如果可能的話，使用PC-Lint、LogiScope等工具進(jìn)行代碼審查。?文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-842802.html

到了這里，關(guān)于高質(zhì)量C/C++編程指南的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！