一.extern

1 基本解釋

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

也就是說extern有兩個作用，第一個,當它與"C"一起連用時，如: extern “C” void fun(int a, int b);則告訴編譯器在編譯fun這個函數名時按著C的規則去翻譯相應的函數名而不是C++的，C++的規則在翻譯這個函數名時會把fun這個名字變得面目全非，可能是fun@aBc_int_int#%$也可能是別的，這要看編譯器的"脾氣"了(不同的編譯器采用的方法不一樣)，為什么這么做呢，因為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中提供對外部接口的聲明，然后調用方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這個編譯單元不需要再有一份了，不然會在連接時報告重復定義這個錯誤!
(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[];
void fun2() { cout << g_str << endl; }
這個時候編譯器就知道g_str是引自于外部的一個編譯模塊了，不會在本模塊中再重復定義一個出來，但是我想說這樣做非常糟糕，因為你由于無法在test2.cpp中使用#include “test1.h”,那么test1.h中聲明的其他函數你也無法使用了，除非也用都用extern修飾，這樣的話你光聲明的函數就要一大串，而且頭文件的作用就是要給外部提供接口使用的，所以 請記住， 只在頭文件中做聲明，真理總是這么簡單。

6. extern 和 static

(1) extern 表明該變量在別的地方已經定義過了,在這里要使用那個變量.
(2) static 表示靜態的變量，分配內存的時候, 存儲在靜態區,不存儲在棧上面.
對于一個完整的程序，在內存中的分布情況如下圖：　
1.棧區： 由編譯器自動分配釋放，像局部變量，函數參數，都是在棧區。會隨著作用于退出而釋放空間。
3.堆區：程序員分配并釋放的區域，像malloc?,new(c++)
3.全局數據區(靜態區)：全局變量和靜態便令的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。程序結束釋放。
4.代碼區

static 作用范圍是內部連接的關系, 和extern有點相反.它和對象本身是分開存儲的,extern也是分開存儲的,但是extern可以被其他的對象用extern 引用,而static 不可以,只允許對象本身用它. 具體差別首先，static與extern是一對“水火不容”的家伙，也就是說extern和static不能同時修飾一個變量；其次，static修飾的全局變量聲明與定義同時進行，也就是說當你在頭文件中使用static聲明了全局變量后，它也同時被定義了；最后，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并不是常量，它被看做是一個定義了的全局變量（可以被其他編譯單元使用）， 所以如果你像讓charg_str遵守const的全局常量的規則，最好這么定義const char* const g_str=“123456”.

二.static

C 語言的 static 關鍵字有三種（具體來說是兩種）用途：

靜態局部變量：用于函數體內部修飾變量，這種變量的生存期長于該函數。

int foo(){static int i = 1; // note:1//int i = 1; // note:2i += 1;return i;}

要明白這個用法，我們首先要了解c/c++的內存分布，以及static所在的區間。

對于一個完整的程序，在內存中的分布情況如下圖：　
1.棧區： 由編譯器自動分配釋放，像局部變量，函數參數，都是在棧區。會隨著作用于退出而釋放空間。
3.堆區：程序員分配并釋放的區域，像malloc?,new(c++)
3.全局數據區(靜態區)：全局變量和靜態便令的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。程序結束釋放。
4.代碼區

所以上面note:1的static是在全局數據區分配的,那么它存在的意思是什么？又是什么時候初始化的呢？

首先回答第一個問題：它存在的意義就是隨著第一次函數的調用而初始化，卻不隨著函數的調用結束而銷毀(如果把以上的note:1換成note:2,那么i就是在棧區分配了，會隨著foo的調用結束而釋放)。
那么第二個問題也就浮出水面了，它是在第一次調用進入note:1的時候初始化（當初面試被坑過，我居然說是一開始就初始化了，汗！！）。且只初始化一次，也就是你第二次調用foo(),不會繼續初始化，而會直接跳過。

那么它跟定義一個全局變量有什么區別呢，同樣是初始化一次，連續調用foo()的結果是一樣的，但是，使用全局變量的話，變量就不屬于函數本身了，不再僅受函數的控制，給程序的維護帶來不便。
　　靜態局部變量正好可以解決這個問題。靜態局部變量保存在全局數據區，而不是保存在棧中，每次的值保持到下一次調用，直到下次賦新值。

那么我們總結一下，靜態局部變量的特點（括號內為note:2,也就是局部變量的對比）：
（1）該變量在全局數據區分配內存(局部變量在棧區分配內存);
（2）靜態局部變量在程序執行到該對象的聲明處時被首次初始化，即以后的函數調用不再進行初始化(局部變量每次函數調用都會被初始化);
（3）靜態局部變量一般在聲明處初始化，如果沒有顯式初始化，會被程序自動初始化為0(局部變量不會被初始化);
（4）它始終駐留在全局數據區，直到程序運行結束。但其作用域為局部作用域，也就是不能在函數體外面使用它(局部變量在棧區，在函數結束后立即釋放內存);

2.靜態全局變量：定義在函數體外，用于修飾全局變量，表示該變量只在本文件可見。

static int i = 1; //note:3 //int i = 1; //note:4int foo() {i += 1;return i; }

note:3和note:4有什么差異呢？你調用foo(),無論調用幾次，他們的結果都是一樣的。也就是說在本文件內調用他們是完全相同的。那么他們的區別是什么呢？
文件隔離！

假設我有一個文件a.c,我們再新建一個b.c,內容如下。

//file a.c//static int n = 15; //note:5 int n = 15; //note:6//file b.c #include <stdio.h>extern int n;void fn() {n++;printf("after: %d\n",n); }void main() {printf("before: %d\n",n);fn(); }

我們先使用note:6,也就是非靜態全局變量，發現輸出為:
before: 15
after: 16

也就是我們的b.c通過extern使用了a.c定義的全局變量。
那么我們改成使用note:5,也就是使用靜態全局變量呢？
gcc a.c b.c -o output.out

會出現類似undeference to "n"的報錯，它是找不到n的，因為static進行了文件隔離，你是沒辦法訪問a.c定義的靜態全局變量的，當然你用 #include “a.c”,那就不一樣了。

以上我們就可以得出靜態全局變量的特點：

靜態全局變量不能被其它文件所用(全局變量可以);
其它文件中可以定義相同名字的變量，不會發生沖突(自然了，因為static隔離了文件，其它文件使用相同的名字的變量，也跟它沒關系了);

3.靜態函數：準確的說，靜態函數跟靜態全局變量的作用類似：

//file a.c #include <stdio.h>void fn() {printf("this is non-static func in a"); }//file b.c #include <stdio.h>extern void fn(); //我們用extern聲明其他文件的fn(),供本文件使用。void main() {fn(); }

可以正常輸出：this is non-static func in a。
當給void fn()加上static的關鍵字之后呢？ undefined reference to “fn”.

所以，靜態函數的好處跟靜態全局變量的好處就類似了：
1.靜態函數不能被其它文件所用;
2.其它文件中可以定義相同名字的函數，不會發生沖突;

上面一共說了三種用法，為什么說準確來說是兩種呢？
1.一種是修飾變量，一種是修飾函數，所以說是兩種（這種解釋不多）。
2.靜態全局變量和修飾靜態函數的作用是一樣的，一般合并為一種。（這是比較多的分法）。

C++ 語言的 static 關鍵字有二種用途：

當然以上的幾種，也可以用在c++中。還有額外的兩種用法：

1.靜態數據成員：用于修飾 class 的數據成員，即所謂“靜態成員”。這種數據成員的生存期大于 class 的對象（實體 instance）。靜態數據成員是每個 class 有一份，普通數據成員是每個 instance 有一份，因此靜態數據成員也叫做類變量，而普通數據成員也叫做實例變量。

#include<iostream>using namespace std;class Rectangle { private:int m_w,m_h;static int s_sum;public:Rectangle(int w,int h){this->m_w = w;this->m_h = h;s_sum += (this->m_w * this->m_h);}void GetSum(){cout<<"sum = "<<s_sum<<endl;}};int Rectangle::s_sum = 0; //初始化int main() {cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;Rectangle *rect1 = new Rectangle(3,4);rect1->GetSum();cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;Rectangle rect2(2,3);rect2.GetSum();cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;system("pause");return 0; }

結果如下：

由圖可知：sizeof(Rectangle)=8bytes=sizeof(m_w)+sizeof(m_h)。也就是說 static 并不占用Rectangle的內存空間。
那么static在哪里分配內存的呢？是的，全局數據區(靜態區)。
再看看GetSum()，第一次12=34，第二次18=12+23。由此可得，static只會被初始化一次，于實例無關。
結論：

對于非靜態數據成員，每個類對象(實例)都有自己的拷貝。而靜態數據成員被當作是類的成員，由該類型的所有對象共享訪問,對該類的多個對象來說，靜態數據成員只分配一次內存。
靜態數據成員存儲在全局數據區。靜態數據成員定義時要分配空間，所以不能在類聲明中定義。

也就是說，你每new一個Rectangle，并不會為static int s_sum的構建一份內存拷貝，它是不管你new了多少Rectangle的實例，因為它只與類Rectangle掛鉤，而跟你每一個Rectangle的對象沒關系。

2、靜態成員函數：用于修飾 class 的成員函數。
我們對上面的例子稍加改動：

#include<iostream>using namespace std;class Rectangle { private:int m_w,m_h;static int s_sum;public:Rectangle(int w,int h){this->m_w = w;this->m_h = h;s_sum += (this->m_w * this->m_h);}static void GetSum() //這里加上static{cout<<"sum = "<<s_sum<<endl;}};int Rectangle::s_sum = 0; //初始化int main() {cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;Rectangle *rect1 = new Rectangle(3,4);rect1->GetSum();cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;Rectangle rect2(2,3);rect2.GetSum(); //可以用對象名.函數名訪問cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;Rectangle::GetSum(); //也可以可以用類名::函數名訪問system("pause");return 0; }

上面注釋可見:對GetSum()加上static，使它變成一個靜態成員函數，可以用類名::函數名進行訪問。
那么靜態成員函數有特點呢？
1.靜態成員之間可以相互訪問，包括靜態成員函數訪問靜態數據成員和訪問靜態成員函數;
2.非靜態成員函數可以任意地訪問靜態成員函數和靜態數據成員;
3.靜態成員函數不能訪問非靜態成員函數和非靜態數據成員;
4.調用靜態成員函數，可以用成員訪問操作符(.)和(->)為一個類的對象或指向類對象的指針調用靜態成員函數,也可以用類名::函數名調用(因為他本來就是屬于類的，用類名調用很正常)

前三點其實是一點：靜態成員函數不能訪問非靜態(包括成員函數和數據成員)，但是非靜態可以訪問靜態，有點暈嗎？沒關系，我給你個解釋，
因為靜態是屬于類的，它是不知道你創建了10個還是100個對象，所以它對你對象的函數或者數據是一無所知的，所以它沒辦法調用，而反過來，你創建的對象是對類一清二楚的(不然你怎么從它那里實例化呢)，所以你是可以調用類函數和類成員的，就像不管GetSum是不是static，都可以調用static的s_sum一樣。

為什么靜態成員不能在類內初始化

在C++中，類的靜態成員（static member）必須在類內聲明，在類外初始化，像下面這樣。

class A { private:static int count ; // 類內聲明 };int A::count = 0 ; // 類外初始化，不必再加static關鍵字

為什么？因為靜態成員屬于整個類，而不屬于某個對象，如果在類內初始化，會導致每個對象都包含該靜態成員，這是矛盾的。

C語言中 在一個函數中用 static修飾的變量，還能給它賦上新值嗎？

可以，static在C語言中是表示一個變量為靜態變量的，而不是常量，也不是不可變的變量。所謂的靜態變量有兩種情況，一種是靜態全局變量，一種是靜態局部變量。
先說靜態局部變量：通常情況下，在一個函數中定義一個變量，那么函數退出之后，這個變量就消失了，即使你第二次調用這個函數，里面的變量也會被重新賦初值。比如我們寫一個函數：

int fun(int a) {int sum; sum=sum+a; return sum;}

這樣無論你是第幾次調用fun這個函數，sum都會重新被賦初值，也就是函數的返回值一直會是a；而不會出現多次調用累加的情況。
但如果你在一個函數中，用static來聲明變量，那么這個變量雖然在函數外部不可用，但退出函數時，這個變量是不會消失的，下一次再調用這個函數，里面的值仍然存在。就說上面這個函數，如果你的第一句寫成static int sum;那么你第一次調用fun(3);函數返回3，第二次再調用fun(5);函數返回值是8,因為第一次調用之后的sum=3的值不會消失。
另一種是靜態全局變量。因為是全局變量，不存在退出函數消不消失的問題。所以靜態全局變量和普通全局變量的區別是：普通全局變量在其他源文件中可以通過extern全局變量名的聲明，來使用該變量，而靜態全局變量只能在變量所在的文件中使用，即使你在其他文件中使用extern聲明也不可以使用，這樣可以有效避免不同文件全局變量的沖突。

總結

以上是生活随笔為你收集整理的C C++中关于全局变量静态变量，extern，static，const的区别与总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。