C語言程序設計基礎講座之函數

2019-11-17 05:35:15

字體：大中小

來源：轉載

供稿：網友

概述

　　在第一章中已經介紹過，C源程序是由函數組成的。雖然在前面各章的程序中都只有一個主函數main()，但實用程序往往由多個函數組成。函數是C源程序的基本模塊，通過對函數模塊的調用實現特定的功能。C語言中的函數相當于其它高級語言的子程序。 C語言不僅提供了極為豐富的庫函數(如Turbo C，MS C 都提供了三百多個庫函數)，還答應用戶建立自己定義的函數。用戶可把自己的算法編成一個個相對獨立的函數模塊，然后用調用的方法來使用函數。

　　可以說C程序的全部工作都是由各式各樣的函數完成的，所以也把C語言稱為函數式語言。由于采用了函數模塊式的結構， C語言易于實現結構化程序設計。使程序的層次結構清楚，便于程序的編寫、閱讀、調試。

　　在C語言中可從不同的角度對函數分類。

　　1. 從函數定義的角度看，函數可分為庫函數和用戶定義函數兩種。

　　(1)庫函數

　　由C系統提供，用戶無須定義，也不必在程序中作類型說明，只需在程序前包含有該函數原型的頭文件即可在程序中直接調用。在前面各章的例題中反復用到PRintf 、 scanf 、 getchar 、putchar、gets、puts、strcat等函數均屬此類。

　　(2)用戶定義函數

　　由用戶按需要寫的函數。對于用戶自定義函數，不僅要在程序中定義函數本身，而且在主調函數模塊中還必須對該被調函數進行類型說明，然后才能使用。

　　2. C語言的函數兼有其它語言中的函數和過程兩種功能，從這個角度看，又可把函數分為有返回值函數和無返回值函數兩種。

　　(1)有返回值函數

　　此類函數被調用執行完后將向調用者返回一個執行結果，稱為函數返回值。如數學函數即屬于此類函數。由用戶定義的這種要返回函數值的函數，必須在函數定義和函數說明中明確返回值的類型。

　　(2)無返回值函數

　　此類函數用于完成某項特定的處理任務，執行完成后不向調用者返回函數值。這類函數類似于其它語言的過程。由于函數無須返回值，用戶在定義此類函數時可指定它的返回為“空類型”，空類型的說明符為“void”。

　　3. 從主調函數和被調函數之間數據傳送的角度看又可分為無參函數和有參函數兩種。

　　(1)無參函數

　　函數定義、函數說明及函數調用中均不帶參數。主調函數和被調函數之間不進行參數傳送。此類函數通常用來完成一組指定的功能，可以返回或不返回函數值。

　　(2)有參函數

　　也稱為帶參函數。在函數定義及函數說明時都有參數，稱為形式參數(簡稱為形參)。在函數調用時也必須給出參數，稱為實際參數(簡稱為實參)。進行函數調用時，主調函數將把實參的值傳送給形參，供被調函數使用。

　　4. C語言提供了極為豐富的庫函數，這些庫函數又可從功能角度作以下分類。

　　(1)字符類型分類函數

　　用于對字符按ASCII碼分類：字母，數字，控制字符，分隔符，大小寫字母等。

　　(2)轉換函數

　　用于字符或字符串的轉換；在字符量和各類數字量 (整型，實型等)之間進行轉換；在大、小寫之間進行轉換。

　　(3)目錄路徑函數

　　用于文件目錄和路徑操作。

　　(4)診斷函數

　　用于內部錯誤檢測。

　　(5)圖形函數

　　用于屏幕治理和各種圖形功能。

　　(6)輸入輸出函數

　　用于完成輸入輸出功能。

　　(7)接口函數

　　用于與DOS，BIOS和硬件的接口。

　　(8)字符串函數

　　用于字符串操作和處理。

　　(9)內存治理函數

　　用于內存治理。

　　(10)數學函數

　　用于數學函數計算。

　　(11)日期和時間函數

　　用于日期，時間轉換操作。

　　(12)進程控制函數

　　用于進程治理和控制。

　　(13)其它函數

　　用于其它各種功能。
　　
　　以上各類函數不僅數量多，而且有的還需要硬件知識才會使用，因此要想全部把握則需要一個較長的學習過程。應首先把握一些最基本、最常用的函數，再逐步深入。由于篇幅關系，本書只介紹了很少一部分庫函數，其余部分讀者可根據需要查閱有關手冊。

　　還應該指出的是，在C語言中，所有的函數定義，包括主函數main在內，都是平行的。也就是說，在一個函數的函數體內，不能再定義另一個函數，即不能嵌套定義。但是函數之間答應相互調用，也答應嵌套調用。習慣上把調用者稱為主調函數。函數還可以自己調用自己，稱為遞歸調用。main 函數是主函數，它可以調用其它函數，而不答應被其它函數調用。因此，C程序的執行總是從main函數開始，完成對其它函數的調用后再返回到main函數，最后由main函數結束整個程序。一個C源程序必須有，也只能有一個主函數main。 函數定義的一般形式

　　1.無參函數的一般形式

　　類型說明符函數名()
　　{
　　　類型說明
　　　語句
　　}

　　其中類型說明符和函數名稱為函數頭。類型說明符指明了本函數的類型，函數的類型實際上是函數返回值的類型。該類型說明符與第二章介紹的各種說明符相同。函數名是由用戶定義的標識符，函數名后有一個空括號，其中無參數，但括號不可少。{} 中的內容稱為函數體。在函數體中也有類型說明，這是對函數體內部所用到的變量的類型說明。在很多情況下都不要求無參函數有返回值，此時函數類型符可以寫為void。

　　我們可以改為一個函數定義：

void Hello()
{
　printf ("Hello,world /n");
}
　　這里，只把main改為Hello作為函數名，其余不變。Hello 函數是一個無參函數，當被其它函數調用時，輸出Hello world字符串。

　　2.有參函數的一般形式

　　類型說明符函數名(形式參數表)

　　型式參數類型說明
　　{
　　　類型說明
　　　語句
　　}

　　有參函數比無參函數多了兩個內容，其一是形式參數表，其二是形式參數類型說明。在形參表中給出的參數稱為形式參數，它們可以是各種類型的變量，各參數之間用逗號間隔。在進行函數調用時，主調函數將賦予這些形式參數實際的值。形參既然是變量，當然必須給以類型說明。例如，定義一個函數，用于求兩個數中的大數，可寫為：

int max(a,b)
int a,b;
{
if (a>b) return a;
else return b;
}
　　第一行說明max函數是一個整型函數，其返回的函數值是一個整數。形參為a,b。第二行說明a,b均為整型量。 a,b 的具體值是由主調函數在調用時傳送過來的。在{}中的函數體內，除形參外沒有使用其它變量，因此只有語句而沒有變量類型說明。上邊這種定義方法稱為“傳統格式”。這種格式不易于編譯系統檢查，從而會引起一些非常細微而且難于跟蹤的錯誤。ANSI C 的新標準中把對形參的類型說明合并到形參表中，稱為“現代格式”。

