面向?qū)ο笫荂++的重要特性.?
但是c++在c的基礎(chǔ)上新增加的幾點(diǎn)優(yōu)化也是很耀眼的?
就const直接可以取代c中的#define?
以下幾點(diǎn)很重要,學(xué)不好后果也也很嚴(yán)重?

const?
1. 限定符聲明變量只能被讀?
? const int i=5;?
? int j=0;?
? ...?
? i=j;? //非法，導(dǎo)致編譯錯(cuò)誤?
? j=i;? //合法?
2. 必須初始化?
? const int i=5;? ? //合法?
? const int j;? ? ? //非法，導(dǎo)致編譯錯(cuò)誤?
3. 在另一連接文件中引用const常量?
? extern const int i;? ? //合法?
? extern const int j=10;? //非法，常量不可以被再次賦值?
4. 便于進(jìn)行類型檢查?
? 用const方法可以使編譯器對(duì)處理內(nèi)容有更多了解。?
? #define I=10?
? const long &i=10;? /*dapingguo提醒：由于編譯器的優(yōu)化，使?
? ? ? 得在const long i=10; 時(shí)i不被分配內(nèi)存，而是已10直接代入?
? ? ? 以后的引用中，以致在以后的代碼中沒有錯(cuò)誤，為達(dá)到說教效?
? ? ? 果，特別地用&i明確地給出了i的內(nèi)存分配。不過一旦你關(guān)閉所?
? ? ? 有優(yōu)化措施，即使const long i=10;也會(huì)引起后面的編譯錯(cuò)誤。*/?
? char h=I;? ? ? //沒有錯(cuò)?
? char h=i;? ? ? //編譯警告，可能由于數(shù)的截短帶來錯(cuò)誤賦值。?
5. 可以避免不必要的內(nèi)存分配?
? #define STRING "abcdefghijklmnn"?
? const char string[]="abcdefghijklmn";?
? ...?
? printf(STRING);? //為STRING分配了第一次內(nèi)存?
? printf(string);? //為string一次分配了內(nèi)存，以后不再分配?
? ...?
? printf(STRING);? //為STRING分配了第二次內(nèi)存?
? printf(string);?
? ...?
? 由于const定義常量從匯編的角度來看，只是給出了對(duì)應(yīng)的內(nèi)存地址，?
? 而不是象#define一樣給出的是立即數(shù)，所以，const定義的常量在?
? 程序運(yùn)行過程中只有一份拷貝，而#define定義的常量在內(nèi)存中有?
? 若干個(gè)拷貝。?
6. 可以通過函數(shù)對(duì)常量進(jìn)行初始化?
? int value();?
? const int i=value();?
? dapingguo說：假定對(duì)ROM編寫程序時(shí)，由于目標(biāo)代碼的不可改寫，?
? 本語句將會(huì)無效，不過可以變通一下：?
? const int &i=value();?
? 只要令i的地址處于ROM之外，即可實(shí)現(xiàn)：i通過函數(shù)初始化，而其?
? 值有不會(huì)被修改。?
7. 是不是const的常量值一定不可以被修改呢？?
? 觀察以下一段代碼：?
? const int i=0;?
? int *p=(int*)&i;?
? p=100;?
? 通過強(qiáng)制類型轉(zhuǎn)換，將地址賦給變量，再作修改即可以改變const常量值。?
8. 請(qǐng)分清數(shù)值常量和指針常量，以下聲明頗為玩味：?
? int ii=0;?
? const int i=0;? ? ? ? ? ? //i是常量，i的值不會(huì)被修改?
? const int *p1i=&i;? ? ? ? //指針p1i所指內(nèi)容是常量，可以不初始化?
? int? * const p2i=ⅈ? ? //指針p2i是常量，所指內(nèi)容可修改?
? const int * const p3i=&i; //指針p3i是常量，所指內(nèi)容也是常量?
? p1i=ⅈ? ? ? ? ? ?? ? ? //合法?
? *p2i=100;? ? ? ? ? ? ?? //合法?
關(guān)于C++中的const關(guān)鍵字的用法非常靈活，而使用const將大大改善程序的健壯性，參考了康建東兄的const使用詳解一文，對(duì)其中進(jìn)行了一些補(bǔ)充，寫下了本文。?


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

