C語言的那些小秘密之const修飾符

或許還有不少人對於const修飾符理解的並不深刻，都只是停留在一個比較淺的層面上，僅僅是在讀別人代碼的時候看到了const修飾符的使用，自己的寫代碼的過中從未使用過，所以自然對於const修飾符比較陌生。那麼到底什麼是const修飾符，我們在自己編寫C語言代碼的過程中又該如何有效使用const修飾符呢，現在讓我們來學習下const修飾符的使用。

const在C語言中算是一個比較新的描述符，我們稱之為常量修飾符，即就是說其所修飾的對象為常量。當你代碼中想要設法阻止一個變數被改變，那麼這個時候可以選擇使用const關鍵字。在你給一個變數加上const修飾符的同時，通常需要對它進行初始化，在之後的程式中就不能再去改變它。

可能有的人會有一個疑問，我們不是有在C中有預先處理指令#define VariableName VariableValue 可以很方便地進行值替代，幹嘛還要引入const修飾符呢？！這是因為預先處理語句雖然可以很方便的進行值得替代，但它有個比較致命的缺點，即預先處理語句僅僅只是簡單值替代，缺乏類型的檢測機制。這樣預先處理語句就不能享受C編譯器嚴格類型檢查的好處，正是由於這樣，使得它的使用存在著一系列的隱患和局限性。

在講解const修飾符之前，我們在此首先給出const修飾符的幾個典型作用：

1.   const類型定義：指明變數或對象的值是不能被更新,引入目的是為了取代先行編譯指令

2.   可以保護被修飾的東西，防止意外的修改，增強程式的健壯性；

3.   編譯器通常不為普通const常量分配儲存空間，而是將它們儲存在符號表中，這使得它成為一個編譯期間的常量，沒有了儲存與讀記憶體的操作，使得它的效率也很高。

4.    可以節省空間的，避免不必要的記憶體配置。

 接下來看看具體的使用。

一、const修飾符在函數體內修飾局部變數。

 const int n=5；

和

 int const n=5；

是等價的。我們在編程的過程中一定要清楚的知道const修飾的對象是誰，在這裡修飾的是n，和int沒有關係。const 要求他所修飾的對象為常量，不能被改變，同時也不能夠被賦值，所以下面這樣的寫法是錯誤的。
const int n;
n=0;

對於上面的情況是比較容易理解的，但是當const與指標一起使用時，就容易讓人感到迷惑。例如，下面我們來看看一個p和q的聲明：

 const int *p;
 int const *q;

看了上面的代碼可能有人會覺得 const int *p;表示的是const int類型的指標（const直接修飾int），而 int const *q;表示的是int類型的const指標（const直接修飾指標）。實際上，在上面的聲明中p和q都被聲明為const int類型的指標。而int類型的const指標應該這樣聲明：

 int * const r= &n;

以上的p和q都是指向const int類型的指標，也就是說，你在以後的程式裡不能改變*p的值。而r是一個const指標，它在聲明的時候被初始化指向變數n（即r=&n；）之後，r的值將不再允許被改變，但*r的值可以改變。在此對於判斷const的修飾對象給出一種常使用的方法，我們以*為界線，如果const位於*的左側，則const就是用來修飾指標所指向的變數，即指標指向為常量；如果const位於*的右側，const就是修飾指標本身，即指標本身是常量。

還是給個代碼來加深下大家的印象吧。

#include <stdio.h>

int main(int argc, char* argv[])
{
 int ss=9;
 int * const r= &ss;
 printf("%d\n",*r);
 printf("%d\n",ss);
 *r=100;
 printf("%d\n",*r);
 printf("%d\n",ss);

    return 0;
}

運行結果如下：

簡單的來分析下吧，因為r指向的是ss的地址，所以修改r指向的地址單元的值的同時ss的值也隨之變化。

結合上述兩種const修飾的情況，我們現在應該可以完成如何聲明一個指向const int類型的const指標，如下：

const int * const r=&ss;

這個時候我們既不能修改*r的值也不能修改r的值。

接下來看看const用於修飾常量靜態字串，例如：例如：

const char* str="fdsafdsa";

如果沒有const的修飾，我們可能會在後面有意無意的寫str[4]='x'這樣的語句，這樣會導致對唯讀記憶體地區的賦值，然後程式會立刻異常終止。有了const，這個錯誤就能在程式被編譯的時候就立即檢查出來，這就是const的好處。讓邏輯錯誤在編譯期被發現。

二、const在函式宣告時修飾參數

void *memmove( void* dest, const void* src, size_t count ); 這是標準庫中的一個函數，在標頭檔#include <string.h>中聲明，其功能為由src所指記憶體地區複製count個位元組到dest所指記憶體地區。用於按位元組方式複製字串（記憶體）。它的第一個參數，是將字串複製到哪裡去(dst),是目的地，這段記憶體地區必須是可寫。它的第二個參數，是要將什麼樣的字串複製出去，我們對這段記憶體地區只做讀取，不寫。於是，我們站在這個函數自己的角度來看，src 這個指標，它所指向的記憶體內所儲存的資料在整個函數執行的過程中是不變。於是src所指向的內容是常量。於是就需要用const修飾。另外需要強調的一點就是src和dest所指記憶體地區可以重疊，但複製後dest內容會被更改。函數返回指向dest的指標。

