c++多個文件中如何共用一個全局變量

例子：

頭文件：state.h   源文件：state.cpp       

 其它源文件：t1.cpp  t2.cpp  t3.cpp, 這些源文件都包含頭文件state.h。

需要定義一個全局變量供這些源文件中使用：方法如下

1、在 state.h聲明全局變量： extern inta;

2、在state.cpp中定義該全局變量：int a =10;

這樣其它源文件就可以使用該變量啦

 

 

這里需要的是“聲明”，不是“定義”！根據C++標准的規定，一個變量聲明必須同時滿足兩個條件，否則就是定義：  
 (1)聲明必須使用extern關鍵字；(2)不能給變量賦初值    
  extern  int  a;  //聲明 

 int  a;   //定義

 int  a  =  0; //定義

 extern  int  a  =0;   //定義

 

 

     頭文件中應使用extern關鍵字聲明全局變量（不定義），如果這個變量有多個文件用到，可以新建一個cpp，在其中定義，把這個cpp加入工程即可。頭文件請不要定義任何變量，那是非常業余的行為……

    一般在頭文件中申明，用extern,在cpp中定義。 如果在頭文件中定義，如果這個頭文件被多個cpp引用，會造成重復定義的鏈接錯誤。

    頭文件只能申明全局變量（extern），不可定義（不推薦使用）    .cpp里，在最外層定義即可（int gi），直接引用

如果在.cpp里使用static定義，則該變量只在當前cpp文件中有效，在別的文件中無效
在.h里使用static定義，不會進行編譯（.h文件不編譯），只會在其每個include的cpp文件中包含編譯，相當於在.cpp里使用static定義。

轉載：http://www.cnblogs.com/yyxt/p/3891712.html

1 基本解釋：extern可以置於變量或者函數前，以標示變量或者函數的定義在別的文件中，提示編譯器遇到此變量和函數時在其他模塊中尋找其定義。此外extern也可用來進行鏈接指定。

      也就是說extern有兩個作用，第一個,當它與"C"一起連用時，如: extern "C" void fun(int a, int b);則告訴編譯器在編譯fun這個函數名時按着C的規則去翻譯相應的函數名而不是C++的，C++的規則在翻譯這個函數名時會把fun這個名字變得面目全非，可能是fun@aBc_int_int#%$也可能是別的，這要看編譯器的"脾氣"了(不同的編譯器采用的方法不一樣)，為什么這么做呢，因為C++支持函數的重載啊，在這里不去過多的論述這個問題，如果你有興趣可以去網上搜索，相信你可以得到滿意的解釋!（C++ 和 C 采用的名稱修飾規則不同）
    第二，當extern不與"C"在一起修飾變量或函數時，如在頭文件中: extern int g_Int; 它的作用就是聲明函數或全局變量的作用范圍的關鍵字，其聲明的函數和變量可以在本模塊活其他模塊中使用，記住它是一個聲明不是定義!也就是說B模塊(編譯單元)要是引用模塊(編譯單元)A中定義的全局變量或函數時，它只要包含A模塊的頭文件即可,在編譯階段，模塊B雖然找不到該函數或變量，但它不會報錯，它會在連接時從模塊A生成的目標代碼中找到此函數。

2 問題：extern 變量
　　在一個源文件里定義了一個數組：char a[6];
　　在另外一個文件里用下列語句進行了聲明：extern char *a；
　　請問，這樣可以嗎？ 
　　答案與分析：
　　1)、不可以，程序運行時會告訴你非法訪問。原因在於，指向類型T的指針並不等價於類型T的數組。extern char *a聲明的是一個指針變量而不是字符數組，因此與實際的定義不同，從而造成運行時非法訪問。應該將聲明改為extern char a[ ]。
　　2)、例子分析如下，如果a[] = "abcd",則外部變量a=0x61626364 (abcd的ASCII碼值)，*a顯然沒有意義
　　顯然a指向的空間（0x61626364）沒有意義，易出現非法內存訪問。
　　3)、這提示我們，在使用extern時候要嚴格對應聲明時的格式，在實際編程中，這樣的錯誤屢見不鮮。
　　4)、extern用在變量聲明中常常有這樣一個作用，你在*.c文件中聲明了一個全局的變量，這個全局的變量如果要被引用，就放在*.h中並用extern來聲明。