2.? ? ? const 修飾類的數(shù)據(jù)成員。如：?
class A?

{?

? ? const int size;?

? ? …?

}?

const 數(shù)據(jù)成員只在某個(gè)對(duì)象生存期內(nèi)是常量，而對(duì)于整個(gè)類而言卻是可變的。因?yàn)轭惪梢詣?chuàng)建多個(gè)對(duì)象，不同的對(duì)象其const數(shù)據(jù)成員的值可以不同。所以不能在類 聲明中初始化const數(shù)據(jù)成員，因?yàn)轭惖膶?duì)象未被創(chuàng)建時(shí)，編譯器不知道const 數(shù)據(jù)成員的值是什么。如?

class A?

{?

const int size = 100;? ? //錯(cuò)誤?

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

}?

const數(shù)據(jù)成員的初始化只能在類的構(gòu)造函數(shù)的初始化表中進(jìn)行。要想建立在整個(gè)類中都恒定的常量，應(yīng)該用類中的枚舉常量來實(shí)現(xiàn)。如?

class A?

{…?

enum {size1=100, size2 = 200 };?

int array1[size1];?

int array2[size2];?

}?

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

3.? ? ? const修飾指針的情況，見下式：?

int b = 500;?
const int* a = &? ? ? ? ? [1]?
int const *a = &? ? ? ? ? [2]?
int* const a = &? ? ? ? ? [3]?
const int* const a = &? ? [4]?
如 果你能區(qū)分出上述四種情況，那么，恭喜你，你已經(jīng)邁出了可喜的一步。不知道，也沒關(guān)系，我們可以參考《Effective c++》Item21上的做法，如果const位于星號(hào)的左側(cè)，則const就是用來修飾指針?biāo)赶虻淖兞?，即指針指向?yàn)槌Ａ?；如果const位于星號(hào)的 右側(cè)，const就是修飾指針本身，即指針本身是常量。因此，[1]和[2]的情況相同，都是指針?biāo)赶虻膬?nèi)容為常量（const放在變量聲明符的位置無 關(guān)），這種情況下不允許對(duì)內(nèi)容進(jìn)行更改操作，如不能*a = 3 ；[3]為指針本身是常量，而指針?biāo)赶虻膬?nèi)容不是常量，這種情況下不能對(duì)指針本身進(jìn)行更改操作，如a++是錯(cuò)誤的；[4]為指針本身和指向的內(nèi)容均為常 量。?

4.? ? const的初始化?
先看一下const變量初始化的情況?
1) 非指針const常量初始化的情況：A b;?
const A a = b;?
2) 指針const常量初始化的情況：?

A* d = new A();?
const A* c = d;?
或者：const A* c = new A();?
3）引用const常量初始化的情況：?
A f;?
const A& e = f;? ? ? // 這樣作e只能訪問聲明為const的函數(shù)，而不能訪問一? ? ? ? ? ??

般的成員函數(shù)；?
? ? [思考1]： 以下的這種賦值方法正確嗎？?
? ? const A* c=new A();?
? ? A* e = c;?
? ? [思考2]： 以下的這種賦值方法正確嗎？?
? ? A* const c = new A();?
? ? A* b = c;?

5.? ? 另外const 的一些強(qiáng)大的功能在于它在函數(shù)聲明中的應(yīng)用。在一個(gè)函數(shù)聲明中，const 可以修飾函數(shù)的返回值，或某個(gè)參數(shù)；對(duì)于成員函數(shù)，還可以修飾是整個(gè)函數(shù)。有如下幾種情況，以下會(huì)逐漸的說明用法：A& operator=(const A& a);?
void fun0(const A* a );?
void fun1( ) const; // fun1( ) 為類成員函數(shù)?
const A fun2( );?