　　例如max函數用現代格式可定義為：

int max(int a,int b)
{
if(a>b) return a;
else return b;
}
　　現代格式在函數定義和函數說明(后面將要介紹)時，給出了形式參數及其類型，在編譯時易于對它們進行查錯，從而保證了函數說明和定義的一致性。例1.3即采用了這種現代格式。在max函數體中的return語句是把a(或b)的值作為函數的值返回給主調函數。有返回值函數中至少應有一個return語句。在C程序中，一個函數的定義可以放在任意位置，既可放在主函數main之前，也可放在main之后。例如例1.3中定義了一個max 函數，其位置在main之后，也可以把它放在main之前。

　　修改后的程序如下所示。

int max(int a,int b)
{
if(a>b)return a;
else return b;
}
void main()
{
int max(int a,int b);
int x,y,z;
printf("input two numbers:/n");
scanf("%d%d",&x,&y);
z=max(x,y);
printf("maxmum=%d",z);
}
　　現在我們可以從函數定義、函數說明及函數調用的角度來分析整個程序，從中進一步了解函數的各種特點。程序的第1行至第5行為max函數定義。進入主函數后，因為預備調用max函數，故先對max函數進行說明(程序第8行)。函數定義和函數說明并不是一回事，在后面還要專門討論。可以看出函數說明與函數定義中的函數頭部分相同，但是末尾要加分號。程序第12 行為調用max函數，并把x,y中的值傳送給max的形參a,b。max函數執行的

　　結果 (a或b)將返回給變量z。最后由主函數輸出z的值。

　　函數調用的一般形式前面已經說過，在程序中是通過對函數的調用來執行函數體的，其過程與其它語言的子程序調用相似。C語言中，函數調用的一般形式為：

　　函數名(實際參數表) 對無參函數調用時則無實際參數表。實際參數表中的參數可以是常數，變量或其它構造類型數據及表達式。各實參之間用逗號分隔。'Next of Page在C語言中，可以用以下幾種方式調用函數：

　　1.函數表達式

　　函數作表達式中的一項出現在表達式中，以函數返回值參與表達式的運算。這種方式要求函數是有返回值的。例如： z=max(x,y)是一個賦值表達式，把max的返回值賦予變量z。'Next of Page

　　2.函數語句

　　函數調用的一般形式加上分號即構成函數語句。例如： printf ("%D",a);scanf ("%d",&b);都是以函數語句的方式調用函數。

　　3.函數實參

　　函數作為另一個函數調用的實際參數出現。這種情況是把該函數的返回值作為實參進行傳送，因此要求該函數必須是有返回值的。例如： printf("%d",max(x,y)); 即是把max調用的返回值又作為printf函數的實參來使用的。在函數調用中還應該注重的一個問題是求值順序的問題。所謂求值順序是指對實參表中各量是自左至右使用呢，還是自右至左使用。對此，各系統的規定不一定相同。在3.1.3節介紹printf 函數時已提

　　到過，這里從函數調用的角度再強調一下。看例5.2程序。

void main()
{
int i=8;
printf("%d/n%d/n%d/n%d/n",++i,--i,i++,i--);
}
　　如按照從右至左的順序求值。例5.2的運行結果應為：

　　8
　　7
　　7
　　8

　　如對printf語句中的++i，--i，i++，i--從左至右求值，結果應為：

　　9
　　8
　　8
　　9

　　應非凡注重的是，無論是從左至右求值，還是自右至左求值，其輸出順序都是不變的，即輸出順序總是和實參表中實參的順序相同。由于Turbo C現定是自右至左求值，所以結果為8，7，7，8。上述問題如還不理解，上機一試就明白了。函數的參數和函數的值 一、函數的參數

　　前面已經介紹過，函數的參數分為形參和實參兩種。在本小節中，進一步介紹形參、實參的特點和兩者的關系。形參出現在函數定義中，在整個函數體內都可以使用，離開該函數則不能使用。實參出現在主調函數中，進入被調函數后，實參變量也不能使用。形參和實參的功能是作數據傳送。發生函數調用時，主調函數把實參的值傳送給被調函數的形參從而實現主調函數向被調函數的數據傳送。

　　函數的形參和實參具有以下特點：

　　1.形參變量只有在被調用時才分配內存單元，在調用結束時，即刻釋放所分配的內存單元。因此，形參只有在函數內部有效。函數調用結束返回主調函數后則不能再使用該形參變量。

　　2.實參可以是常量、變量、表達式、函數等，無論實參是何種類型的量，在進行函數調用時，它們都必須具有確定的值，以便把這些值傳送給形參。因此應預先用賦值，輸入等辦法使實參獲得確定值。

　　3.實參和形參在數量上，類型上，順序上應嚴格一致，否則會發生“類型不匹配”的錯誤。

　　4.函數調用中發生的數據傳送是單向的。即只能把實參的值傳送給形參，而不能把形參的值反向地傳送給實參。因此在函數調用過程中，形參的值發生改變，而實參中的值不會變化。例5.3可以說明這個問題。

void main()
{
int n;
printf("input number/n");
scanf("%d",&n);
s(n);
printf("n=%d/n",n);
}
int s(int n)
{
int i;
for(i=n-1;i>=1;i--)
n=n+i;
printf("n=%d/n",n);
}
　　本程序中定義了一個函數s，該函數的功能是求∑ni=1i 的值。在主函數中輸入n值，并作為實參，在調用時傳送給s 函數的形參量n( 注重，本例的形參變量和實參變量的標識符都為n，但這是兩個不同的量，各自的作用域不同)。在主函數中用printf 語句輸出一次n值，這個n值是實參n的值。在函數s中也用printf 語句輸出了一次n值，這個n值是形參最后取得的n值0。從運行情況看，輸入n值為100。即實參n的值為100。把此值傳給函數s時，形參 n 的初值也為100，在執行函數過程中，形參n的值變為5050。返回主函數之后，輸出實參n的值仍為100。可見實參的值不隨形參的變化而變化。

　　二、函數的值

　　函數的值是指函數被調用之后，執行函數體中的程序段所取得的并返回給主調函數的值。如調用正弦函數取得正弦值，調用例5.1的max函數取得的最大數等。對函數的值(或稱函數返回值)有以下一些說明：

　　1. 函數的值只能通過return語句返回主調函數。return 語句的一般形式為：

　　return 表達式；

　　或者為：

　　return (表達式)；

