在討論全域性變數之前我們先要明白幾個基本的概念：

1. 編譯單元(模組)：

    在IDE開發工具大行其道的今天，對於編譯的一些概念很多人已經不再清楚了，很多程式設計師最怕的就是處理連線錯誤(LINK ERROR), 因為它不像編譯錯誤那樣可以給出你程式錯誤的具體位置，你常常對這種錯誤感到懊惱，但是如果你經常使用gcc，makefile等工具在linux或者嵌入式下做開發工作的話，那麼你可能非常的理解編譯與連線的區別！當在VC這樣的開發工具上編寫完程式碼，點選編譯按鈕準備生成exe檔案時，VC其實做了兩步工作，第一步，將每個.cpp(.c)和相應.h檔案編譯成obj檔案；第二步，將工程中所有的obj檔案進行LINK生成最終的.exe檔案，那麼錯誤就有可能在兩個地方產生，一個是編譯時的錯誤，這個主要是語法錯誤，另一個是連線錯誤，主要是重複定義變數等。我們所說的編譯單元就是指在編譯階段生成的每個obj檔案，一個obj檔案就是一個編譯單元，也就是說一個cpp(.c)和它相應的.h檔案共同組成了一個編譯單元，一個工程由很多個編譯單元組成，每個obj檔案裡包含了變數儲存的相對地址等 。

2. 宣告與定義的區別

    函式或變數在宣告時，並沒有給它實際的實體記憶體空間，它有時候可以保證你的程式編譯通過， 但是當函式或變數定義的時候，它就在記憶體中有了實際的物理空間，如果你在編譯模組中引用的外部變數沒有在整個工程中任何一個地方定義的話， 那麼即使它在編譯時可以通過，在連線時也會報錯，因為程式在記憶體中找不到這個變數！你也可以這樣理解， 對同一個變數或函式的宣告可以有多次，而定義只能有一次!

3. extern的作用

    extern有兩個作用，第一個,當它與"C"一起連用時，如: extern "C" void fun(int a, int b); 則告訴編譯器在編譯fun這個函式名時按著C的規則去翻譯相應的函式名而不是C++的， C++的規則在翻譯這個函式名時會把fun這個名字變得面目全非，可能是

    當extern不與"C"在一起修飾變數或函式時，如在標頭檔案中: extern int g_Int; 它的作用就是宣告函式或全域性變數的作用範圍的關鍵字，其宣告的函式和變數可以在本模組活其他模組中使用，記住它是一個宣告不是定義!也就是說B模組(編譯單元)要是引用模組(編譯單元)A中定義的全域性變數或函式時，它只要包含A模組的標頭檔案即可, 在編譯階段，模組B雖然找不到該函式或變數，但它不會報錯，它會在連線時從模組A生成的目的碼中找到此函式。

    如果你對以上幾個概念已經非常明白的話，那麼讓我們一起來看以下幾種全域性變數/常量的使用區別:

1. 用extern修飾的全域性變數

    以上已經說了extern的作用，下面我們來舉個例子,如:

    在test1.h中有下列宣告:

    #ifndef TEST1H

    #define TEST1H

    extern char g_str[]; // 宣告全域性變數g_str

    void fun1();

    #endif

    在test1.cpp中

    #include "test1.h"

    char g_str[] = "123456"; // 定義全域性變數g_str

    void fun1()

    {

        cout << g_str << endl;

    }

    以上是test1模組， 它的編譯和連線都可以通過,如果我們還有test2模組也想使用g_str,只需要在原檔案中引用就可以了

    #include "test1.h"

    void fun2()

    {

        cout << g_str << endl;

    }

    以上test1和test2可以同時編譯連線通過，如果你感興趣的話可以用ultraEdit開啟test1.obj,你可以在裡面著"123456"這個字串,但是你卻不能在test2.obj裡面找到，這是因為g_str是整個工程的全域性變數，在記憶體中只存在一份, test2.obj這個編譯單元不需要再有一份了，不然會在連線時報告重複定義這個錯誤!

    有些人喜歡把全域性變數的宣告和定義放在一起，這樣可以防止忘記了定義，如把上面test1.h改為

    extern char g_str[] = "123456"; // 這個時候相當於沒有extern

    然後把test1.cpp中的g_str的定義去掉,這個時候再編譯連線test1和test2兩個模組時，會報連線錯誤，這是因為你把全域性變數g_str的定義放在了標頭檔案之後，test1.cpp這個模組包含了test1.h所以定義了一次g_str,而 test2.cpp也包含了test1.h所以再一次定義了g_str, 這個時候聯結器在連線test1和test2時發現兩個g_str。如果你非要把g_str的定義放在test1.h中的話，那麼就把test2的程式碼中#include "test1.h"去掉 換成:

    extern char g_str[];

    void fun2()

    {

        cout << g_str << endl;

    }

    這個時候編譯器就知道g_str是引自於外部的一個編譯模組了，不會在本模組中再重複定義一個出來，但是我想說這樣做非常糟糕，因為你由於無法在test2.cpp中使用#include "test1.h", 那麼test1.h中宣告的其他函式你也無法使用了，除非也用都用extern修飾，這樣的話你光宣告的函式就要一大串，而且標頭檔案的作用就是要給外部提供介面使用的，所以 請記住， 只在標頭檔案中做宣告，真理總是這麼簡單。

