C語言的本質（19）——預處理之一：巨集定義

我們在寫程式碼時已多次使用過以“#”號開頭的預處理命令。如包含命令#include，巨集定義命令#define等。在源程式中這些命令都放在函式之外，而且一般都放在原始檔的前面，它們稱為預處理部分。

所謂預處理是指在進行編譯的第一遍掃描（詞法掃描和語法分析）之前所作的工作。預處理是C語言的一個重要功能，它由預處理程式負責完成。當對一個原始檔進行編譯時，系統將自動引用預處理程式對源程式中的預處理部分作處理，處理完畢自動進入對源程式的編譯。

C語言提供了多種預處理功能，如巨集定義、檔案包含、條件編譯等。合理地使用預處理功能編寫的程式便於閱讀、修改、移植和除錯，也有利於模組化程式設計。本章介紹常用的幾種預處理功能。

在C語言源程式中允許用一個識別符號來表示一個字串，稱為“巨集”。被定義為“巨集”的識別符號稱為“巨集名”。在編譯預處理時，對程式中所有出現的“巨集名”，都用巨集定義中的字串去代換，這稱為“巨集代換”或“巨集展開”。

巨集定義是由源程式中的巨集定義命令完成的。巨集代換是由預處理程式自動完成的。在C語言中，“巨集”分為有引數和無引數兩種。

 

無參巨集定義

 

無參巨集的巨集名後不帶引數。其定義的一般形式為：

   #define  識別符號  字串

其中的“#”表示這是一條預處理命令。凡是以“#”開頭的均為預處理命令。“define”為巨集定義命令。“識別符號”為所定義的巨集名。“字串”可以是常數、表示式、格式串等。

 

在前面介紹過的符號常量的定義就是一種無參巨集定義。此外，常對程式中反覆使用的表示式進行巨集定義。例如：

#define M (y*y+3*y)

它的作用是指定識別符號M來代替表示式(y*y+3*y)。在編寫源程式時，所有的(y*y+3*y)都可由M代替，而對源程式作編譯時，將先由預處理程式進行巨集代換，即用(y*y+3*y)表示式去置換所有的巨集名M，然後再進行編譯。

 

#define M (y*y+3*y)
int main(void)
{
   int s,y;
   printf("input a number: ");
   scanf("%d",&y);
   s=3*M+4*M+5*M;
   printf("s=%d\n",s);
}

上例程式中首先進行巨集定義，定義M來替代表示式(y*y+3*y)，在s=3*M+4*M+5*M中作了巨集呼叫。在預處理時經巨集展開後該語句變為：

s=3*(y*y+3*y)+4*(y*y+3*y)+5*(y*y+3*y);

但要注意的是，在巨集定義中表示式(y*y+3*y)兩邊的括號不能少。否則會發生錯誤。如當作以下定義後：

#difine M y*y+3*y

在巨集展開時將得到下述語句：

s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y;

這相當於：

   3y2+3y+4y2+3y+5y2+3y

顯然與原題意要求不符。計算結果當然是錯誤的。因此在作巨集定義時必須十分注意。應保證在巨集代換之後不發生錯誤。

 

對於巨集定義還要說明以下幾點：

1、巨集定義是用巨集名來表示一個字串，在巨集展開時又以該字串取代巨集名，這只是一種簡單的代換，字串中可以含任何字元，可以是常數，也可以是表示式，預處理程式對它不作任何檢查。如有錯誤，只能在編譯已被巨集展開後的源程式時發現。

2、 巨集定義不是說明或語句，在行末不必加分號，如加上分號則連分號也一起置換。

3、巨集定義必須寫在函式之外，其作用域為巨集定義命令起到源程式結束。如要終止其作用域可使用#undef命令。例如：

#define PI 3.14159
int main(void)
{
   /* …… */
}
#undef PI
f1(){
   /* …… */
}

表示PI只在main函式中有效，在f1中無效。

 

4、 巨集名在源程式中若用引號括起來，則預處理程式不對其作巨集代換。例如：

#define OK 100
int main(void)
{
   printf("OK");
   printf("\n");
}

