作用域是一個在絕大多數（事實上我沒有見過沒有作用域概念的程序語言）程序語言的必然組成部分。日常良好的使用使用習慣和程序設計風格，有時候讓我們漸漸忘記了這些作用域的準確定義，因為它通常沒給我們帶來什么麻煩。這里我將其寫下來，僅在勾起大家模糊回憶中清晰的輪廓，也許有你所知的，也許有你所惑的，又或者可能我的理解和你的理解甚至格格不入，煩請大家積極指正。
幾個概念：
a.外部變量，許多程序設計的書上用“全局變量”一詞，這里做一個統一，本文中“外部變量”就是所謂的“全局變量”。
b.自動變量，許多程序設計的書上用“局部變量”一詞，這里做一個統一，本文中“自動變量”就是所謂的也可以稱作“動態局部變量”，與此相對的還有“靜態局部變量”，這兩種局部變量的并集就是通常所說的“局部變量”了。
這兩種叫法都是有其特定的道理和闡述的意義的。局部變量就是直言了其作用的范圍，它是局部的可見的（這一點您應該深有體會）。因為在一個函數內聲明一個變量，形如int a;它從它的聲明式開始，直到該函數的末尾（以“}”符號所標識）有效。在函數體的外部，該變量a不存在并且無效。這樣的聲明事實上是auto int a;聲明式的一種省略寫法，因此稱之為“自動變量”，因為它在該函數調用開始的時候初始化內存空間，在調用結束的時候將釋放該函數的內存空間，而這一切不需要人工的干預，因此它是自動的。
c.靜態變量，又稱之為“靜態局部變量”，它通常與auto int a;的形式相反，它采用了static關鍵字進行修飾，static int a;。這樣的聲明導致了它在編譯時就分配了內存空間，并在整個程序的運行過程中持續有效。唯一的限制是它僅在它所在的函數范圍內有效。
1、外部變量的作用域從它聲明的位置開始，到其所在（待編譯）的文件的末尾結束。
參看以下代碼：
#include <stdio.h>
#include <stdlib.h>
void extern1Processor(void);
int main(void){
/*下面的語句因為extern1Variable變量的定義在main函數的后面
* 因此該函數將產生編譯錯誤。
* extern1Variable' undeclared (first use in this function)
printf("main.extern1Variable:%d\n",extern1Variable);*/
extern1Processor();
return EXIT_SUCCESS;
}
int extern1Variable = 2003;
/*下面能夠正確使用extern1Variable變量，因為extern1Variable的
* 定義在extern1Processor(void);方法之上。*/
void extern1Processor(void){
printf("extern1Processor.extern1Variable:%d\n",extern1Variable);
}
2、如果要在外部變量的定義之前使用該變量，則必須在相應的變量聲明中強制地使用關鍵字extern。
參看以下代碼：
#include <stdio.h>
#include <stdlib.h>
void extern2Processor(void);
int main(void) {
extern int extern2Variable;
printf("extern2Processor.extern2Variable:%d\n", extern2Variable);
extern2Processor();
return EXIT_SUCCESS;
}
int extern2Variable = 2004;
void extern2Processor(void) {
printf("extern2Processor.extern2Variable:%d\n", extern2Variable);
}輸出結果：
extern2Processor.extern2Variable:2004
extern2Processor.extern2Variable:2004
3、如果外部變量的定義與變量的使用不在同一個源文件中，則必須在相應的變量聲明中強制地使用關鍵字extern。
假設在不同的源文件file1.c與file2.c中，我們都需要定義一個變量int aVariable = 2;時，分別編譯二者，它們將都包含一個變量aVariable的聲明和定義。但是當我們將它們一起加載的時候，由于它們都是外部變量，相同的變量名導致編譯器不知道它們的主次關系。因此，這里我們要求程序員一定要用extern將主次分出來。比如file1.c中int aVariable = 2;這句話聲明了aVariable的類型為int，為它分配了sizeof(int)內存大小的一塊內存空間，它的值為2。在file2.c中我們聲明它extern int aVariable;（這里不能使用extern int aVariable=3;但是可以使用int aVariable;）這句話告訴了編譯器aVariable不是我這個源文件中進行聲明的，它來自外部（一個未知的位置）。這樣在單獨編譯該文件gcc -c file2.c的時候就不會因為缺失聲明式而引發編譯錯誤了。
有同學認為這里的int aVariable;是聲明，不是定義，這是一種錯誤的觀點。在外部變量中，形如：
file1.c file2.c
---------------------------------------------------------------
int aVariable = 3; int aVariable;
int main(){
……
}其中的int aVariable;定義了外部變量aVariable，并為之分配了存儲單元。
這同時也成為了外部變量和靜態變量必須是常量表達式，且只初始化一次的理由。如果我們對兩邊都進行初始化（定義），編譯器將不知道讓誰成為主要初始化的值。事實上，外部變量和靜態變量的值初始化過程是在編譯時進行的，它們的值都被放在靜態存儲區，也就是我們慣常在匯編中的DATA SEGMENT部分，因此它們必須是常量表達式，并且有且只有初始化一次，否則我們將可能寫出類似這樣的語句（而這樣的語句本身就是錯誤的）：
DATA SETMENT
INFO1 "INFOMATION1"
"INFOMATION2" ;這樣的定義是不允許的
DATA ENDS
……按照概念extern通常被看作是外部的，因此通常情況下初始化操作一般是在無extern的聲明式后的，若在extern一邊進行初始化，則有違常理（主次不分了）。但是由于將初始化步驟僅放在extern一邊滿足只初始化一次的原則，因此編譯不會出錯，但是根據不同的編譯器可能會給出警告提示。
參看以下代碼：
包含main的源文件：
#include <stdio.h>
#include <stdlib.h>
void extern3Processor(void);
int main(void) {
extern3Processor();
return EXIT_SUCCESS;
}
extern int extern3Variable;
void extern3Processor(void) {
printf("extern3Processor.extern3Variable:%d\n", extern3Variable);
}externFile.c文件：（這個文件很簡單，就包含了一個外部變量的定義）
int extern3Variable = 2005;
編譯多個文件如下：（將.c文件編譯為.o文件，再將這幾個.o文件一起加載到.exe文件中（UNIX中通常為.out文件），通常在對個別文件作出修改后，我們只需要重新編譯那個文件，然后將這些新舊.o文件一起加載到.exe文件中即可。）
gcc -O0 -g3 -Wall -c -fmessage-length=0 -osrc\EffectiveArea.o ..\src\EffectiveArea.c
gcc -O0 -g3 -Wall -c -fmessage-length=0 -osrc\externFile.o ..\src\externFile.c
gcc -oEffectiveArea.exe src\externFile.o src\EffectiveArea.o
輸出結果：
extern3Processor.extern3Variable:2005
4、之前提到的文字中包含“聲明”和“定義”，它們其實有著嚴格的區別。
聲明：變量聲明用于說明變量的屬性（主要是變量的類型）
定義：變量定義除了需要聲明之外，還引起了存儲器分配。
5、在步驟3中我們發現在任意文件中定義的外部變量均可在其它文件中進行使用，只要我們使用了extern關鍵字告訴編譯器這個變量的聲明式，我們就可以順利通過編譯。雖然這個方式能夠實現在多個文件中共享數據，但是考慮到文件的管理與項目的不可預測性，這樣的方式未免讓我們有了些許的擔心。要是我定義的變量被別人惡意引用了怎么辦？對于只進行讀操作的行為，可能這種災難是比較小的，但是對于寫操作的行為，就有可能影響到變量的正確性。
用static聲明限定外部變量和函數，可以將其后聲明的對象的作用域限定為被編譯源文件的剩余部分。
參看以下代碼：
包含main的源文件：
#include <stdio.h>
#include <stdlib.h>
void static1Processor(void);
int main(void) {
static1Processor();
return EXIT_SUCCESS;
}
extern int static1Variable;
void static1Processor(void) {
printf("static3Processor.static3Variable:%d\n", static1Variable);
}staticFile.c文件：（這個文件很簡單，就包含了一個外部變量的定義，與externFile.c所不同的是它的定義增加了static關鍵字修飾）：
static int static1Variable = 2006;
輸出結果（編譯錯誤，無任何輸出結果）：
由于static int static1Variable = 2006;導致了static1Variable變量只對staticFile.c文件可見。
對于函數，它也是具有類似的限制：
包含main的源文件：
#include <stdio.h>
#include <stdlib.h>
/*兩種定義均無法引用void static2Processor(void);方法的具體實現。*/
/*void static2Processor(void);*/
extern void static2Processor(void);
int main(void) {
static2Processor();
return EXIT_SUCCESS;
}staticFile.c：
#include <stdio.h>
static int static2Variable = 2007;
static void static2Processor(void) {
printf("static2Processor.static1Variable:%d\n", static2Variable);
}static不僅可以用于聲明外部變量，它還可以用于聲明內部變量。static類型的內部變量同自動變量一樣，是某個特定局部變量，只能在該函數中使用，但它與自動變量不同的是，不管其所在函數是否被調用，它將一直存在，而不像自動變量那樣，隨著所在函數的被調用和退出而存在和消失。換句話說，static類型的內部變量只是一種只能在某個特定函數中使用但一直占據存儲空間的變量。
6、因為extern是為了防止重復定義，而不是防止重復聲明。因此對于不可能產生重復定義的函數聲明式來說，形如void extern4Processor(void); 這樣的語句可以不用增加extern，因為它是重復的聲明，而不是定義。
因為函數聲明式本身是不允許嵌套的，因此它天生就是外部的，所以默認情況下類似void FunctionName(){……};的形式都有個默認的修飾符extern void FunctionName(){……};只有標識了static的函數不是外部函數。
包含main的源文件：
#include <stdio.h>
#include <stdlib.h>
/*double kinds of declare
* The storage-class specifier, if any,in the declaration specifiers
* shall be either extern or static .
*/
/*extern void extern4Processor(void);*/
void extern4Processor(void);
int main(void) {
extern4Processor();
return EXIT_SUCCESS;
}
externFile.c：
#include <stdio.h>
int extern4Variable = 2008;
void extern4Processor(void) {
printf("extern4Processor.extern4Variable:%d\n", extern4Variable);
}輸出結果：
extern4Processor.extern4Variable:2008
7、重復聲明并不可怕，可怕的是重復定義。
參看以下代碼：
包含main的源文件：
#include <stdio.h>
#include <stdlib.h>
char repeatVariableWithoutDefinition1; /*declear thrice no hurt*/
char repeatVariableWithoutDefinition1; /*declear thrice no hurt*/
char repeatVariableWithoutDefinition1; /*declear thrice no hurt*/
void repeatVariableWithoutDefinition1Func(void);
int main(void) {
repeatVariableWithoutDefinition1Func();
return EXIT_SUCCESS;
}
void repeatVariableWithoutDefinition1Func(void) {
repeatVariableWithoutDefinition1 = 'v';
printf("repeatVariableWithoutDefinition1:%c\n",
repeatVariableWithoutDefinition1);
}otherFile.c：
char repeatVariableWithoutDefinition1;
char repeatVariableWithoutDefinition1;
它的無害是因為它們都是在編譯時進行分配的，它們并沒有并存，只是僅存了一個罷了。
8、至此，上面已經生成了許多的聲明/定義。可以看出，我們的函數是可以跨文件調用的，而且每次調用都要寫函數聲明式。為此，C語言支持“頭文件”，也就是我們經常看到的#include "xxxxx.h"或#include <stdio.h>。其中include <>的時候，將根據相應規則查找該文件（通常在編譯器所在Includes文件夾內找），但是""的時候總是先在源文件（*.c）所在文件夾查找，若找不到則使用與#include <>相同規則進行查找。
#include是一個C預處理器，它所指定的文件將在編譯時，將其中內容原封不動地替換到#include語句所在的位置。這樣的話，我們就有能力實現了一個地方定義函數，多個地方調用的功能了。（每次重新寫聲明式難免會造成：1、手誤，導致拼寫錯誤；2、修改維護困難，可能會漏掉，但又機緣巧合不會出錯。）
#include頭文件中可以推薦包含文件聲明、宏替換等（事實上可以包含任何的文本）。
因為可以包含任何的文本，所以我們有可能因為重復定義而導致一些不必要的麻煩，因為畢竟重復定義是沒有任何意義的，還增加編譯時間。因此在頭文件的內部，我們通常采用條件包含來避免重復地包含。
參看以下代碼：
#ifndef EFFECTIVEAREA_H_
#define EFFECTIVEAREA_H_
/*define the content of EffectiveArea.h here!*/
#endif /* EFFECTIVEAREA_H_ */
注意，宏名字是全局有效的，因此我們必須保證它的唯一性，否則，在判斷的時候，就會因為兩個頭文件之間的互相排斥（被認為是同一個文件），但事實上它們之間只是錯誤地定義了名字。為此我們可以用文件名的等價轉換來包含它們，因為文件名是唯一的。（文件名包含它的路徑，通常我們將頭文件放入同一個文件夾下，因此我們可以保證在同級文件夾下的文件名的唯一性。）
這樣我們就可以隨心所欲地包含頭文件了，而不必擔心重復包含頭文件所帶來的壞處了。
9、對于函數簽名聲明返回值類型為int的可以省略（不推薦（引發警告））。
參看以下代碼：
#include <stdio.h>
#include <stdlib.h>
/*We can omit the declaration of function here only when it's returnType is int.
* It only cause compile warning "implicit declaration of function 'nodeclare1Func'"
* Because the default function returnType is 'int'. */
/*But we suggest you explicit declare your function here.*/
/*int nodeclare1Func(int param1); */
/*We can not omit anything here!*/
char nodeclare2Func(void);
int main(void) {
nodeclare1Func(2009);
nodeclare2Func();
return EXIT_SUCCESS;
}
int nodeclare1Func(int param1) {
printf("nodeclare1Func.param1:%d\n", param1);
return EXIT_SUCCESS;
}
char nodeclare2Func(void) {
printf("nodeclare2Func.i:%d\n", 2010);
return 'c';
}作用域的內容并不難，掌握它們雖然不需要花費太多的時間（當然我還是比較推崇認真掌握了），但是我們應該從使用習慣上做到合理準確地應用這些特性。對于出現的一些錯誤能夠給出合理的解釋。