1. 取代#define 進行值替代
2. 修飾指針
3. 修飾參數和返回值
4. 修飾類和類成員變量及類成員函數
一、值替代 #define只在預處理器進行值替代，并且沒有類型標識，出現錯誤很難排查。const 提供類型信息，在編譯期可以進行類型檢查。編譯器在編譯時可以通過必要的運算把一個復雜的常量表達式簡化，稱為常量折疊。
我理解的常量折疊是：編譯器會把這個常量放到一個符號表中，比如說const int i = 1;符號表中有一個符號i，同時對應了一個數值1，此時是不分配內存空間的。如果你強行分配內存空間的話也可以。
const int i = 1;
int* ip = const_cast<int*>(&i);
*ip = 2;
cout <<"i = "<<i ;
cout <<＂*ip = "<< *ip;
cout <<＂*(&i) = "<<*(&i) ;
// i = 1;
//*ip = 2;
//
*(&i) = 1;
不論你怎么通過內存修改ｉ，看起來ｉ有兩個值，1和２，這貌似就是常量折疊。
內部鏈接問題 C++中的const是內部鏈接，即const僅在被定義過的文件中才是可見的，鏈接時不能被其他編譯單元看到。在定義時，必須賦一個初值，不然必須用extern顯式地聲明。
通常，編譯器是不為const創建存儲空間的，相反把這個定義保存在它的符號表中。但是extern強制執行了存儲空間的分配，因為extern表示使用外部鏈接，也就是有幾個不同的編譯單元可以引用它，所以必須有存儲空間。（這句話我的理解是：每個編譯單元都有自己的符號表，其他編譯單元是不能看到其他編譯單元符號表中的東西的。其他編譯單元如果要引用一個外部變量，該變量必須是在內存中，可以讀取的。所以一定要分配空間。外部鏈接一般是找到相應名字的內存地址，比如鏈接一個外部函數，就是找到這個函數的內存地址）
通常沒有extern的時候，不會分配存儲空間。但是有些結構比較復雜的const，編譯器還是會分配空間。因為.h文件中一般放置的都是不分配空間的代碼，所以cosnt變量默認為內部鏈接。不然鏈接程序在多個目標文件中看到相同的定義就會”抱怨“。
用常量表達式定義數組大小 定義數組的大小的時候，必須是常量表達式，不能為變量，至于為什么。不太清楚，只是編譯器在編譯的時候給出錯誤：期望一個常量表達式，不能分配一個長度是０的數組，變量是長度未知的。（我的理解是，因為變量是變的，如果靜態地聲明了一個數組a[b]因為ｂ確定，定義的時候ｂ是１，在之后又被修改為２，那數組ａ長度到底應該是１呢還是２呢？）
常量表達式：
const int i = 100;// constant
const int j = 100 + i;// constant express
long addr = (long)&j;// forces storage
char buf[j + 10];//right
const可以應用于集合，但是編譯器不會把一個集合保存到符號表中，所以必須分配內存。這種情況下，const意味著‘不能改變的一塊內存’，編譯器不需要知道里面存儲的內容。如果這樣理解的話，那么編譯器在看到int b = 1;這句話的時候，也會想”這是一個ｉｎｔ型的變量，我給他分配２個字節就行了，里面是什么，或許要到運行的時候再說了“，所以a[b]的長度就是未知長度了。
二、const 指針和指向const的指針 int* u, v;== int*u; int v;
因為ｃ＋＋對類型檢查非常精細，所以，你可以把一個非const指針賦給const指針，但是不能把一個const指針賦給非cosnt指針。同樣也不能把指向const的指針賦給指向非const的指針
int d = 1;
const int e = 2;
int* u = &d;//right;
int* v = &e;//wrong
int* w = const_cast<int*>(&e);//right
int* y = (int*)&e;//right
考慮下面一句代碼：
char* cp = "howdy";
”howdy"是存放在字符常量區的，它是個常量，這個表達式返回的是一個const char*，但是在某些編譯器中是可以通過編譯的。但最好寫成const char* cp = "howdy";修改該字符串數組是錯誤的。如果想修改它就把它放到一個數組中char cp[] = "howdy";為什么呢？
char cp[] = "abcd";
cp[1] = '2';
cout <<cp << endl;
// legall
char *cp = "abcd";
cp[1] = '2';
cout << cp << endl;//cause runtime error
第一種情況："abcd"是放在字符常量區的，但是數組是放在棧上的，現在棧上有５個字節的數組，分別存放了'a','b','c','d''/0'，所以你修改它沒問題。第二種："abcd"是放在字符常量區的，cp只是一個指針，指向了這串字符串，想修改它是錯誤地。臨時量 他們也需要存儲空間，并且可以構造和銷毀，但是，我們看不到它們，并且自動地成為常量。一旦計算結束，臨時變量也會不復存在，所以對臨時變量所做的任何操作都會丟失。
傳遞指針和引用的時候一般都用const修飾。
值拷貝：
int i = 1;
int* const ip = &i;
int* ip2 = ip;//right;because you can't modify ip by ip2
const int j = 2;
int k = j;//right;// you can't modify j by k;
const int m = 1;
int* mp = &m;//wrong, you can modify m by mp, but m is a constant
類中的const非static變量在構造函數的初始化列表里定義
static const 在定義的地方初始化，enum可以實現static const作用
class A
{
enum {size = 100};
int i[size];
};//equal to static const int size = 100;
const對象const A a(1); 必須保證對象的數據成員在其聲明周期中不被改變。如何保證？用const成員函數，明確表示不改變成員數據。聲明的時候要用const 定義時也要用const,不然會被看作兩個函數。
class X
{
int i;
public:
int f() const;
};
int X::f() const
{
return i;
}
按位const和按邏輯const按位是指這塊內存中的每個字節都是不能改變的。
按邏輯是指，可以在某個成員函數中修改成員變量。兩種方法：
class X
{
int i;
public:
void f() const;
}
void X::f() const
{
(const_cast<X*>(this))->i++;//right
}
void X::f(const X* this)
{
this->i++;//illegal
(const_cast<X*>(this))->i++;//right
}
//////////another method//////////
class X
{
mutable int i;
public:
void f() const;
}
void X::f() const
{
i++;//right
}
posted on 2012-05-30 16:12
Dino-Tech 閱讀(176)
評論(0) 編輯 收藏 引用