3 問題：單方面修改extern 函數原型
　　當函數提供方單方面修改函數原型時，如果使用方不知情繼續沿用原來的extern申明，這樣編譯時編譯器不會報錯。但是在運行過程中，因為少了或者多了輸入參數，往往會照成系統錯誤，這種情況應該如何解決？
　　答案與分析：
　　目前業界針對這種情況的處理沒有一個很完美的方案，通常的做法是提供方在自己的xxx_pub.h中提供對外部接口的聲明(extern)，然后調用方include該頭文件，從而省去extern這一步。以避免這種錯誤。
　　寶劍有雙鋒，對extern的應用，不同的場合應該選擇不同的做法。

4 問題：extern “C”
　　在C++環境下使用C函數的時候，常常會出現編譯器無法找到obj模塊中的C函數定義，從而導致鏈接失敗的情況，應該如何解決這種情況呢？

　　答案與分析：
　　C++語言在編譯的時候為了解決函數的多態問題，會將函數名和參數聯合起來生成一個中間的函數名稱，而C語言則不會，因此會造成鏈接時找不到對應函數的情況，此時C函數就需要用extern “C”進行鏈接指定，這告訴編譯器，請保持我的名稱，不要給我生成用於鏈接的中間函數名。
　　下面是一個標准的寫法：

//在.h文件的頭上
#ifdef __cplusplus
#if __cplusplus
extern "C"{
　#endif
　#endif /* __cplusplus */ 
　…
　…
　//.h文件結束的地方
　#ifdef __cplusplus
　#if __cplusplus
}
#endif
#endif /* __cplusplus */ 

 

5 問題：extern 函數聲明
　　常常見extern放在函數的前面成為函數聲明的一部分，那么，C語言的關鍵字extern在函數的聲明中起什么作用？
　　答案與分析：
　　如果函數的聲明中帶有關鍵字extern，僅僅是暗示這個函數可能在別的源文件里定義，沒有其它作用。即下述兩個函數聲明沒有明顯的區別：

extern int f(); 

int f();

　　當然，這樣的用處還是有的，就是在程序中取代include “*.h”來聲明函數，在一些復雜的項目中，我比較習慣在所有的函數聲明前添加extern修飾。關於這樣做的原因和利弊可見下面的這個例子：“用extern修飾的全局變量”

    (1) 在test1.h中有下列聲明:

    #ifndef TEST1H
    #define TEST1H
    extern char g_str[]; // 聲明全局變量g_str
    void fun1();
    #endif

    (2) 在test1.cpp中

    #include "test1.h"
        char g_str[] = "123456"; // 定義全局變量g_str
        void fun1() { cout << g_str << endl; }

    (3) 以上是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這個編譯單元不需要再有一份了，不然會在連接時報告重復定義這個錯誤!

注意：如果使用到sizeof，聲明數組需要指定大小 extern char g_str[7]; 因為test2模塊中只是聲明了一個數組，但具體多大，並不知道。若沒有在.h文件中聲明數組大小，會報“非法的sizeof操作數”的錯誤。

　　(4) 有些人喜歡把全局變量的聲明和定義放在一起，這樣可以防止忘記了定義，如把上面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[];  // 沒有include “test1.h”
void fun2()   {  cout << g_str << endl;   }

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