1） 修飾參數(shù)的const，如 voidfun0(const A* a ); void fun1(const A& a);?
調(diào) 用函數(shù)的時(shí)候，用相應(yīng)的變量初始化const常量，則在函數(shù)體中，按照const所修飾的部分進(jìn)行常量化，如形參為const A* a，則不能對(duì)傳遞進(jìn)來的指針的內(nèi)容進(jìn)行改變，保護(hù)了原指針?biāo)赶虻膬?nèi)容；如形參為const A& a，則不能對(duì)傳遞進(jìn)來的引用對(duì)象進(jìn)行改變，保護(hù)了原對(duì)象的屬性。?
[注意]：參數(shù)const通常用于參數(shù)為指針或引用的情況，且只能修飾輸入?yún)?shù);若輸入?yún)?shù)采用“值傳遞”方式，由于函數(shù)將自動(dòng)產(chǎn)生臨時(shí)變量用于復(fù)制該參數(shù)，該參數(shù)本就不需要保護(hù)，所以不用const修飾。?

[總結(jié)]對(duì)于非內(nèi)部數(shù)據(jù)類型的輸入?yún)?shù)，因該將“值傳遞”的方式改為“const引用傳遞”，目的是為了提高效率。例如，將void Func(A a)改為void Func(const A &a)?

? ? ? 對(duì)于內(nèi)部數(shù)據(jù)類型的輸入?yún)?shù)，不要將“值傳遞”的方式改為“const引用傳遞”。否則既達(dá)不到提高效率的目的，又降低了函數(shù)的可理解性。例如void Func(int x)不應(yīng)該改為void Func(const int &x)?

2）? 修飾返回值的const，如const A fun2( ); const A* fun3();?
這樣聲明了返回值后，const按照"修飾原則"進(jìn)行修飾，起到相應(yīng)的保護(hù)作用。const Rationaloperator*(const Rational& lhs, const Rational& rhs)?
{?
return Rational(lhs.numerator() * rhs.numerator(),?
lhs.denominator() * rhs.denominator());?
}?
返回值用const修飾可以防止允許這樣的操作發(fā)生:Rational a,b;?
Radional c;?
(a*b) = c;?
一般用const修飾返回值為對(duì)象本身（非引用和指針）的情況多用于二目操作符重載函數(shù)并產(chǎn)生新對(duì)象的時(shí)候。?
[總結(jié)]?

1.? ? 一般情況下，函數(shù)的返回值為某個(gè)對(duì)象時(shí)，如果將其聲明為const時(shí)，多用于操作符的重載。通常，不建議用const修飾函數(shù)的返回值類型為某個(gè)對(duì)象或?qū)?某個(gè)對(duì)象引用的情況。原因如下：如果返回值為某個(gè)對(duì)象為const（const A test = A 實(shí)例）或某個(gè)對(duì)象的引用為const（const A& test = A實(shí)例） ，則返回值具有const屬性，則返回實(shí)例只能訪問類A中的公有（保護(hù)）數(shù)據(jù)成員和const成員函數(shù)，并且不允許對(duì)其進(jìn)行賦值操作，這在一般情況下很少 用到。?

2.? ? ? 如果給采用“指針傳遞”方式的函數(shù)返回值加const修飾，那么函數(shù)返回值（即指針）的內(nèi)容不能被修改，該返回值只能被賦給加const 修飾的同類型指針。如：?

const char * GetString(void);?

如下語句將出現(xiàn)編譯錯(cuò)誤：?

char *str=GetString();?

正確的用法是：?

const char *str=GetString();?

3.? ? 函數(shù)返回值采用“引用傳遞”的場合不多，這種方式一般只出現(xiàn)在類的賻值函數(shù)中，目的是為了實(shí)現(xiàn)鏈?zhǔn)奖磉_(dá)。如：?

class A?

{…?

A &operate = (const A &other);? //負(fù)值函數(shù)?

}?
A a,b,c;? ? ? ? ? ? ? //a,b,c為A的對(duì)象?

…?

a=b=c;? ? ? ? ? ? //正常?

(a=b)=c;? ? ? ? ? //不正常，但是合法?

若負(fù)值函數(shù)的返回值加const修飾，那么該返回值的內(nèi)容不允許修改，上例中a=b=c依然正確。(a=b)=c就不正確了。?
[思考3]： 這樣定義賦值操作符重載函數(shù)可以嗎？?
const A& operator=(const A& a);?