1. 編譯單元(模組)：
    在IDE開發工具大行其道的今天，對於編譯的一些概念很多人已經不再清楚了，很多程式設計師最怕的就是處理連線錯誤(LINK ERROR), 因為它不像編譯錯誤那樣可以給出你程式錯誤的具體位置，你常常對這種錯誤感到懊惱，但是如果你經常使用gcc，makefile等工具在linux或者嵌入式下做開發工作的話，那麼你可能非常的理解編譯與連線的區別！當在VC這樣的開發工具上編寫完程式碼，點選編譯按鈕準備生成exe檔案時，VC其實做了兩步工作，第一步，將每個.cpp(.c)和相應.h檔案編譯成obj檔案；第二步，將工程中所有的obj檔案進行LINK生成最終的.exe檔案，那麼錯誤就有可能在兩個地方產生，一個是編譯時的錯誤，這個主要是語法錯誤，另一個是連線錯誤，主要是重複定義變數等。我們所說的編譯單元就是指在編譯階段生成的每個obj檔案，一個obj檔案就是一個編譯單元，也就是說一個cpp(.c)和它相應的.h檔案共同組成了一個編譯單元，一個工程由很多個編譯單元組成，每個obj檔案裡包含了變數儲存的相對地址等 。

2. 宣告與定義的區別
    函式或變數在宣告時，並沒有給它實際的實體記憶體空間，它有時候可以保證你的程式編譯通過， 但是當函式或變數定義的時候，它就在記憶體中有了實際的物理空間，如果你在編譯模組中引用的外部變數沒有在整個工程中任何一個地方定義的話， 那麼即使它在編譯時可以通過，在連線時也會報錯，因為程式在記憶體中找不到這個變數！你也可以這樣理解， 對同一個變數或函式的宣告可以有多次，而定義只能有一次!

3. extern的作用
    extern有兩個作用，第一個,當它與"C"一起連用時，如: extern "C" void fun(int a, int b); 則告訴編譯器在編譯fun這個函式名時按著C的規則去翻譯相應的函式名而不是C++的， C++的規則在翻譯這個函式名時會把fun這個名字變得面目全非，可能是[email protected]_int_int#%$也可能是別的，這要看編譯器的"脾氣"了(不同的編譯器採用的方法不一樣)，為什麼這麼做呢，因為C++支援函式的過載啊，在這裡不去過多的論述這個問題，如果你有興趣可以去網上搜索，相信你可以得到滿意的解釋!
    當extern不與"C"在一起修飾變數或函式時，如在標頭檔案中: extern int g_Int;  它的作用就是宣告函式或全域性變數的作用範圍的關鍵字，其宣告的函式和變數可以在本模組活其他模組中使用，記住它是一個宣告不是定義!也就是說B模組(編譯單元)要是引用模組(編譯單元)A中定義的全域性變數或函式時，它只要包含A模組的標頭檔案即可, 在編譯階段，模組B雖然找不到該函式或變數，但它不會報錯，它會在連線時從模組A生成的目的碼中找到此函式。

    如果你對以上幾個概念已經非常明白的話，那麼讓我們一起來看以下幾種全域性變數/常量的使用區別:

