面向?qū)ο笫荂++的重要特性.?
但是c++在c的基礎(chǔ)上新增加的幾點優(yōu)化也是很耀眼的?
就const直接可以取代c中的#define?
以下幾點很重要,學(xué)不好后果也也很嚴重?
const?
1.
限定符聲明變量只能被讀?
? const int i=5;?
? int j=0;?
? ...?
? i=j;? //非法，導(dǎo)致編譯錯誤?
? j=i;? //合法?
2.
必須初始化?
? const int i=5;? ? //合法?
? const int j;? ? ? //非法，導(dǎo)致編譯錯誤?
3.
在另一連接文件中引用const常量?
? extern const int i;? ? //合法?
? extern const int j=10;? //非法，常量不可以被再次賦值?
4.
便于進行類型檢查?
?
用const方法可以使編譯器對處理內(nèi)容有更多了解。?
? #define I=10?
? const long &i=10;? /*dapingguo提醒：由于編譯器的優(yōu)化，使?
? ? ?
得在const long i=10;
時i不被分配內(nèi)存，而是已10直接代入?
? ? ?
以后的引用中，以致在以后的代碼中沒有錯誤，為達到說教效?
? ? ?
果，特別地用&i明確地給出了i的內(nèi)存分配。不過一旦你關(guān)閉所?
? ? ?
有優(yōu)化措施，即使const long i=10;也會引起后面的編譯錯誤。*/?
? char h=I;? ? ? //沒有錯?
? char h=i;? ? ? //編譯警告，可能由于數(shù)的截短帶來錯誤賦值。?
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定義常量從匯編的角度來看，只是給出了對應(yīng)的內(nèi)存地址，?
?
而不是象#define一樣給出的是立即數(shù)，所以，const定義的常量在?
?
程序運行過程中只有一份拷貝，而#define定義的常量在內(nèi)存中有?
?
若干個拷貝。?
6.
可以通過函數(shù)對常量進行初始化?
? int value();?
? const int i=value();?
? dapingguo說：假定對ROM編寫程序時，由于目標代碼的不可改寫，?
?
本語句將會無效，不過可以變通一下：?
? const int &i=value();?
?
只要令i的地址處于ROM之外，即可實現(xiàn)：i通過函數(shù)初始化，而其?
?
值有不會被修改。?
7.
是不是const的常量值一定不可以被修改呢？?
?
觀察以下一段代碼：?
? const int i=0;?
? int *p=(int*)&i;?
? p=100;?
?
通過強制類型轉(zhuǎn)換，將地址賦給變量，再作修改即可以改變const常量值。?
8.
請分清數(shù)值常量和指針常量，以下聲明頗為玩味：?
? int ii=0;?
? const int i=0;? ? ? ? ? ? //i是常量，i的值不會被修改?
? 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使用詳解一文，對其中進行了一些補充，寫下了本文。?
1.? ? ? const常量，如const int max = 100;??
優(yōu)點：const常量有數(shù)據(jù)類型，而宏常量沒有數(shù)據(jù)類型。編譯器可以對前者進行類型安全檢查，而對后者只進行字符替換，沒有類型安全檢查，并且在字符替換時可能會產(chǎn)生意料不到的錯誤（邊際效應(yīng)）?
2.? ? ? const
修飾類的數(shù)據(jù)成員。如：?
class A?
{?
? ? const int size;?
? ? …?
}?
const
數(shù)據(jù)成員只在某個對象生存期內(nèi)是常量，而對于整個類而言卻是可變的。因為類可以創(chuàng)建多個對象，不同的對象其const數(shù)據(jù)成員的值可以不同。所以不能在類
聲明中初始化const數(shù)據(jù)成員，因為類的對象未被創(chuàng)建時，編譯器不知道const
數(shù)據(jù)成員的值是什么。如?
class A?
{?
const int size = 100;? ? //錯誤?
int array[size];? ? ? ? //錯誤，未知的size?
}?
const數(shù)據(jù)成員的初始化只能在類的構(gòu)造函數(shù)的初始化表中進行。要想建立在整個類中都恒定的常量，應(yīng)該用類中的枚舉常量來實現(xiàn)。如?
class A?
{…?
enum {size1=100, size2 = 200 };?
int array1[size1];?
int array2[size2];?
}?
枚舉常量不會占用對象的存儲空間，他們在編譯時被全部求值。但是枚舉常量的隱含數(shù)據(jù)類型是整數(shù)，其最大值有限，且不能表示浮點數(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位于星號的左側(cè)，則const就是用來修飾指針所指向的變量，即指針指向為常量；如果const位于星號的
右側(cè)，const就是修飾指針本身，即指針本身是常量。因此，[1]和[2]的情況相同，都是指針所指向的內(nèi)容為常量（const放在變量聲明符的位置無
關(guān)），這種情況下不允許對內(nèi)容進行更改操作，如不能*a = 3
；[3]為指針本身是常量，而指針所指向的內(nèi)容不是常量，這種情況下不能對指針本身進行更改操作，如a++是錯誤的；[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
的一些強大的功能在于它在函數(shù)聲明中的應(yīng)用。在一個函數(shù)聲明中，const
可以修飾函數(shù)的返回值，或某個參數(shù)；對于成員函數(shù)，還可以修飾是整個函數(shù)。有如下幾種情況，以下會逐漸的說明用法：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ù)的時候，用相應(yīng)的變量初始化const常量，則在函數(shù)體中，按照const所修飾的部分進行常量化，如形參為const
A* a，則不能對傳遞進來的指針的內(nèi)容進行改變，保護了原指針所指向的內(nèi)容；如形參為const A& a，則不能對傳遞進來的引用對象進行改變，保護了原對象的屬性。?
[注意]：參數(shù)const通常用于參數(shù)為指針或引用的情況，且只能修飾輸入?yún)?shù);若輸入?yún)?shù)采用“值傳遞”方式，由于函數(shù)將自動產(chǎn)生臨時變量用于復(fù)制該參數(shù)，該參數(shù)本就不需要保護，所以不用const修飾。?
[總結(jié)]對于非內(nèi)部數(shù)據(jù)類型的輸入?yún)?shù)，因該將“值傳遞”的方式改為“const引用傳遞”，目的是為了提高效率。例如，將void
Func(A a)改為void Func(const A &a)?
? ? ?
對于內(nèi)部數(shù)據(jù)類型的輸入?yún)?shù)，不要將“值傳遞”的方式改為“const引用傳遞”。否則既達不到提高效率的目的，又降低了函數(shù)的可理解性。例如void
Func(int x)不應(yīng)該改為void Func(const int &x)?
2）?
修飾返回值的const，如const A fun2(
); const A* fun3();?
這樣聲明了返回值后，const按照"修飾原則"進行修飾，起到相應(yīng)的保護作用。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修飾返回值為對象本身（非引用和指針）的情況多用于二目操作符重載函數(shù)并產(chǎn)生新對象的時候。?
[總結(jié)]?
1.? ?
一般情況下，函數(shù)的返回值為某個對象時，如果將其聲明為const時，多用于操作符的重載。通常，不建議用const修飾函數(shù)的返回值類型為某個對象或?qū)?某個對象引用的情況。原因如下：如果返回值為某個對象為const（const
A test = A 實例）或某個對象的引用為const（const
A& test = A實例）
，則返回值具有const屬性，則返回實例只能訪問類A中的公有（保護）數(shù)據(jù)成員和const成員函數(shù)，并且不允許對其進行賦值操作，這在一般情況下很少
用到。?
2.? ? ?
如果給采用“指針傳遞”方式的函數(shù)返回值加const修飾，那么函數(shù)返回值（即指針）的內(nèi)容不能被修改，該返回值只能被賦給加const
修飾的同類型指針。如：?
const char * GetString(void);?
如下語句將出現(xiàn)編譯錯誤：?
char *str=GetString();?
正確的用法是：?
const char *str=GetString();?
3.? ?
函數(shù)返回值采用“引用傳遞”的場合不多，這種方式一般只出現(xiàn)在類的賻值函數(shù)中，目的是為了實現(xiàn)鏈式表達。如：?
class A?
{…?
A &operate = (const A &other);? //負值函數(shù)?
}?
A a,b,c;? ? ? ? ? ? ? //a,b,c為A的對象?
…?
a=b=c;? ? ? ? ? ? //正常?
(a=b)=c;? ? ? ? ? //不正常，但是合法?
若負值函數(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;?
任何不會修改數(shù)據(jù)成員的函數(shù)都因該聲明為const類型。如果在編寫const成員函數(shù)時，不慎修改了數(shù)據(jù)成員，或者調(diào)用了其他非const成員函數(shù)，編譯器將報錯，這大大提高了程序的健壯性。如：?
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;? ? ? ? ? ? ? //編譯錯誤，企圖修改數(shù)據(jù)成員m_num?
? Pop();? ? ? ? ? ? ?? ? ? //編譯錯誤，企圖調(diào)用非const函數(shù)?
? Return m_num;?
}?
7.? ? ?
使用const的一些建議?
1
要大膽的使用const，這將給你帶來無盡的益處，但前提是你必須搞清楚原委；?
2
要避免最一般的賦值操作錯誤，如將const變量賦值，具體可見思考題；?
3
在參數(shù)中使用const應(yīng)該使用引用或指針，而不是一般的對象實例，原因同上；?
4 const在成員函數(shù)中的三種用法（參數(shù)、返回值、函數(shù)）要很好的使用；?
5
不要輕易的將函數(shù)的返回值類型定為const;?
6除了重載操作符外一般不要將返回值類型定為對某個對象的const引用;?
[思考題答案]?
1
這種方法不正確，因為聲明指針的目的是為了對其指向的內(nèi)容進行改變，而聲明的指針e指向的是一個常量，所以不正確；?
2
這種方法正確，因為聲明指針所指向的內(nèi)容可變；?
3
這種做法不正確；?
在const A::operator=(const A&a)中，參數(shù)列表中的const的用法正確，而當這樣連續(xù)賦值的時侯，問題就出現(xiàn)了：?
A a,b,c:?
(a=b)=c;?
因為a.operator=(b)的返回值是對a的const引用，不能再將c賦值給const常量。
?
?
1.1.1.
定義普通常量
使用#define來定義常量也是常用方法，但const也可以用來定義常量，在[Effective
C++]中建議使用const代替#define來定義常量，因為const定義的常量具有類型信息，而宏沒有，所以使用const定義的常量在進行賦值操作時編譯器會進行更嚴格的類型檢查，是類型安全的。
constdouble PI = 3.1414926;
constint POOL_SIZE = 20;
定義常量有三種方法：宏、const、enum，其中宏應(yīng)該盡量避免，而const與enum也各有優(yōu)缺點，最大的區(qū)別就是enum只能用于定義整數(shù)，而不能定義浮點數(shù)；而對于定義邏輯關(guān)系較近的一組整數(shù)時比較適合使用enum，也可以考慮使用類代替enum(參見[??])。
常量必須在定義時進行初始化，之后便不能再賦值。說它不能被賦值并不是說常量的值是絕對不會改變的，只是說不能直接賦值，但可以通過指針及強制類型轉(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直接輸出變量的值時顯示其值始終沒有改變，但通過指針間接顯示出來的值是改變了，而且輸出結(jié)果的最后一行很奇怪，ci的值與*cpci的值居然不相等，只因為編譯器在編譯時進行了優(yōu)化，將代碼中的ci直接替換成了5，與宏替換是相同的效果，而指針的值則是實際內(nèi)存中的值。
所以，千萬不要試圖使用指針強行改變const變量的值，否則程序可能表現(xiàn)出錯誤的行為，而且查找起來這種錯誤非常困難。在gcc 4.3.4和visualC++ 2010中均默認打開了對常量的優(yōu)化選項，目前還沒找到關(guān)閉該優(yōu)化的命令行選項，一定不要自作聰明去改const變量的值。
1.1.2.
修飾指針
把const與指針放到一起，很多人便會想到一個繞口令“指針常量與常量指針?！爸羔槼Ａ俊奔匆粋€指針變量，該變量不能被賦值，而指針指向的內(nèi)存單元的內(nèi)容是可以改變的；“常量指針”即一個指向常量的指針，指針變量本身可以賦值，而指針指向的內(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)容的時候都將指針定義成常量指針，不打算指針本身被修改的場合都定義成指針常量。盡可能地多用const，用錯了沒關(guān)系，編譯器會提示你的，只要能夠編譯通過，就不會因為用錯const而導(dǎo)致程序邏輯錯誤，應(yīng)該說const負作用極小。
1.1.3.
修飾類成員常量
當使用const修飾類成員變量時便定義了常數(shù)據(jù)成員，它的使用與使用類外定義的常量本質(zhì)上并沒有什么區(qū)別，在這里只想指出一點：有網(wǎng)友提到const數(shù)據(jù)成員只能被const修飾的函數(shù)使用這是沒有根據(jù)的，是錯誤的。
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)用成員類對象const函數(shù)，但有個例外，就是mutable修飾的成員變量可以在const修飾的成員函數(shù)中被修改，如_readCount。
另外，const只能修飾非靜態(tài)函數(shù)。
建議：將所有不改變對象狀態(tài)的函數(shù)都使用const修飾符標識，以提高程序的可讀性。其實，頭文件就是最好的類接口的說明文檔，越多的提供信息就能使程序的可讀性越好，越利于維護?？吹匠蓡T函數(shù)的const修飾符，讀者便立即明白該函數(shù)不會改變程序的狀態(tài)，這也有利于當程序狀態(tài)出現(xiàn)異常時的問題定位。
1.1.5. 修飾類對象、對象引用或?qū)ο笾羔槪ǔＡ恐羔槪?br />當const修飾自定義的類對象時，與修飾C++內(nèi)置類型的變量的思想是一致的，但稍有不同，除了不能被賦值外，還不能調(diào)用沒有使用const修飾的非靜態(tài)成員函數(shù)。當const修飾類對象引用、指針時限制是一樣的，因為引用本身與直接使用該變量實質(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)不會被意外修改，一般用于修飾輸入?yún)?shù)，例如標準庫中的字符串連接函數(shù)。str1是輸出參數(shù)，其內(nèi)容會被修改，而str2為輸入?yún)?shù)，其內(nèi)容不會修改。
char*strcat(char* str1, const char* str2);
實際上在說到const用法一開始就提到，const只是一種聲明，但并不能保證，例如strcat函數(shù)雖然聲明了str2為constchar*型，但并不能保證內(nèi)部絕對不會修改str2的內(nèi)容。但const從語言本身提供了一種編寫自描述性代碼的方法，只要使用函數(shù)與實現(xiàn)函數(shù)的雙方都達成一致的約定，按照契約編程，我們就可以認為const修飾的類型在函數(shù)體內(nèi)不會被修改，這與const修飾類成員函數(shù)一樣，可以提高軟件的可讀性。
1.1.7.
修飾函數(shù)返回值
const可以用于修飾任何類型，只要返回值類型不是void，const就可以用來修飾返回值的類型。但實際上const用于修飾非引用的返回值類型是沒有意義的，因為返回值一般都會被賦值給另一個變量，此時用于傳遞返回值的對象已經(jīng)被銷毀，修飾返回值類型的const的作用也就終結(jié)了。
當返回值是引用類型時，如果該引用的值不希望被修改是可以聲明為常引用的，例如：
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)造臨時變量，將IP函數(shù)返回值定義為引用類型以提高程序運行效率，但為了保護內(nèi)部狀態(tài)不會被客戶端代碼意外，返回值使用const修飾為常引用。但是，如果對于軟件安全性較高的場合，最好不要定義為引用，因為惡意的客戶端代碼是有可能修改Socket::_ip的值的。
在C++中賦值運算符反默認返回值都是引用，但筆者認為定義為常引用更為合適，例如：
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
顯然，在實際工程中誰也不會寫出這樣的代碼，這段代碼卻是合法的，無疑這給程序員多了一種出錯的可能，如果把賦值運算符的返回值定義為常引用，則會減少程序員出錯的機會，例如[??]:
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 編譯時則會出現(xiàn)錯誤提示：
error:passing ‘const Object’ as ‘this’ argument of ‘const Object&Object::operator=(const Object&)’ discards qualifiers.?
當然，不同的編譯器可能錯誤提示不同。
下載文檔