上例中定義巨集名OK表示100，但在printf語句中OK被引號括起來，因此不作巨集代換。程式的執行結果為：OK這表示把“OK”當字串處理。

 

5、巨集定義允許巢狀，在巨集定義的字串中可以使用已經定義的巨集名。在巨集展開時由預處理程式層層代換。例如：

#define PI 3.1415926
#define S PI*y*y    /* PI是已定義的巨集名*/

對語句：

printf("%f",S);

在巨集代換後變為：

printf("%f",3.1415926*y*y);

 

6、習慣上巨集名用大寫字母表示，以便於與變數區別。但也允許用小寫字母。

 

7、可用巨集定義表示資料型別，使書寫方便。例如：

#define STU struct stu

在程式中可用STU作變數說明：

STU body[5],*p;
#define INTEGER int

在程式中即可用INTEGER作整型變數說明：

INTEGER a,b;

應注意用巨集定義表示資料型別和用typedef定義資料說明符的區別。巨集定義只是簡單的字串代換，是在預處理完成的，而typedef是在編譯時處理的，它不是作簡單的代換，而是對型別說明符重新命名。被命名的識別符號具有型別定義說明的功能。

 

#define PIN1 int *
typedef (int *) PIN2;

從形式上看這兩者相似，但在實際使用中卻不相同。

 

下面用PIN1，PIN2說明變數時就可以看出它們的區別：

PIN1 a,b;

在巨集代換後變成：

int *a,b;

表示a是指向整型的指標變數，而b是整型變數。然而：

PIN2 a,b;

表示a、b都是指向整型的指標變數。因為PIN2是一個型別說明符。由這個例子可見，巨集定義雖然也可表示資料型別，但畢竟是作字元代換。在使用時要分外小心，以避出錯。

 

8、對“輸出格式”作巨集定義，可以減少書寫麻煩。

 

#define P printf
#define D "%d\n"
#define F "%f\n"
int main(void)
{
   int a=5, c=8, e=11;
   float b=3.8, d=9.7, f=21.08;
   P(D F,a,b);
   P(D F,c,d);
   P(D F,e,f);
}
 

帶引數的巨集

 

C語言允許巨集帶有引數。在巨集定義中的引數稱為形式引數，在巨集呼叫中的引數稱為實際引數。對帶引數的巨集，在呼叫中，不僅要巨集展開，而且要用實參去代換形參。

 帶參巨集定義的一般形式為：

   #define  巨集名(形參表)  字串

在字串中含有各個形參。

 

帶參巨集呼叫的一般形式為：

    巨集名(實參表);

例如：

#define M(y) y*y+3*y    /*巨集定義*/
/* …… */
k=M(5);   /*巨集呼叫*/

在巨集呼叫時，用實參5去代替形參y，經預處理巨集展開後的語句為：

   k=5*5+3*5

 

#define MAX(a,b) (a>b) ? a : b
int main(void)
{
   int x,y,max;
   printf("input two numbers:   ");
   scanf("%d%d",&x,&y);
   max=MAX(x,y);
   printf("max=%d\n",max);
}

上例程式的第一行進行帶參巨集定義，用巨集名MAX表示條件表示式(a>b)?a:b，形參a、b均出現在條件表示式中。程式第6行max=MAX(x,y)為巨集呼叫，實參x、y，將代換形參a、b。巨集展開後該語句為：

max=(x>y) ? x : y;

用於計算x、y中的大數。

 

對於帶參的巨集定義有以下問題需要說明：

1、 帶參巨集定義中，形參之間可以出現空格，但是巨集名和形參表之間不能有空格出現。例如把：

#define MAX(a,b) (a>b)?a:b

寫為：

#define MAX (a,b)  (a>b)?a:b

將被認為是無參巨集定義，巨集名MAX代表字串 (a,b) (a>b)?a:b。巨集展開時，巨集呼叫語句：

max=MAX(x,y);

將變為：

max=(a,b)(a>b)?a:b(x,y);

這顯然是錯誤的。

 