6.? ? 類成員函數(shù)中const的使用?
一般放在函數(shù)體后，形如：void fun() const;?
任何不會(huì)修改數(shù)據(jù)成員的函數(shù)都因該聲明為const類型。如果在編寫const成員函數(shù)時(shí)，不慎修改了數(shù)據(jù)成員，或者調(diào)用了其他非const成員函數(shù)，編譯器將報(bào)錯(cuò)，這大大提高了程序的健壯性。如：?

class Stack?

{?

public:?

? ? ? void Push(int elem);?

? ? ? int Pop(void);?

? ? ? int GetCount(void) const;? //const 成員函數(shù)?

private:?

? ? ? 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;?

}?

7.? ? ? 使用const的一些建議?
1 要大膽的使用const，這將給你帶來無盡的益處，但前提是你必須搞清楚原委；?
2 要避免最一般的賦值操作錯(cuò)誤，如將const變量賦值，具體可見思考題；?
3 在參數(shù)中使用const應(yīng)該使用引用或指針，而不是一般的對(duì)象實(shí)例，原因同上；?
4 const在成員函數(shù)中的三種用法（參數(shù)、返回值、函數(shù)）要很好的使用；?
5 不要輕易的將函數(shù)的返回值類型定為const;?
6除了重載操作符外一般不要將返回值類型定為對(duì)某個(gè)對(duì)象的const引用;?
[思考題答案]?
1 這種方法不正確，因?yàn)槁暶髦羔樀哪康氖菫榱藢?duì)其指向的內(nèi)容進(jìn)行改變，而聲明的指針e指向的是一個(gè)常量，所以不正確；?
2 這種方法正確，因?yàn)槁暶髦羔標(biāo)赶虻膬?nèi)容可變；?
3 這種做法不正確；?
在const A::operator=(const A&a)中，參數(shù)列表中的const的用法正確，而當(dāng)這樣連續(xù)賦值的時(shí)侯，問題就出現(xiàn)了：?
A a,b,c:?
(a=b)=c;?
因?yàn)閍.operator=(b)的返回值是對(duì)a的const引用，不能再將c賦值給const常量。

?

?

1.1.1. 定義普通常量
使用#define來定義常量也是常用方法，但const也可以用來定義常量，在[Effective C++]中建議使用const代替#define來定義常量，因?yàn)閏onst定義的常量具有類型信息，而宏沒有，所以使用const定義的常量在進(jìn)行賦值操作時(shí)編譯器會(huì)進(jìn)行更嚴(yán)格的類型檢查，是類型安全的。

constdouble PI = 3.1414926;

constint POOL_SIZE = 20;

定義常量有三種方法：宏、const、enum，其中宏應(yīng)該盡量避免，而const與enum也各有優(yōu)缺點(diǎn)，最大的區(qū)別就是enum只能用于定義整數(shù)，而不能定義浮點(diǎn)數(shù)；而對(duì)于定義邏輯關(guān)系較近的一組整數(shù)時(shí)比較適合使用enum，也可以考慮使用類代替enum(參見[??])。

常量必須在定義時(shí)進(jìn)行初始化，之后便不能再賦值。說它不能被賦值并不是說常量的值是絕對(duì)不會(huì)改變的，只是說不能直接賦值，但可以通過指針及強(qiáng)制類型轉(zhuǎn)換、const_cast是可以改變常量的值的。

#include

usingnamespace std;

intmain( void )

{

constint ci = 5;

constint* cpci = &ci;

int*pci = (int*)&ci;

cout<<"cpci= "<

return0;

}

輸出結(jié)果：

cpci =002DFAC8, pci = 002DFAC8

ci=5,*cpci=1, *pci=1

ci=5,*cpci=2, *pci=2

ci !=*cpci

之所以使用ci直接輸出變量的值時(shí)顯示其值始終沒有改變，但通過指針間接顯示出來的值是改變了，而且輸出結(jié)果的最后一行很奇怪，ci的值與*cpci的值居然不相等，只因?yàn)榫幾g器在編譯時(shí)進(jìn)行了優(yōu)化，將代碼中的ci直接替換成了5，與宏替換是相同的效果，而指針的值則是實(shí)際內(nèi)存中的值。