1. 用extern修飾的全域性變數
    以上已經說了extern的作用，下面我們來舉個例子,如: 
    在test1.h中有下列宣告:
    #ifndef TEST1H
    #define TEST1H
    extern char g_str[]; // 宣告全域性變數g_str
    void fun1();
    #endif
    在test1.cpp中
    #include "test1.h"
    
    char g_str[] = "123456"; // 定義全域性變數g_str
    
    void fun1()
    {
        cout << g_str << endl;
    }
    
    以上是test1模組， 它的編譯和連線都可以通過,如果我們還有test2模組也想使用g_str,只需要在原檔案中引用就可以了
    #include "test1.h"

    void fun2()
    {
        cout << g_str << endl;
    }
    以上test1和test2可以同時編譯連線通過，如果你感興趣的話可以用ultraEdit開啟test1.obj,你可以在裡面著"123456"這個字串,但是你卻不能在test2.obj裡面找到，這是因為g_str是整個工程的全域性變數，在記憶體中只存在一份, test2.obj這個編譯單元不需要再有一份了，不然會在連線時報告重複定義這個錯誤!
    有些人喜歡把全域性變數的宣告和定義放在一起，這樣可以防止忘記了定義，如把上面test1.h改為
    extern char g_str[] = "123456"; // 這個時候相當於沒有extern
    然後把test1.cpp中的g_str的定義去掉,這個時候再編譯連線test1和test2兩個模組時，會報連線錯誤，這是因為你把全域性變數g_str的定義放在了標頭檔案之後，test1.cpp這個模組包含了test1.h所以定義了一次g_str,而 test2.cpp也包含了test1.h所以再一次定義了g_str, 這個時候聯結器在連線test1和test2時發現兩個g_str。如果你非要把g_str的定義放在test1.h中的話，那麼就把test2的程式碼中#include "test1.h"去掉 換成:
    extern char g_str[];
    void fun2()
    {
        cout << g_str << endl;
    }
    這個時候編譯器就知道g_str是引自於外部的一個編譯模組了，不會在本模組中再重複定義一個出來，但是我想說這樣做非常糟糕，因為你由於無法在test2.cpp中使用#include "test1.h", 那麼test1.h中宣告的其他函式你也無法使用了，除非也用都用extern修飾，這樣的話你光宣告的函式就要一大串，而且標頭檔案的作用就是要給外部提供介面使用的，所以 請記住， 只在標頭檔案中做宣告，真理總是這麼簡單。

2. 用static修飾的全域性變數
    首先，我要告訴你static與extern是一對“水火不容”的傢伙，也就是說extern和static不能同時修飾一個變數；其次，static修飾的全域性變數宣告與定義同時進行，也就是說當你在標頭檔案中使用static聲明瞭全域性變數後，它也同時被定義了；最後，static修飾全域性變數的作用域只能是本身的編譯單元，也就是說它的“全域性”只對本編譯單元有效，其他編譯單元則看不到它,如:
    test1.h:
    #ifndef TEST1H
    #define TEST1H
    static char g_str[] = "123456"; 
    void fun1();
    #endif

    test1.cpp:
    #include "test1.h"
    
    void fun1()
    {
        cout << g_str << endl;
    }
    
    test2.cpp
    #include "test1.h"
    
    void fun2()
    {
        cout << g_str << endl;
    }
    
    以上兩個編譯單元可以連線成功, 當你開啟test1.obj時，你可以在它裡面找到字串"123456", 同時你也可以在test2.obj中找到它們，它們之所以可以連線成功而沒有報重複定義的錯誤是因為雖然它們有相同的內容，但是儲存的實體地址並不一樣，就像是兩個不同變數賦了相同的值一樣，而這兩個變數分別作用於它們各自的編譯單元。
    也許你比較較真，自己偷偷的跟蹤除錯上面的程式碼,結果你發現兩個編譯單元（test1, test2）的g_str的記憶體地址相同，於是你下結論static修飾的變數也可以作用於其他模組，但是我要告訴你，那是你的編譯器在欺騙你，大多數編譯器都對程式碼都有優化功能，以達到生成的目標程式更節省記憶體，執行效率更高，當編譯器在連線各個編譯單元的時候，它會把相同內容的記憶體只拷貝一份，比如上面的"123456", 位於兩個編譯單元中的變數都是同樣的內容，那麼在連線的時候它在記憶體中就只會存在一份了， 如果你把上面的程式碼改成下面的樣子，你馬上就可以拆穿編譯器的謊言:
    test1.cpp:
    #include "test1.h"
    
    void fun1()
    {
        g_str[0] = 'a';
        cout << g_str << endl;
    }

    test2.cpp
    #include "test1.h"
    
    void fun2()
    {
        cout << g_str << endl;
    }
    
    void main()
    {
        fun1(); // a23456
        fun2(); // 123456
    }
    
    這個時候你在跟蹤程式碼時，就會發現兩個編譯單元中的g_str地址並不相同，因為你在一處修改了它，所以編譯器被強行的恢復記憶體的原貌，在記憶體中存在了兩份拷貝給兩個模組中的變數使用。

    正是因為static有以上的特性，所以一般定義static全域性變數時，都把它放在原檔案中而不是標頭檔案，這樣就不會給其他模組造成不必要的資訊汙染，同樣記住這個原則吧！
    