　　該語句的功能是計算表達式的值，并返回給主調函數。在函數中答應有多個return語句，但每次調用只能有一個return 語句被執行，因此只能返回一個函數值。

　　2. 函數值的類型和函數定義中函數的類型應保持一致。假如兩者不一致，則以函數類型為準，自動進行類型轉換。

　　3. 如函數值為整型，在函數定義時可以省去類型說明。

　　4. 不返回函數值的函數，可以明確定義為“空類型”，類型說明符為“void”。如例5.3中函數s并不向主函數返函數值，因此可定義為：

void s(int n)
{ ……
}
　　一旦函數被定義為空類型后，就不能在主調函數中使用被調函數的函數值了。例如，在定義s為空類型后，在主函數中寫下述語句 sum=s(n); 就是錯誤的。為了使程序有良好的可讀性并減少出錯，凡不要求返回值的函數都應定義為空類型。函數說明在主調函數中調用某函數之前應對該被調函數進行說明，這與使用變量之前要先進行變量說明是一樣的。在主調函數中對被調函數作說明的目的是使編譯系統知道被調函數返回值的類型，以便在主調函數中按此種類型對返回值作相應的處理。對被調函數的說明也有兩種格式，一種為傳統格式，其一般格式為：類型說明符被調函數名()；這種格式只給出函數返回值的類型，被調函數名及一個空括號。

　　這種格式由于在括號中沒有任何參數信息，因此不便于編譯系統進行錯誤檢查，易于發生錯誤。另一種為現代格式，其一般形式為：

　　類型說明符被調函數名(類型形參，類型形參…)；

　　或為：

　　類型說明符被調函數名(類型，類型…)；

　　現代格式的括號內給出了形參的類型和形參名，或只給出形參類型。這便于編譯系統進行檢錯，以防止可能出現的錯誤。例5.1 main函數中對max函數的說明若

　　用傳統格式可寫為：

int max();
　　用現代格式可寫為：

int max(int a,int b);
　　或寫為:

int max(int,int)；
　　C語言中又規定在以下幾種情況時可以省去主調函數中對被調函數的函數說明。

　　1. 假如被調函數的返回值是整型或字符型時，可以不對被調函數作說明，而直接調用。這時系統將自動對被調函數返回值按整型處理。例5.3的主函數中未對函數s作說明而直接調用即屬此種情形。

　　2. 當被調函數的函數定義出現在主調函數之前時，在主調函數中也可以不對被調函數再作說明而直接調用。例如例5.1中，函數max的定義放在main 函數之前，因此可在main函數中省去對 max函數的函數說明int max(int a,int b)。

　　3. 如在所有函數定義之前，在函數外預先說明了各個函數的類型，則在以后的各主調函數中，可不再對被調函數作說明。例如：

char str(int a);
float f(float b);
main()
{
……
}
char str(int a)
{
……
}
float f(float b)
{
……
}
　　其中第一，二行對str函數和f函數預先作了說明。因此在以后各函數中無須對str和f函數再作說明就可直接調用。

　　4. 對庫函數的調用不需要再作說明，但必須把該函數的頭文件用include命令包含在源文件前部。數組作為函數參數數組可以作為函數的參數使用，進行數據傳送。數組用作函數參數有兩種形式，一種是把數組元素(下標變量)作為實參使用；另一種是把數組名作為函數的形參和實參使用。一、數組元素作函數實參數組元素就是下標變量，它與普通變量并無區別。因此它作為函數實參使用與普通變量是完全相同的，在發生函數調用時，把作為實參的數組元素的值傳送給形參，實現單向的值傳送。例5.4說明了這種情況。[例5.4]判別一個整數數組中各元素的值，若大于0 則輸出該值，若小于等于0則輸出0值。編程如下：

void nzp(int v)
{
if(v>0)
printf("%d ",v);
else
printf("%d ",0);
}
main()
{
int a[5],i;
printf("input 5 numbers/n");
for(i=0;i<5;i++)
{
scanf("%d",&a[i]);
nzp(a[i]);
}
}void nzp(int v)
{ ……
}
main()
{
int a[5],i;
printf("input 5 numbers/n");
for(i=0;i<5;i++)
{ scanf("%d",&a[i]);
nzp(a[i]);
}
}
　　本程序中首先定義一個無返回值函數nzp，并說明其形參v 為整型變量。在函數體中根據v值輸出相應的結果。在main函數中用一個for 語句輸入數組各元素，每輸入一個就以該元素作實參調用一次nzp函數，即把a[i]的值傳送給形參v，供nzp函數使用。
二、數組名作為函數參數

　　用數組名作函數參數與用數組元素作實參有幾點不同：

　　1. 用數組元素作實參時，只要數組類型和函數的形參變量的類型一致，那么作為下標變量的數組元素的類型也和函數形參變量的類型是一致的。因此，并不要求函數的形參也是下標變量。換句話說，對數組元素的處理是按普通變量對待的。用數組名作函數參數時，則要求形參和相對應的實參都必須是類型相同的數組，都必須有明確的數組說明。當形參和實參二者不一致時，即會發生錯誤。

　　2. 在普通變量或下標變量作函數參數時，形參變量和實參變量是由編譯系統分配的兩個不同的內存單元。在函數調用時發生的值傳送是把實參變量的值賦予形參變量。在用數組名作函數參數時，不是進行值的傳送，即不是把實參數組的每一個元素的值都賦予形參數組的各個元素。因為實際上形參數組并不存在，編譯系統不為形參數組分配內存。那么，數據的傳送是如何實現的呢? 在第四章中我們曾介紹過，數組名就是數組的首地址。因此在數組名作函數參數時所進行的傳送只是地址的傳送，也就是說把實參數組的首地址賦予形參數組名。形參數組名取得該首地址之后，也就等于有了實在的數組。實際上是形參數組和實參數組為同一數組，共同擁有一段內存空間。圖5.1說明了這種情形。圖中設a為實參數組，類型為整型。a占有以2000 為首地址的一塊內存區。b為形參數組名。當發生函數調用時，進行地址傳送，把實參數組a的首地址傳送給形參數組名b，于是b也取得該地址2000。于是a，b兩數組共同占有以2000 為首地址的一段連續內存單元。從圖中還可以看出a和b下標相同的元素實際上也占相同的兩個內存單元(整型數組每個元素占二字節)。例如a[0]和b[0]都占用2000和2001單元，當然a[0]等于b[0]。類推則有a[i]等于b[i]。

　　[例5.5]數組a中存放了一個學生5門課程的成績，求平均成績。float aver(float a[5])