所以，千萬不要試圖使用指針強(qiáng)行改變const變量的值，否則程序可能表現(xiàn)出錯(cuò)誤的行為，而且查找起來這種錯(cuò)誤非常困難。在gcc 4.3.4和visualC++ 2010中均默認(rèn)打開了對(duì)常量的優(yōu)化選項(xiàng)，目前還沒找到關(guān)閉該優(yōu)化的命令行選項(xiàng)，一定不要自作聰明去改const變量的值。

1.1.2. 修飾指針
把const與指針放到一起，很多人便會(huì)想到一個(gè)繞口令“指針常量與常量指針?！爸羔槼Ａ俊奔匆粋€(gè)指針變量，該變量不能被賦值，而指針指向的內(nèi)存單元的內(nèi)容是可以改變的；“常量指針”即一個(gè)指向常量的指針，指針變量本身可以賦值，而指針指向的內(nèi)存單元的內(nèi)容是不可以被重新賦值的。

char a= 'A', b = 'B';

constchar* ptoc = &a; // 常量指針

*ptoc ='C'; // 改變指針指向內(nèi)存單元的內(nèi)容，不可以

ptoc =&b; // 改變指針的值，可以

char*const cp = &a; // 指針常量

cp =&b; // 改變指針的值，不可以

*cp ='D'; // 改變指針指向內(nèi)存單元的內(nèi)容，可以

constchar* const cptoc = &a; // 指向常量的指針常量

*cptoc= 'E'; // 不可以

cptoc =&b; // 不可以

const是修飾類型還是修飾指針，要看const的位置，放在*前就是修飾數(shù)據(jù)類型，放到*后就是修飾指針，constchar和charconst是一樣的。

建議：在不打算修改數(shù)據(jù)內(nèi)容的時(shí)候都將指針定義成常量指針，不打算指針本身被修改的場合都定義成指針常量。盡可能地多用const，用錯(cuò)了沒關(guān)系，編譯器會(huì)提示你的，只要能夠編譯通過，就不會(huì)因?yàn)橛缅e(cuò)const而導(dǎo)致程序邏輯錯(cuò)誤，應(yīng)該說const負(fù)作用極小。

1.1.3. 修飾類成員常量
當(dāng)使用const修飾類成員變量時(shí)便定義了常數(shù)據(jù)成員，它的使用與使用類外定義的常量本質(zhì)上并沒有什么區(qū)別，在這里只想指出一點(diǎn)：有網(wǎng)友提到const數(shù)據(jù)成員只能被const修飾的函數(shù)使用這是沒有根據(jù)的，是錯(cuò)誤的。

1.1.4. 修飾類成員函數(shù)
const修飾成員函數(shù)語法：

classSocket

{

public:

typedefunsigned short socket_port_t;

socket_port_tLocalPort( void ) const

{

++readCount;

return_port;

}

private:

socket_port_t_port;

mutableint _readCount;

};

使用const修飾的成員函數(shù)不能修改類的成員變量，如成員_port，而且只能調(diào)用成員類對(duì)象const函數(shù)，但有個(gè)例外，就是mutable修飾的成員變量可以在const修飾的成員函數(shù)中被修改，如_readCount。

另外，const只能修飾非靜態(tài)函數(shù)。

建議：將所有不改變對(duì)象狀態(tài)的函數(shù)都使用const修飾符標(biāo)識(shí)，以提高程序的可讀性。其實(shí)，頭文件就是最好的類接口的說明文檔，越多的提供信息就能使程序的可讀性越好，越利于維護(hù)?？吹匠蓡T函數(shù)的const修飾符，讀者便立即明白該函數(shù)不會(huì)改變程序的狀態(tài)，這也有利于當(dāng)程序狀態(tài)出現(xiàn)異常時(shí)的問題定位。

1.1.5. 修飾類對(duì)象、對(duì)象引用或?qū)ο笾羔槪ǔＡ恐羔槪?br />當(dāng)const修飾自定義的類對(duì)象時(shí)，與修飾C++內(nèi)置類型的變量的思想是一致的，但稍有不同，除了不能被賦值外，還不能調(diào)用沒有使用const修飾的非靜態(tài)成員函數(shù)。當(dāng)const修飾類對(duì)象引用、指針時(shí)限制是一樣的，因?yàn)橐帽旧砼c直接使用該變量實(shí)質(zhì)上沒有區(qū)別，而使用指針只是將.操作符改為了->本質(zhì)上還是一樣的