3 const修飾的全域性常量

    const修飾的全域性常量用途很廣，比如軟體中的錯誤資訊字串都是用全域性常量來定義的。const修飾的全域性常量據有跟static相同的特性，即它們只能作用於本編譯模組中，但是const可以與extern連用來宣告該常量可以作用於其他編譯模組中, 如
    extern const char g_str[];
    然後在原檔案中別忘了定義:
    const char g_str[] = "123456";

    所以當const單獨使用時它就與static相同，而當與extern一起合作的時候，它的特性就跟extern的一樣了！所以對const我沒有什麼可以過多的描述，我只是想提醒你，const char* g_str = "123456" 與 const char g_str[] = "123465"是不同的， 前面那個const 修飾的是char * 而不是g_str,它的g_str並不是常量，它被看做是一個定義了的全域性變數（可以被其他編譯單元使用）， 所以如果你像讓char *g_str遵守const的全域性常量的規則，最好這麼定義const char* const g_str="123456".

論壇中的例子及解釋

int a,b;
int n=10;
int func()
{
  int m=10;
  a=m*3;
  b=n*3;
  return 0;
}
int main()
{
  fumc();
  return 0;
}
以上這個程式的n和m變數的區別是什麼？
比如效率上的差別？程式在執行的時候具體是怎麼操作這兩個變數的？

在C++中,記憶體分成4個區,他們分別是堆,棧,靜態儲存區和常量儲存區
  1)棧,就是那些由編譯器在需要的時候分配,在不需要的時候自動清除的變數的存
  儲區.裡面的變數通常是區域性變數,函式引數等.
  2)堆,又叫自由儲存區,它是在程式執行的過程中動態分配的,它最大的特性就是動.
  態性.由new分配的記憶體塊,他們的釋放編譯器不去管,由我們的應用程式去控制,
  一般一個new就要對應一個delete.如果程式設計師沒有釋放掉,那麼在程式結束後,
  作業系統會自動回收.如果分配了堆物件,卻忘記了釋放,就會產生記憶體洩漏.而
  如果已釋放了物件,卻沒有將相應的指標置為NULL,該指標就是"懸掛指標".
  4)靜態儲存區.所有的靜態物件,全域性物件都於靜態儲存區分配.
  5)常量儲存區,這是一塊比較特殊的儲存區,他們裡面存放的是常量,不允許修改
  (當然,你要通過非正當手段也可以修改,而且方法很多)
  常量字串都存放在靜態儲存區,返回的是常量字串的首地址.

n是全域性變數,儲存在靜態區.進入main函式之前就被建立.生命週期為整個源程式.
m是區域性變數,在棧中分配.在函式func被呼叫時才被建立.生命週期為函式func內.
n只建立一次.
m每次呼叫func都會建立,函式結束就銷燬.

當Cache命中的時候，CPU訪問記憶體的效率是最高的

由於區域性變數是存在棧中的，當一個函式佔用的棧空間不是很大的時候，這部分記憶體很有可能全部命中cache，這時候CPU訪問的效率是很高的。

相反，如果一個函式裡既使用了全域性變數又使用了局部變數，那麼當這兩段地址相差較大時，cpu cache需要來回切換，那麼效率會下降。

所以不太好說全域性還是區域性變數的效率高

1.訪問M時,用到的是棧基地址暫存器BP作為段基地址,訪問N時,用到的是資料段暫存器DS或者ES作為段基地址.
2.N的空間是程式載入記憶體時執行之前就分配好的.沒有初始化的開銷.M的空間是程式碼執行時分配的.需要至少一個指令週期為M分配空間.
3.N是全域性的,因此它的在程式碼中只要不改變N的值那麼N的值就永遠不變,但是M是在棧內分配的,當函式返回後M的值有可能發生變化,但是M佔的空間還是可以訪問的.這也是為什麼語言強制你不要使用作用域外的變數.你可以訪問M的地址,但是你會發現即使你不對進行改變,它的值也隨著程式的執行在發生變化,並且沒有規律性.
4.從整個程式的效率上說,全域性變數效率高,因為不執行時不用為它分配空間.但是從程式設計角度看,全域性變數隱患較大,不便於維護.
5.單單從訪問變數的效率上來說,全域性變數分配的地址可能沒有對齊.即整數的地址值不是4的倍數.這樣訪問效率不高.而區域性變數的地址往往會經過編譯器優化到與記憶體地址對齊,從而訪問效率較高.