{
int i;
float av,s=a[0];
for(i=1;i<5;i++)
s=s+a[i];
av=s/5;
return av;
}
void main()
{
float sco[5],av;
int i;
printf("/ninput 5 scores:/n");
for(i=0;i<5;i++)
scanf("%f",&sco[i]);
av=aver(sco);
printf("average score is %5.2f",av);
}
float aver(float a[5])
{ ……
}
void main()
{
……
for(i=0;i<5;i++)
scanf("%f",&sco[i]);
av=aver(sco);
……
}
　　本程序首先定義了一個實型函數aver，有一個形參為實型數組a，長度為5。在函數aver中，把各元素值相加求出平均值，返回給主函數。主函數main 中首先完成數組sco的輸入，然后以sco作為實參調用aver函數，函數返回值送av，最后輸出av值。從運行情況可以看出，程序實現了所要求的功能

　　3. 前面已經討論過，在變量作函數參數時，所進行的值傳送是單向的。即只能從實參傳向形參，不能從形參傳回實參。形參的初值和實參相同，而形參的值發生改變后，實參并不變化，兩者的終值是不同的。例5.3證實了這個結論。而當用數組名作函數參數時，情況則不同。由于實際上形參和實參為同一數組，因此當形參數組發生變化時，實參數組也隨之變化。當然這種情況不能理解為發生了“雙向”的值傳遞。但從實際情況來看，調用函數之后實參數組的值將由于形參數組值的變化而變化。為了說明這種情況，把例5.4改為例5.6的形式。[例5.6]題目同5.4例。改用數組名作函數參數。

void nzp(int a[5])
{
int i;
printf("/nvalues of array a are:/n");
for(i=0;i<5;i++)
{
if(a[i]<0) a[i]=0;
printf("%d ",a[i]);
}
}
main()
{
int b[5],i;
printf("/ninput 5 numbers:/n");
for(i=0;i<5;i++)
scanf("%d",&b[i]);
printf("initial values of array b are:/n");
for(i=0;i<5;i++)
printf("%d ",b[i]);
nzp(b);
printf("/nlast values of array b are:/n");
for(i=0;i<5;i++)
printf("%d ",b[i]);
}
void nzp(int a[5])
{ ……
}
main()
{
int b[5],i;
……
nzp(b);
……
}
　　本程序中函數nzp的形參為整數組a，長度為 5。主函數中實參數組b也為整型，長度也為5。在主函數中首先輸入數組b的值，然后輸出數組b的初始值。然后以數組名b為實參調用nzp函數。在nzp中，按要求把負值單元清0，并輸出形參數組a的值。返回主函數之后，再次輸出數組b的值。從運行結果可以看出，數組b 的初值和終值是不同的，數組b 的終值和數組a是相同的。這說明實參形參為同一數組，它們的值同時得以改變。用數組名作為函數參數時還應注重以下幾點：

　　a. 形參數組和實參數組的類型必須一致，否則將引起錯誤。

　　b. 形參數組和實參數組的長度可以不相同，因為在調用時，只傳送首地址而不檢查形參數組的長度。當形參數組的長度與實參數組不一致時，雖不至于出現語法錯誤(編譯能通過)，但程序執行結果將與實際不符，這是應予以注重的。如把例5.6修改如下：

void nzp(int a[8])
{
int i;
printf("/nvalues of array aare:/n");
for(i=0;i<8;i++)
{
if(a[i]<0)a[i]=0;
printf("%d",a[i]);
}
}
main()
{
int b[5],i;
printf("/ninput 5 numbers:/n");
for(i=0;i<5;i++)
scanf("%d",&b[i]);
printf("initial values of array b are:/n");
for(i=0;i<5;i++)
printf("%d",b[i]);
nzp(b);
printf("/nlast values of array b are:/n");
for(i=0;i<5;i++)
printf("%d",b[i]);
}
　　本程序與例5.6程序比，nzp函數的形參數組長度改為8，函數體中，for語句的循環條件也改為i<8。因此，形參數組 a和實參數組b的長度不一致。編譯能夠通過，但從結果看，數組a的元素a[5]，a[6]，a[7]顯然是無意義的。c. 在函數形參表中，答應不給出形參數組的長度，或用一個變量來表示數組元素的個數。

　　例如：可以寫為：

void nzp(int a[])
　　或寫為

void nzp(int a[]，int n)
　　其中形參數組a沒有給出長度，而由n值動態地表示數組的長度。n的值由主調函數的實參進行傳送。

　　由此，例5.6又可改為例5.7的形式。

　　[例5.7]

void nzp(int a[],int n)
{
int i;
printf("/nvalues of array a are:/n");
for(i=0;i<n;i++)
{
if(a[i]<0) a[i]=0;
printf("%d ",a[i]);
}
}
main()
{
int b[5],i;
printf("/ninput 5 numbers:/n");
for(i=0;i<5;i++)
scanf("%d",&b[i]);
printf("initial values of array b are:/n");
for(i=0;i<5;i++)
printf("%d ",b[i]);
nzp(b,5);
printf("/nlast values of array b are:/n");
for(i=0;i<5;i++)
printf("%d ",b[i]);
}
void nzp(int a[],int n)
{ ……
}
main()
{
……
nzp(b,5);
……
}

　　本程序nzp函數形參數組a沒有給出長度，由n 動態確定該長度。在main函數中，函數調用語句為nzp(b，5)，其中實參5將賦予形參n作為形參數組的長度。

　　d. 多維數組也可以作為函數的參數。在函數定義時對形參數組可以指定每一維的長度，也可省去第一維的長度。因此，以下寫法都是合法的。

int MA(int a[3][10])
　　或

int MA(int a[][10])
　　函數的嵌套調用

　　C語言中不答應作嵌套的函數定義。因此各函數之間是平行的，不存在上一級函數和下一級函數的問題。但是C語言答應在一個函數的定義中出現對另一個函數的調用。這樣就出現了函數的嵌套調用。即在被調函數中又調用其它函數。這與其它語言的子程序嵌套的情形是類似的。其關系可表示如圖5.2。

　　圖5.2表示了兩層嵌套的情形。其執行過程是：執行main函數中調用a函數的語句時，即轉去執行a函數，在a函數中調用b 函數時，又轉去執行b函數，b函數執行完畢返回a函數的斷點繼續執行，a 函數執行完畢返回main函數的斷點繼續執行。

　　[例5.8]計算s=22!+32!

　　本題可編寫兩個函數，一個是用來計算平方值的函數f1，另一個是用來計算階乘值的函數f2。主函數先調f1計算出平方值，再在f1中以平方值為實參，調用 f2計算其階乘值，然后返回f1，再返回主函數，在循環程序中計算累加和。