6. extern 和 static

 (1) extern 表明該變量在別的地方已經定義過了,在這里要使用那個變量.
 (2) static 表示靜態的變量，分配內存的時候, 存儲在靜態區,不存儲在棧上面.

    static 作用范圍是內部連接的關系, 和extern有點相反.它和對象本身是分開存儲的,extern也是分開存儲的,但是extern可以被其他的對象用extern 引用,而static 不可以,只允許對象本身用它. 具體差別首先，static與extern是一對“水火不容”的家伙，也就是說extern和static不能同時修飾一個變量；其次，static修飾的全局變量聲明與定義同時進行，也就是說當你在頭文件中使用static聲明了全局變量（類外部）后（如果在頭文件的class內部聲明static變量，那么其定義式通常位於實現（.cpp）文件中，例外的，只有const int類型可以in class 初值設定），它也同時被定義了；最后，static修飾全局變量的作用域只能是本身的編譯單元（內部鏈接,參見 存儲持續性、作用域和鏈接性），也就是說它的“全局”只對本編譯單元有效，其他編譯單元則看不到它,如:
    (1) test1.h:

#ifndef TEST1H
#define TEST1H
static char g_str[] = "123456"; 
void fun1();
#endif

    (2) test1.cpp:

#include "test1.h"
void fun1()  {   cout << g_str << endl;  }

    (3) test2.cpp

#include "test1.h"
void fun2()  {   cout << g_str << endl;  }

    以上兩個編譯單元可以連接成功, 當你打開test1.obj時，你可以在它里面找到字符串"123456",同時你也可以在test2.obj中找到它們，它們之所以可以連接成功而沒有報重復定義的錯誤是因為雖然它們有相同的內容，但是存儲的物理地址並不一樣，就像是兩個不同變量賦了相同的值一樣，而這兩個變量分別作用於它們各自的編譯單元。 也許你比較較真，自己偷偷的跟蹤調試上面的代碼,結果你發現兩個編譯單元（test1,test2）的g_str的內存地址相同，於是你下結論static修飾的變量也可以作用於其他模塊，但是我要告訴你，那是你的編譯器在欺騙你，大多數編譯器都對代碼都有優化功能，以達到生成的目標程序更節省內存，執行效率更高，當編譯器在連接各個編譯單元的時候，它會把相同內容的內存只拷貝一份，比如上面的"123456", 位於兩個編譯單元中的變量都是同樣的內容，那么在連接的時候它在內存中就只會存在一份了，如果你把上面的代碼改成下面的樣子，你馬上就可以拆穿編譯器的謊言:
    (1) test1.cpp:

#include "test1.h"
void fun1()
{
   g_str[0] = ''a'';
   cout << g_str << endl;
}

    (2) test2.cpp

#include "test1.h"
void fun2()  {  cout << g_str << endl;  }

    (3) 

void main()     {
        fun1(); // a23456
        fun2(); // 123456
    }

    這個時候你在跟蹤代碼時，就會發現兩個編譯單元中的g_str地址並不相同，因為你在一處修改了它，所以編譯器被強行的恢復內存的原貌，在內存中存在了兩份拷貝給兩個模塊中的變量使用。正是因為static有以上的特性，所以一般定義static全局變量時，都把它放在原文件中而不是頭文件，這樣就不會給其他模塊造成不必要的信息污染，同樣記住這個原則吧！

7. extern 和const

   C++中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".

【轉】http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777431.html

 

/*************************************************************************/

extern 用法，全局變量與頭文件（重復定義） 

用#include 可以包含其他頭文件中變量、函數的聲明，為什么還要extern關鍵字,如果我想引用一個全局變量或函數a，我只要直接在源文件中包含#include<xxx.h> (xxx.h包含了a的聲明)不就可以了么，為什么還要用extern呢？？這個問題一直也是似是而非的 困擾着我許多年了，今天上網狠狠查了一下總算小有所獲了：

頭文件

首先說下頭文件，其實頭文件對計算機而言沒什么作用，她只是在預編譯時在#include的地方展開一下，沒別的意義了，其實頭文件主要是給別人看的。

我做過一個實驗，將頭文件的后綴改成xxx.txt，然后在引用該頭文件的地方用

#include"xxx.txt"

編譯，鏈接都很順利的過去了，由此可知，頭文件僅僅為閱讀代碼作用，沒其他的作用了！