例如，我們這裡這樣使用它。

#include <stdio.h>
#include <string.h>

int main(int argc, char* argv[])
{
 const char* str="hello";
 char buf[10];
 memmove(buf,str,6);
 printf("%s\n",buf);

    return 0;
}

運行結果如下：

如果我們反過來寫，memmove(str,buf,6);那麼編譯器一定會報錯。事實是我們經常會把各種函數的參數順序寫反。事實是編譯器在此時幫了我們大忙。如果編譯器靜悄悄的不報錯，即在函式宣告void *memmove( void* dest, const void* src, size_t count ); 處去掉const即可，那麼這個程式在啟動並執行時候一定會崩潰。這裡還要說明的一點是在函數參數聲明中const一般用來聲明指標而不是變數本身。例如，上面的size_t len,在函數實現的時候可以完全不用更改len的值，那麼是否應該把len也聲明為常量呢？可以，可以這麼做。我們來分析這麼做有什麼優劣。如果加了const,那麼對於這個函數的實現者，可以防止他在實現這個函數的時候修改不需要修改的值(len),這樣很好。但是對於這個函數的使用者，

1.飾符號毫無意義，我們可以傳遞一個常量整數或者一個非常量整數過去，反正對方獲得的只是我們傳遞的一個copy。
2實現。我不需要知道你在實現這個函數的時候是否修改過len的值。

所以，const一般只用來修飾指標。再看一個複雜的例子
int execv(const char *path, char *const argv[]);
著重看後面這個，argv.它代表什麼。如果去掉const,我們可以看出char * argv[]，argv是一個數組，它的每個元素都是char *類型的指標。如果加上const.那麼const修飾的是誰呢？修飾的是一個數組，argv[]意思就是說這個數組的元素是唯讀。那麼數組的元素的是什麼類型呢？是char *類型的指
針.也就是說指標是常量，而它指向的資料不是。於是
argv[1]=NULL; //非法
argv[0][0]='a'; //合法

三、const作為全域變數

在程式中，我們要儘可能少的使用全域變數。因為其範圍是全域，所以程式範圍內都可以修改它的值，從而導致了全域變數不能保證值的正確性，如果出現錯誤非常難以發現。如果在多線程中使用全域變數，你的程式將會錯的一塌糊塗。多線程會修改另一個線程使用的全域變數的值，如果不注意，一旦出錯後果不堪設想。所以在這種情況下萬不得意不要使用全域變數。我們要儘可能多的使用const。如果一個全域變數只在本檔案中使用，那麼用法和前面所說的函數局部變數沒有什麼區別。如果它要在多個檔案間共用，那麼就牽扯到一個儲存類型的問題。

有兩種方式。

1.用extern
例如
/* pi.h */
extern const double pi;
/* pi.c */
const double pi=3.14;
然後其他需要使用pi這個變數的，包含pi.h

#include pi.h

或者，自己把那句聲明複製一遍就好。這樣做的結果是，整個程式連結完後，所有需要使用pi這個變數的共用一個儲存地區。

2.使用static,靜態外部儲存類

/* constant.h */
static const double pi=3.14;
需要使用這個變數的*.c檔案中，必須包含這個標頭檔。前面的static一定不能少。否則連結的時候會報告說該變數被多次定義。這樣做的結果是，每個包含了constant.h的*.c檔案，都有一份該變數自己的copy,該變數實際上還是被定義了多次，佔用了多個儲存空間，不過在加了static關鍵字後，解決了檔案間重定義的衝突。壞處是浪費了儲存空間，導致連結完後的可執行檔變大。通常來說，對於儲存空間位元組的變化不是太大的情況下，不是問題。好處是，你不用關心這個變數是在哪個檔案中被初始化的。

下面再來看看一段代碼：

#include <stdio.h>

int main()
{
 const int a=12;
 const int *p=&a;           // 這個是指向常量的指標，指標指向一個常量
 p++;                               //可以指標可以自加、自減
 p--;                                  //合法

 int const *q=&a;           // 這個和上面const int *p=&a;是一個意思
 int b=12;

 int * const r=&b;           //這個就是常量指標(常指標)，不能自加、自減,並且要初始化
 //r++;                               //編譯出錯 

 const int * const t=&b; //這個就是指向常量的常指標,並且要初始化，用變數初始化

 //t++;                                //編譯出錯
 p=&b;                              //const指標可以指向const和非const對象
 q=&b;                              //合法

 return 0;
}

為了便於代碼的閱讀理解，在此就直接在代碼後面加註釋，就不在這兒做過多的講解了。

綜上所述，const 的好處，是引入了常量的概念，讓我們不要去修改不該修改的記憶體。直接的作用就是讓更多的邏輯錯誤在編譯期被發現。所以我們要儘可能的多使用const。以上內容難免有錯，如果錯誤，請糾正！如需轉載，請註明出處！

在此說幾句閑話，前幾天無意間在google搜尋時發現有個別網站和個人未經我的同意就私自在不標註任何出處資訊的情況下轉載我的文章，有個網友更是以第一作者的身份在另外一個論壇進行發表，沒有標註任何文章出處的相關資訊。我希望在轉載文章的同時也能標註下出處，畢竟也算是對原創起碼的一點尊重，希望我們大家都有一種尊重原創的意識，我的部落格地址：http://blog.csdn.net/bigloomy