long f1(int p)
{
int k;
long r;
long f2(int);
k=p*p;
r=f2(k);
return r;
}
long f2(int q)
{
long c=1;
int i;
for(i=1;i<=q;i++)
c=c*i;
return c;
}
main()
{
int i;
long s=0;
for (i=2;i<=3;i++)
s=s+f1(i);
printf("/ns=%ld/n",s);
}
long f1(int p)
{
……
long f2(int);
r=f2(k);
……
}
long f2(int q)
{
……
}
main()
{ ……
s=s+f1(i);
……
}
　　在程序中，函數f1和f2均為長整型，都在主函數之前定義，故不必再在主函數中對f1和f2加以說明。在主程序中，執行循環程序依次把i值作為實參調用函數f1求i2值。在f1中又發生對函數f2的調用，這時是把i2的值作為實參去調f2，在f2 中完成求i2! 的計算。f2執行完畢把C值(即i2!)返回給f1，再由f1 返回主函數實現累加。至此，由函數的嵌套調用實現了題目的要求。由于數值很大，所以函數和一些變量的類型都說明為長整型，否則會造成計算錯誤。 函數的遞歸調用

　　一個函數在它的函數體內調用它自身稱為遞歸調用。這種函數稱為遞歸函數。C語言答應函數的遞歸調用。在遞歸調用中，主調函數又是被調函數。執行遞歸函數將反復調用其自身。每調用一次就進入新的一層。例如有函數f如下：

int f (int x)
{
int y;
z=f(y);
return z;
}
　　這個函數是一個遞歸函數。但是運行該函數將無休止地調用其自身，這當然是不正確的。為了防止遞歸調用無終止地進行，必須在函數內有終止遞歸調用的手段。常用的辦法是加條件判定，滿足某種條件后就不再作遞歸調用，然后逐層返回。下面舉例說明遞歸調用的執行過程。

　　[例5.9]用遞歸法計算n!用遞歸法計算n!可用下述公式表示：

n!=1 (n=0,1)
n×(n-1)! (n>1)
按公式可編程如下：
long ff(int n)
{
long f;
if(n<0) printf("n<0,input error");
else if(n==0n==1) f=1;
else f=ff(n-1)*n;
return(f);
}
main()
{
int n;
long y;
printf("/ninput a inteager number:/n");
scanf("%d",&n);
y=ff(n);
printf("%d!=%ld",n,y);
}
long ff(int n)
{ ……
else f=ff(n-1)*n;
……
}
main()
{ ……
y=ff(n);
……
}
　　程序中給出的函數ff是一個遞歸函數。主函數調用ff 后即進入函數ff執行，假如n<0,n==0或n=1時都將結束函數的執行，否則就遞歸調用ff函數自身。由于每次遞歸調用的實參為n-1，即把n-1 的值賦予形參n，最后當n-1的值為1時再作遞歸調用，形參n的值也為1，將使遞歸終止。然后可逐層退回。下面我們再舉例說明該過程。設執行本程序時輸入為5，即求 5!。在主函數中的調用語句即為y=ff(5)，進入ff函數后，由于n=5,不等于0或1，故應執行f=ff(n-1)*n,即f=ff(5-1)*5。該語句對ff作遞歸調用即ff(4)。逐次遞歸展開如圖5.3所示。進行四次遞歸調用后，ff函數形參取得的值變為1，故不再繼續遞歸調用而開始逐層返回主調函數。ff(1)的函數返回值為1，ff(2)的返回值為1*2=2，ff(3)的返回值為2*3=6，ff(4) 的返回值為6*4=24，最后返回值ff(5)為24*5=120。

　　例5. 9也可以不用遞歸的方法來完成。如可以用遞推法，即從1開始乘以2，再乘以3…直到n。遞推法比遞歸法更輕易理解和實現。但是有些問題則只能用遞歸算法才能實現。典型的問題是Hanoi塔問題。
　　
　　[例5.10]Hanoi塔問題

　　一塊板上有三根針，A，B，C。A針上套有64個大小不等的圓盤，大的在下，小的在上。如圖5.4所示。要把這64個圓盤從A針移動C針上，每次只能移動一個圓盤，移動可以借助B針進行。但在任何時候，任何針上的圓盤都必須保持大盤在下，小盤在上。求移動的步驟。

　　本題算法分析如下，設A上有n個盤子。

　　假如n=1，則將圓盤從A直接移動到C。

　　假如n=2，則：

　　1.將A上的n-1(等于1)個圓盤移到B上；

　　2.再將A上的一個圓盤移到C上；

　　3.最后將B上的n-1(等于1)個圓盤移到C上。

　　假如n=3，則：

　　A. 將A上的n-1(等于2，令其為n`)個圓盤移到B(借助于C)，

　　步驟如下：

　　(1)將A上的n`-1(等于1)個圓盤移到C上，見圖5.5(b)。

　　(2)將A上的一個圓盤移到B，見圖5.5(c)

　　(3)將C上的n`-1(等于1)個圓盤移到B，見圖5.5(d)

　　B. 將A上的一個圓盤移到C，見圖5.5(e)

　　C. 將B上的n-1(等于2，令其為n`)個圓盤移到C(借助A)，

　　步驟如下：

　　(1)將B上的n`-1(等于1)個圓盤移到A，見圖5.5(f)

　　(2)將B上的一個盤子移到C，見圖5.5(g)

　　(3)將A上的n`-1(等于1)個圓盤移到C，見圖5.5(h)。

　　到此，完成了三個圓盤的移動過程。

　　從上面分析可以看出，當n大于等于2時，移動的過程可分解為三個步驟：

　　第一步把A上的n-1個圓盤移到B上；

　　第二步把A上的一個圓盤移到C上；

　　第三步把B上的n-1個圓盤移到C上；其中第一步和第三步是類同的。

　　當n=3時，第一步和第三步又分解為類同的三步，即把n`-1個圓盤從一個針移到另一個針上，這里的n`=n-1。顯然這是一個遞歸過
程，據此算法可編程如下：

move(int n,int x,int y,int z)
{
if(n==1)
printf("%c-->%c/n",x,z);
else
{
move(n-1,x,z,y);
printf("%c-->%c/n",x,z);
move(n-1,y,x,z);
}
}
main()
{
int h;
printf("/ninput number:/n");
scanf("%d",&h);
printf("the step to moving %2d diskes:/n",h);
move(h,'a','b','c');
}
move(int n,int x,int y,int z)
{
if(n==1)
printf("%-->%c/n",x,z);
else
{
move(n-1,x,z,y);
printf("%c-->%c/n",x,z);
move(n-1,y,x,z);
}
}
main()
{ ……
move(h,'a','b','c');
}
　　從程序中可以看出,move函數是一個遞歸函數，它有四個形參n,x,y,z。n表示圓盤數，x,y,z分別表示三根針。move 函數的功能是把x上的n個圓盤移動到z 上。當n==1時，直接把x上的圓盤移至z上，輸出x→z。如n!=1則分為三步：遞歸調用move函數，把n-1個圓盤從x移到y；輸出x→z；遞歸調用move函數，把n-1個圓盤從y移到z。在遞歸調用過程中n=n-1，故n的值逐次遞減，最后n=1時，終止遞歸，逐層返回。當n=4 時程序運行的結果為