不管是C還是C++，你把你的函數，變量或者結構體，類啥的放在你的.c或者.cpp文件里。然后編譯成lib,dll,obj,.o等等，然后別人用的時候最基本的gcc hisfile.cpp yourfile.o|obj|dll|lib 等等。
但對於我們程序員而言，他們怎么知道你的lib,dll...里面到底有什么東西？要看你的頭文件。你的頭文件就是對用戶的說明。函數，參數，各種各樣的接口的說明。
那既然是說明，那么頭文件里面放的自然就是關於函數，變量，類的“聲明”了。記着，是“聲明”，不是“定義”。
那么，我假設大家知道聲明和定義的區別。所以，最好不要傻嘻嘻的在頭文件里定義什么東西。比如全局變量：

#ifndef _XX_頭文件.H
#define _XX_頭文件.H
int A;
#endif

那么，很糟糕的是，這里的int A是個全局變量的定義，所以如果這個頭文件被多次引用的話，你的A會被重復定義.
顯 然語法上錯了。只不過有了這個#ifndef的條件編譯，所以能保證你的頭文件只被引用一次，不過也許還是會岔子，但若多個c文件包含這個頭文件時還是會 出錯的，因為宏名有效范圍僅限於本c源文件，所以在這多個c文件編譯時是不會出錯的，但在鏈接時就會報錯，說你多處定義了同一個變量，

Linking...
incl2.obj : error LNK2005: "int glb" (?glb@@3HA) already defined in incl1.obj
Debug/incl.exe : fatal error LNK1169: one or more multiply defined symbols found

注意！！！

extern

這個關鍵字真的比較可惡，在聲明的時候，這個extern居然可以被省略，所以會讓你搞不清楚到底是聲明還是定義，下面分變量和函數兩類來說：

（1）變量

尤其是對於變量來說。

extern int a;//聲明一個全局變量a
int a; //定義一個全局變量a
extern int a =0 ;//定義一個全局變量a 並給初值。
int a =0;//定義一個全局變量a,並給初值，

第四個 等於 第 三個，都是定義一個可以被外部使用的全局變量，並給初值。
糊塗了吧，他們看上去可真像。但是定義只能出現在一處。也就是說，不管是int a;還是extern int a=0;還是int a=0;都只能出現一次，而那個extern int a可以出現很多次。

當你要引用一個全局變量的時候，你就要聲明，extern int a;這時候extern不能省略，因為省略了，就變成int a;這是一個定義，不是聲明。

（2）函數
對於函數也一樣，也是定義和聲明，定義的時候用extern，說明這個函數是可以被外部引用的，聲明的時候用extern說明這是一個聲明。 但由於函數的定義和聲明是有區別的，定義函數要有函數體，聲明函數沒有函數體，所以函數定義和聲明時都可以將extern省略掉，反正其他文件也是知道這個函數是在其他地方定義的，所以不加extern也行。兩者如此不同，所以省略了extern也不會有問題。
比如：

int fun(void)
{
    return 0;
}

很好，我們定義了一個全局函數

int fun(void);

我們對它做了個聲明，然后后面就可以用了, 加不加extern都一樣.
我們也可以把對fun的聲明 放在一個頭文件里，最后變成這樣

int fun(void);//函數聲明，所以省略了extern，完整些是extern int fun(void);
int fun(void)
{
　　return 0;
}//一個完整的全局函數定義，因為有函數體，extern同樣被省略了。

然后，一個客戶，一個要使用你的fun的客戶，把這個頭文件包含進去，ok，一個全局的聲明。沒有問題。
但是，對應的，如果是這個客戶要使用全局變量，那么要extern 某某變量；不然就成了定義了。

總結下：

對變量而言，如果你想在本源文件中使用另一個源文件的變量，就需要在使用前用extern聲明該變量，或者在頭文件中用extern聲明該變量；

對函數而言，如果你想在本源文件中使用另一個源文件的函數，就需要在使用前用聲明該變量，聲明函數加不加extern都沒關系，所以在頭文件中函數可以不用加extern。