2、 在帶參巨集定義中，形式引數不分配記憶體單元，因此不必作型別定義。而巨集呼叫中的實參有具體的值。要用它們去代換形參，因此必須作型別說明。這是與函式中的情況不同的。在函式中，形參和實參是兩個不同的量，各有自己的作用域，呼叫時要把實參值賦予形參，進行“值傳遞”。而在帶參巨集中，只是符號代換，不存在值傳遞的問題。

 3、 在巨集定義中的形參是識別符號，而巨集呼叫中的實參可以是表示式。

#define SQ(y) (y)*(y)
int main(void)
{
   int a,sq;
   printf("input a number:   ");
   scanf("%d",&a);
   sq=SQ(a+1);
   printf("sq=%d\n",sq);
}

上例中第1行為巨集定義，形參為y。程式第6行巨集呼叫中實參為a+1，是一個表示式，在巨集展開時，用a+1代換y，再用(y)*(y) 代換SQ，得到如下語句：

sq=(a+1)*(a+1);

這與函式的呼叫是不同的，函式呼叫時要把實參表示式的值求出來再賦予形參。而巨集代換中對實參表示式不作計算直接地照原樣代換。

 4、在巨集定義中，字串內的形參通常要用括號括起來以避免出錯。在上例中的巨集定義中(y)*(y)表示式的y都用括號括起來，因此結果是正確的。如果去掉括號，把程式改為以下形式：

 

#define SQ(y) y*y
int main(void)
{
   int a,sq;
   printf("input a number:   ");
   scanf("%d",&a);
   sq=SQ(a+1);
   printf("sq=%d\n",sq);
}

執行結果為：

   input a number:3
   sq=7

同樣輸入3，但結果卻是不一樣的。問題在哪裡呢？這是由於代換隻作符號代換而不作其它處理而造成的。巨集代換後將得到以下語句：

sq=a+1*a+1;

由於a為3故sq的值為7。這顯然與題意相違，因此引數兩邊的括號是不能少的。即使在引數兩邊加括號還是不夠的：

#define SQ(y) (y)*(y)
int main(void){
   int a,sq;
   printf("input a number:    ");
   scanf("%d",&a);
   sq=160/SQ(a+1);
   printf("sq=%d\n",sq);
}

本程式與前例相比，只把巨集呼叫語句改為：

sq=160/SQ(a+1);

執行本程式如輸入值仍為3時，希望結果為10。但實際執行的結果如下：

   input a number:3
   sq=160

為什麼會得這樣的結果呢?分析巨集呼叫語句，在巨集代換之後變為：

sq=160/(a+1)*(a+1);

a為3時，由於“/”和“*”運算子優先順序和結合性相同，則先作160/(3+1)得40，再作40*(3+1)最後得160。為了得到正確答案應在巨集定義中的整個字串外加括號，我們把程式修改一下：

#define SQ(y) ((y)*(y))
int main(void)
{
   int a,sq;
   printf("input a number:   ");
   scanf("%d",&a);
   sq=160/SQ(a+1);
   printf("sq=%d\n",sq);
}

以上討論說明，對於巨集定義不僅應在引數兩側加括號，也應在整個字串外加括號。

 

帶參的巨集和帶參函式很相似，但有本質上的不同，除上面已談到的各點外，把同一表示式用函式處理與用巨集處理兩者的結果有可能是不同的。

巨集定義也可用來定義多個語句，在巨集呼叫時，把這些語句又代換到源程式內。看下面的例子。

 

#define SSSV(s1,s2,s3,v)s1=l*w;s2=l*h;s3=w*h;v=w*l*h;
int main(void)
{
   int l=3,w=4,h=5,sa,sb,sc,vv;
   SSSV(sa,sb,sc,vv);
   printf("sa=%d\nsb=%d\nsc=%d\nvv=%d\n",sa,sb,sc,vv);
}

程式第一行為巨集定義，用巨集名SSSV表示4個賦值語句，4 個形參分別為4個賦值符左部的變數。在巨集呼叫時，把4個語句展開並用實參代替形參。使計算結果送入實參之中。