input number:
4
the step to moving 4 diskes:
a→b
a→c
b→c
a→b
c→a
c→b
a→b
a→c
b→c
b→a
c→a
b→c
a→b
a→c
b→c 變量的作用域

　　在討論函數的形參變量時曾經提到，形參變量只在被調用期間才分配內存單元，調用結束立即釋放。這一點表明形參變量只有在函數內才是有效的，離開該函數就不能再使用了。這種變量有效性的范圍稱變量的作用域。不僅對于形參變量， C語言中所有的量都有自己的作用域。變量說明的方式不同，其作用域也不同。 C語言中的變量，按作用域范圍可分為兩種，即局部變量和全局變量。

　　一、局部變量

　　局部變量也稱為內部變量。局部變量是在函數內作定義說明的。其作用域僅限于函數內，離開該函數后再使用這種變量是非法的。

　　例如：

int f1(int a) /*函數f1*/
{
int b,c;
……
}a,b,c作用域
int f2(int x) /*函數f2*/
{
int y,z;
}x,y,z作用域
main()
{
int m,n;
}
　　m,n作用域在函數f1內定義了三個變量，a為形參，b,c為一般變量。在 f1的范圍內a,b,c有效，或者說a,b,c變量的作用域限于f1內。同理，x,y,z的作用域限于f2內。 m,n的作用域限于main函數內。關于局部變量的作用域還要說明以下幾點：

　　1. 主函數中定義的變量也只能在主函數中使用，不能在其它函數中使用。同時，主函數中也不能使用其它函數中定義的變量。因為主函數也是一個函數，它與其它函數是平行關系。這一點是與其它語言不同的，應予以注重。

　　2. 形參變量是屬于被調函數的局部變量，實參變量是屬于主調函數的局部變量。

　　3. 答應在不同的函數中使用相同的變量名，它們代表不同的對象，分配不同的單元，互不干擾，也不會發生混淆。如在例5.3 中，形參和實參的變量名都為n，是完全答應的。4. 在復合語句中也可定義變量，其作用域只在復合語句范圍內。例如：

main()
{
int s,a;
……
{
int b;
s=a+b;
……b作用域
}
……s,a作用域
}[例5.11]main()
{
int i=2,j=3,k;
k=i+j;
{
int k=8;
if(i==3) printf("%d/n",k);
}
printf("%d/n%d/n",i,k);
}
main()
{
int i=2,j=3,k;
k=i+j;
{
int k=8;
if(i=3) printf("%d/n",k);
}
printf("%d/n%d/n",i,k);
}

　　本程序在main中定義了i,j,k三個變量，其中k未賦初值。而在復合語句內又定義了一個變量k，并賦初值為8。應該注重這兩個k不是同一個變量。在復合語句外由main定義的k起作用，而在復合語句內則由在復合語句內定義的k起作用。因此程序第4行的k為main所定義，其值應為5。第7行輸出k值，該行在復合語句內，由復合語句內定義的k起作用，其初值為8，故輸出值為8，第9行輸出i，k值。i是在整個程序中有效的，第7行對i賦值為3，故以輸出也為3。而第9行已在復合語句之外，輸出的k應為main所定義的k，此k值由第4 行已獲得為5，故輸出也為5。

　　二、全局變量

　　全局變量也稱為外部變量，它是在函數外部定義的變量。它不屬于哪一個函數，它屬于一個源程序文件。其作用域是整個源程序。在函數中使用全局變量，一般應作全局變量說明。只有在函數內經過說明的全局變量才能使用。全局變量的說明符為extern。但在一個函數之前定義的全局變量，在該函數內使用可不再加以說明。例如：

int a,b; /*外部變量*/
void f1() /*函數f1*/
{
……
}
float x,y; /*外部變量*/
int fz() /*函數fz*/
{
……
}
main() /*主函數*/
{
……
}/*全局變量x,y作用域全局變量a,b作用域*/
　　從上例可以看出a、b、x、y 都是在函數外部定義的外部變量，都是全局變量。但x,y 定義在函數f1之后，而在f1內又無對x,y的說明，所以它們在f1內無效。 a,b定義在源程序最前面，因此在f1,f2及main內不加說明也可使用。

　　[例5.12]輸入正方體的長寬高l,w,h。求體積及三個面x*y,x*z,y*z的面積。

int s1,s2,s3;
int vs( int a,int b,int c)
{
int v;
v=a*b*c;
s1=a*b;
s2=b*c;
s3=a*c;
return v;
}
main()
{
int v,l,w,h;
printf("/ninput length,width and height/n");
scanf("%d%d%d",&l,&w,&h);
v=vs(l,w,h);
printf("v=%d s1=%d s2=%d s3=%d/n",v,s1,s2,s3);
}
　　本程序中定義了三個外部變量s1,s2,s3，用來存放三個面積，其作用域為整個程序。函數vs用來求正方體體積和三個面積，函數的返回值為體積v。由主函數完成長寬高的輸入及結果輸出。由于C語言規定函數返回值只有一個，當需要增加函數的返回數據時，用外部變量是一種很好的方式。本例中，如不使用外部變量，在主函數中就不可能取得v,s1,s2,s3四個值。而采用了外部變量，在函數vs中求得的s1,s2,s3值在main 中仍然有效。因此外部變量是實現函數之間數據通訊的有效手段。對于全局變量還有以下幾點說明：

　　1. 對于局部變量的定義和說明，可以不加區分。而對于外部變量則不然，外部變量的定義和外部變量的說明并不是一回事。外部變量定義必須在所有的函數之外，且只能定義一次。其一般形式為： [extern] 類型說明符變量名，變量名… 其中方括號內的extern可以省去不寫。

　　例如： int a,b;

　　等效于：

　　extern int a,b;
　
　　而外部變量說明出現在要使用該外部變量的各個函數內，在整個程序內，可能出現多次，外部變量說明的一般形式為： extern 類型說明符變量名，變量名，…；外部變量在定義時就已分配了內存單元，外部變量定義可作初始賦值，外部變量說明不能再賦初始值，只是表明在函數內要使用某外部變量。

　　2. 外部變量可加強函數模塊之間的數據聯系，但是又使函數要依靠這些變量，因而使得函數的獨立性降低。從模塊化程序設計的觀點來看這是不利的，因此在不必要時盡量不要使用全局變量。

　　3. 在同一源文件中，答應全局變量和局部變量同名。在局部變量的作用域內，全局變量不起作用。

　　[例5.13]