C程序采用模塊化的編程思想，需合理地將一個很大的軟件划分為一系列功能獨立的部分合作完成系統的需求，在模塊的划分上主要依據功能。模塊由頭文件和實現文件組成，對頭文件和實現文件的正確使用方法是：
規則1　頭文件(.h)中是對於該模塊接口的聲明，接口包括該模塊提供給其它模塊調用的外部函數及外部全局變量，對這些變量和函數都需在.h中文件中冠以extern關鍵字聲明；
規則2 模塊內的函數和全局變量需在.c文件開頭冠以static關鍵字聲明；
規則3 永遠不要在.h文件中定義變量；
許多程序員對定義變量和聲明變量混淆不清，定義變量和聲明變量的區別在於定義會產生內存分配的操作，是匯編階段的概念；而聲明則只是告訴包含該聲明的模塊在連接階段從其它模塊尋找外部函數和變量。如：
int a = 5;
#include “module1.h”
#include “module1.h”
#include “module1.h”
以上程序的結果是在模塊1、2、3中都定義了整型變量a，a在不同的模塊中對應不同的地址單元，這明顯不符合編寫者的本意。正確的做法是：
extern int a;
#include “module1.h”
int a = 5;
#include “module1.h”
#include “module1.h” 　
這樣如果模塊1、2、3操作a的話，對應的是同一片內存單元。

規則4 如果要用其它模塊定義的變量和函數，直接包含其頭文件即可。
許多程序員喜歡這樣做，當他們要訪問其它模塊定義的變量時，他們在本模塊文件開頭添加這樣的語句：
extern int externVar;　
拋棄這種做法吧，只要頭文件按規則1完成，某模塊要訪問其它模塊中定義的全局變量時，只要包含該模塊的頭文件即可。

共享變量聲明
就像在函數間共享變量的方式一樣，變量可以在文件中共享。為了共享函數，要把函數的定義放在一個源文件中，然后在需要調用此函數的其他文件中放置聲明。共享變量的方法和此方式非常類似。
在此之前，不需要區別變量的聲明和它的定義。為了聲明變量i，寫成如下形式：
int i; 
這樣不僅聲明i是int型的變量，而且也對i進行了定義，從而使編譯器為i留出了空間。為了聲明沒有定義的變量i，需要在變量聲明的開始處放置關鍵字extern：
extern int i;
extern提示編譯器變量i是在程序中的其他位置定義的（大多數可能是在不同的源文件中），因此不需要為i分配空間。
順便說一句，extern可以用於所有類型的變量。在數組的聲明中使用extern時，可以忽略數組的長度：
extern int a[];
因為此刻編譯器不用為數組a分配空間，所以也就不需要知道數組a的長度了。
為了在幾個源文件中共享變量i，首先把變量i的定義放置在一個文件中：
int i;
如果需要對變量i初始化，那么可以在這里放初始值。在編譯這個文件時，編譯器將會為變量i分配內存空間，而其他文件將包含變量i的聲明：
extern int i;
通過在每個文件中聲明變量i，使得在這些文件中可以訪問/或修改變量i。然而，由於關鍵字extern，使得編譯器不會在每次編譯其中某個文件時為變量i分配額外的內存空間。
當在文件中共享變量時，會面臨和共享函數時相似的挑戰：確保變量的所有聲明和變量的定義一致。
為了避免矛盾，通常把共享變量的聲明放置在頭文件中。需要訪問特殊變量的源文件可以稍后包含適當的頭文件。此外，含有變量定義的源文件包含每一個含有變量聲明的頭文件，這樣使編譯器可以檢查兩者是否匹配。

如果工程很大，頭文件很多，而有幾個頭文件又是經常要用的，那么
1。把這些頭文件全部寫到一個頭文件里面去，比如寫到preh.h
2。寫一個preh.c，里面只一句話：#include "preh.h"
3。對於preh.c，在project setting里面設置creat precompiled headers，對於其他c文件，設置use precompiled header file