conststd::string hello = “Hello from Noock Tian;

std::cout<

hello ="Hi"; // 不可以賦值

hello.push_back("!");// 不可以

1.1.6. 修飾函數(shù)參數(shù)
const修飾函數(shù)的例子是很常見了，表示函數(shù)的參數(shù)在函數(shù)體內(nèi)不會(huì)被意外修改，一般用于修飾輸入?yún)?shù)，例如標(biāo)準(zhǔn)庫中的字符串連接函數(shù)。str1是輸出參數(shù)，其內(nèi)容會(huì)被修改，而str2為輸入?yún)?shù)，其內(nèi)容不會(huì)修改。

char*strcat(char* str1, const char* str2);

實(shí)際上在說到const用法一開始就提到，const只是一種聲明，但并不能保證，例如strcat函數(shù)雖然聲明了str2為constchar*型，但并不能保證內(nèi)部絕對(duì)不會(huì)修改str2的內(nèi)容。但const從語言本身提供了一種編寫自描述性代碼的方法，只要使用函數(shù)與實(shí)現(xiàn)函數(shù)的雙方都達(dá)成一致的約定，按照契約編程，我們就可以認(rèn)為const修飾的類型在函數(shù)體內(nèi)不會(huì)被修改，這與const修飾類成員函數(shù)一樣，可以提高軟件的可讀性。

1.1.7. 修飾函數(shù)返回值
const可以用于修飾任何類型，只要返回值類型不是void，const就可以用來修飾返回值的類型。但實(shí)際上const用于修飾非引用的返回值類型是沒有意義的，因?yàn)榉祷刂狄话愣紩?huì)被賦值給另一個(gè)變量，此時(shí)用于傳遞返回值的對(duì)象已經(jīng)被銷毀，修飾返回值類型的const的作用也就終結(jié)了。

當(dāng)返回值是引用類型時(shí)，如果該引用的值不希望被修改是可以聲明為常引用的，例如：

classSocket

{

public:

conststring& IP( void ) const{ return _ip; }

private:

string_ip;

};

Socketsock;

string&ip = sock.IP(); // 不可以

conststring& ip2 = sock.IP(); // 可以

stringip3 = sock.IP(); // Socket::_ip被復(fù)制，可以

此處，為了減少構(gòu)造臨時(shí)變量，將IP函數(shù)返回值定義為引用類型以提高程序運(yùn)行效率，但為了保護(hù)內(nèi)部狀態(tài)不會(huì)被客戶端代碼意外，返回值使用const修飾為常引用。但是，如果對(duì)于軟件安全性較高的場合，最好不要定義為引用，因?yàn)閻阂獾目蛻舳舜a是有可能修改Socket::_ip的值的。

在C++中賦值運(yùn)算符反默認(rèn)返回值都是引用，但筆者認(rèn)為定義為常引用更為合適，例如：

intmain( void )

{

int a =1,b = 2,c = 3,d = 4;

((a=b)=c)=d;

cout<<”a=”<

return0;

}

輸出結(jié)果：

a=4,b=2, c=3, d=4

顯然，在實(shí)際工程中誰也不會(huì)寫出這樣的代碼，這段代碼卻是合法的，無疑這給程序員多了一種出錯(cuò)的可能，如果把賦值運(yùn)算符的返回值定義為常引用，則會(huì)減少程序員出錯(cuò)的機(jī)會(huì)，例如[??]:

classObject

{

public:

constObject& operator=(const Object& a) { return *this; }

};

intmain( void )

{

Objecta, b, c, d;

a = b =c = d; // 可以

((a=b)=c)=d;// 不可以

return0;

}

在gcc 編譯時(shí)則會(huì)出現(xiàn)錯(cuò)誤提示：

error:passing ‘const Object’ as ‘this’ argument of ‘const Object&Object::operator=(const Object&)’ discards qualifiers.?
當(dāng)然，不同的編譯器可能錯(cuò)誤提示不同。