int vs(int l,int w)
{
extern int h;
int v;
v=l*w*h;
return v;
}
main()
{
extern int w,h;
int l=5;
printf("v=%d",vs(l,w));
}
int l=3,w=4,h=5;
　　本例程序中，外部變量在最后定義，因此在前面函數中對要用的外部變量必須進行說明。外部變量l，w和vs函數的形參l，w同名。外部變量都作了初始賦值，mian函數中也對l作了初始化賦值。執行程序時，在printf語句中調用vs函數，實參l的值應為main中定義的l值，等于5，外部變量l在main內不起作用；實參w的值為外部變量w的值為4，進入vs后這兩個值傳送給形參l，wvs函數中使用的h 為外部變量，其值為5，因此v的計算結果為100，返回主函數后輸出。變量的存儲類型各種變量的作用域不同，就其本質來說是因變量的存儲類型相同。所謂存儲類型是指變量占用內存空間的方式，也稱為存儲方式。

　　變量的存儲方式可分為“靜態存儲”和“動態存儲”兩種。

　　靜態存儲變量通常是在變量定義時就分定存儲單元并一直保持不變，直至整個程序結束。5.5.1節中介紹的全局變量即屬于此類存儲方式。動態存儲變量是在程序執行過程中，使用它時才分配存儲單元，使用完畢立即釋放。典型的例子是函數的形式參數，在函數定義時并不給形參分配存儲單元，只是在函數被調用時，才予以分配，調用函數完畢立即釋放。假如一個函數被多次調用，則反復地分配、釋放形參變量的存儲單元。從以上分析可知，靜態存儲變量是一直存在的，而動態存儲變量則時而存在時而消失。我們又把這種由于變量存儲方式不同而產生的特性稱變量的生存期。生存期表示了變量存在的時間。生存期和作用域是從時間和空間這兩個不同的角度來描述變量的特性，這兩者既有聯系，又有區別。一個變量究竟屬于哪一種存儲方式，并不能僅從其作用域來判定，還應有明確的存儲類型說明。

　　在C語言中，對變量的存儲類型說明有以下四種：

　　auto　　　　自動變量
　　register 　　寄存器變量
　　extern 　　　外部變量
　　static 　　　靜態變量

　　自動變量和寄存器變量屬于動態存儲方式，外部變量和靜態變量屬于靜態存儲方式。在介紹了變量的存儲類型之后，可以知道對一個變量的說明不僅應說明其數據類型，還應說明其存儲類型。因此變量說明的完整形式應為：存儲類型說明符數據類型說明符變量名，變量名…；例如：

　　static int a,b; 　　　　　　　　　說明a,b為靜態類型變量
　　auto char c1,c2; 　　　　　　　　　說明c1,c2為自動字符變量
　　static int a[5]={1,2,3,4,5}; 　　　說明a為靜整型數組
　　extern int x,y; 　　　　　　　　　說明x,y為外部整型變量

　　下面分別介紹以上四種存儲類型： 一、自動變量的類型說明符為auto

　　這種存儲類型是C語言程序中使用最廣泛的一種類型。C語言規定，函數內凡未加存儲類型說明的變量均視為自動變量，也就是說自動變量可省去說明符auto。在前面各章的程序中所定義的變量凡未加存儲類型說明符的都是自動變量。例如：

{ int i,j,k;
char c;
……
}等價于： { auto int i,j,k;
auto char c;
……
}
　　自動變量具有以下特點：

　　1. 自動變量的作用域僅限于定義該變量的個體內。在函數中定義的自動變量，只在該函數內有效。在復合語句中定義的自動變量只在該復合語句中有效。例如：

int kv(int a)
{
auto int x,y;
{ auto char c;
} /*c的作用域*/
……
} /*a,x,y的作用域*/
　　2. 自動變量屬于動態存儲方式，只有在使用它，即定義該變量的函數被調用時才給它分配存儲單元，開始它的生存期。函數調用結束，釋放存儲單元，結束生存期。因此函數調用結束之后，自動變量的值不能保留。在復合語句中定義的自動變量，在退出復合語句后也不能再使用，否則將引起錯誤。例如以下程序：

main()
{ auto int a,s,p;
printf("/ninput a number:/n");
scanf("%d",&a);
if(a>0){
s=a+a;
p=a*a;
}
printf("s=%d p=%d/n",s,p);
}
{ auto int a;
printf("/ninput a number:/n");
scanf("%d",&a);
if(a>0){
auto int s,p;
s=a+a;
p=a*a;
}
printf("s=%d p=%d/n",s,p);
}
　　s,p是在復合語句內定義的自動變量，只能在該復合語句內有效。而程序的第9行卻是退出復合語句之后用printf語句輸出s,p的值，這顯然會引起錯誤。

　　3. 由于自動變量的作用域和生存期都局限于定義它的個體內( 函數或復合語句內)，因此不同的個體中答應使用同名的變量而不會混淆。即使在函數內定義的自動變量也可與該函數內部的復合語句中定義的自動變量同名。例5.14表明了這種情況。

　　[例5.14]

main()
{
auto int a,s=100,p=100;
printf("/ninput a number:/n");
scanf("%d",&a);
if(a>0)
{
auto int s,p;
s=a+a;
p=a*a;
printf("s=%d p=%d/n",s,p);
}
printf("s=%d p=%d/n",s,p);
}
　　本程序在main函數中和復合語句內兩次定義了變量s,p為自動變量。按照C語言的規定，在復合語句內，應由復合語句中定義的s,p起作用，故s的值應為a+ a，p的值為a*a。退出復合語句后的s,p 應為main所定義的s,p，其值在初始化時給定，均為100。從輸出結果可以分析出兩個s和兩個p雖變量名相同，但卻是兩個不同的變量。

　　4. 對構造類型的自動變量如數組等，不可作初始化賦值。 二、外部變量外部變量的類型說明符為extern

　　在前面介紹全局變量時已介紹過外部變量。這里再補充說明外部變量的幾個特點：

　　1. 外部變量和全局變量是對同一類變量的兩種不同角度的提法。全局變是是從它的作用域提出的，外部變量從它的存儲方式提出的，表示了它的生存期。

　　2. 當一個源程序由若干個源文件組成時，在一個源文件中定義的外部變量在其它的源文件中也有效。例如有一個源程序由源文件F1.C和F2.C組成： F1.C

int a,b; /*外部變量定義*/
char c; /*外部變量定義*/
main()
{
……
}

　　F2.C

extern int a,b; /*外部變量說明*/
extern char c; /*外部變量說明*/
func (int x,y)
{
……
}
　　在F1.C和F2.C兩個文件中都要使用a,b,c三個變量。在F1.C文件中把a,b,c都定義為外部變量。在F2.C文件中用extern把三個變量說明為外部變量，表示這些變量已在其它文件中定義，并把這些變量的類型和變量名，編譯系統不再為它們分配內存空間。對構造類型的外部變量，如數組等可以在說明時作初始化賦值，若不賦初值，則系統自動定義它們的初值為0。 三、靜態變量

　　靜態變量的類型說明符是static。靜態變量當然是屬于靜態存儲方式，但是屬于靜態存儲方式的量不一定就是靜態變量，例如外部變量雖屬于靜態存儲方式，但不一定是靜態變量，必須由 static加以定義后才能成為靜態外部變量，或稱靜態全局變量。對于自動變量，前面已經介紹它屬于動態存儲方式。但是也可以用static定義它為靜態自動變量，或稱靜態局部變量，從而成為靜態存儲方式。
由此看來，一個變量可由static進行再說明，并改變其原有的存儲方式。

　　1. 靜態局部變量

　　在局部變量的說明前再加上static說明符就構成靜態局部變量。

　　例如：

static int a,b;
static float array[5]={1,2,3,4,5}；
　
　　靜態局部變量屬于靜態存儲方式，它具有以下特點：

　　(1)靜態局部變量在函數內定義，但不象自動變量那樣，當調用時就存在，退出函數時就消失。靜態局部變量始終存在著，也就是說它的生存期為整個源程序。

　　(2)靜態局部變量的生存期雖然為整個源程序，但是其作用域仍與自動變量相同，即只能在定義該變量的函數內使用該變量。退出該函數后，盡管該變量還繼續存在，但不能使用它。

　　(3)答應對構造類靜態局部量賦初值。在數組一章中，介紹數組初始化時已作過說明。若未賦以初值，則由系統自動賦以0值。

　　(4)對基本類型的靜態局部變量若在說明時未賦以初值，則系統自動賦予0值。而對自動變量不賦初值，則其值是不定的。根據靜態局部變量的特點，可以看出它是一種生存期為整個源程序的量。雖然離開定義它的函數后不能使用，但如再次調用定義它的函數時，它又可繼續使用，而且保存了前次被調用后留下的值。因此，當多次調用一個函數且要求在調用之間保留某些變量的值時，可考慮采用靜態局部變量。雖然用全局變量也可以達到上述目的，但全局變量有時會造成意外的副作用，因此仍以采用局部靜態變量為宜。

　　[例5.15]

main()
{
int i;
void f(); /*函數說明*/
for(i=1;i<=5;i++)
f(); /*函數調用*/
}
void f() /*函數定義*/
{
auto int j=0;
++j;
printf("%d/n",j);
}
　　程序中定義了函數f，其中的變量j 說明為自動變量并賦予初始值為0。當main中多次調用f時，j均賦初值為0，故每次輸出值均為1?，F在把j改為靜態局部變量，程序如下：

main()
{
int i;
void f();
for (i=1;i<=5;i++)
f();
}
void f()
{
static int j=0;
++j;
printf("%d/n",j);
}
void f()
{
static int j=0;
++j;
printf("%d/n",j);
}
　　由于j為靜態變量，能在每次調用后保留其值并在下一次調用時繼續使用，所以輸出值成為累加的結果。讀者可自行分析其執行過程。

　　2.靜態全局變量

　　全局變量(外部變量)的說明之前再冠以static 就構成了靜態的全局變量。全局變量本身就是靜態存儲方式，靜態全局變量當然也是靜態存儲方式。這兩者在存儲方式上并無不同。這兩者的區別雖在于非靜態全局變量的作用域是整個源程序，當一個源程序由多個源文件組成時，非靜態的全局變量在各個源文件中都是有效的。而靜態全局變量則限制了其作用域，即只在定義該變量的源文件內有效，在同一源程序的其它源文件中不能使用它。由于靜態全局變量的作用域局限于一個源文件內，只能為該源文件內的函數公用，因此可以避免在其它源文件中引起錯誤。從以上分析可以看出，把局部變量改變為靜態變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變為靜態變量后是改變了它的作用域，限制了它的使用范圍。因此static 這個說明符在不同的地方所起的作用是不同的。應予以注重。

　　四、寄存器變量

　　上述各類變量都存放在存儲器內，因此當對一個變量頻繁讀寫時，必須要反復訪問內存儲器，從而花費大量的存取時間。為此，C語言提供了另一種變量，即寄存器變量。這種變量存放在CPU的寄存器中，使用時，不需要訪問內存，而直接從寄存器中讀寫，這樣可提高效率。寄存器變量的說明符是register。對于循環次數較多的循環控制變量及循環體內反復使用的變量均可定義為寄存器變量。

　　[例5.16]

求∑200i=1imain()

{
register i,s=0;
for(i=1;i<=200;i++)
s=s+i;
printf("s=%d/n",s);
}
　　本程序循環200次，i和s都將頻繁使用，因此可定義為寄存器變量。對寄存器變量還要說明以下幾點：

　　1. 只有局部自動變量和形式參數才可以定義為寄存器變量。因為寄存器變量屬于動態存儲方式。凡需要采用靜態存儲方式的量不能定義為寄存器變量。

　　2. 在Turbo C，MS C等微機上使用的C語言中，實際上是把寄存器變量當成自動變量處理的。因此速度并不能提高。而在程序中答應使用寄存器變量只是為了與標準C保持一致。3. 即使能真正使用寄存器變量的機器，由于CPU 中寄存器的個數是有限的，因此使用寄存器變量的個數也是有限的。 內部函數和外部函數

　　函數一旦定義后就可被其它函數調用。但當一個源程序由多個源文件組成時，在一個源文件中定義的函數能否被其它源文件中的函數調用呢?為此，C語言又把函數分為兩類：

　　一、內部函數

　　假如在一個源文件中定義的函數只能被本文件中的函數調用，而不能被同一源程序其它文件中的函數調用，這種函數稱為內部函
數。定義內部函數的一般形式是： static 類型說明符函數名(形參表) 例如：

　static int f(int a,int b)　
　　內部函數也稱為靜態函數。但此處靜態static 的含義已不是指存儲方式，而是指對函數的調用范圍只局限于本文件。因此在不同的源文件中定義同名的靜態函數不會引起混淆。

　　二、外部函數

　　外部函數在整個源程序中都有效，其定義的一般形式為： extern 類型說明符函數名(形參表) 例如：

　　extern int f(int a,int b)
　　如在函數定義中沒有說明extern或static則隱含為extern。在一個源文件的函數中調用其它源文件中定義的外部函數時，應用extern說明被調函數為外部函數。例如：

　　F1.C (源文件一)

main()
{
extern int f1(int i); /*外部函數說明，表示f1函
數在其它源文件中*/
……
}
F2.C (源文件二)
extern int f1(int i); /*外部函數定義*/
{
……
}

上一篇：C++指針使用方法解惑

下一篇：C++啟蒙之編寫簡單的C++程序