技術標籤：字串javac++c語言程式語言

1. C語言預處理概述

在前面各章中，已多次使用過以“#”號開頭的預處理命令。如包含命令#include，巨集定義命令#define等。在源程式中這些命令都放在函式之外，而且一般都放在原始檔的前面，它們稱為 預處理部分。 所謂預處理是指在進行編譯的第一遍掃描(詞法掃描和語法分析)之前所作的工作。預處理是C語言的一個重要功能，它由預處理程式負責完成。當對一個原始檔進行編譯時，系統將自動引用預處理程式對源程式中的預處理部分作處理，處理完畢自動進入對源程式的編譯。 C語言提供了多種預處理功能，如巨集定義、檔案包含、條件編譯等。合理地使用預處理功能編寫的程式便於閱讀、修改、移植和除錯，也有利於模組化程式設計。本章介紹常用的幾種預處理功能。

2.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，然後再進行編譯。 【例9-1】

      
#include <stdio.h>
#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);
    return 0;
}

上例程式中首先進行巨集定義，定義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){
    /* …… */
    return 0;
}
#undef PI
f1(){
    /* …… */
}

表示PI只在main函式中有效，在f1中無效。 4) 巨集名在源程式中若用引號括起來，則預處理程式不對其作巨集代換。如下所示【例92】：

      
#include <stdio.h>
#define OK 100
int main(void){
    printf("OK");
    printf("\n");
    return 0;
}

上例中定義巨集名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) 對“輸出格式”作巨集定義，可以減少書寫麻煩。 【例9-3】中就採用了這種方法。

      
#include <stdio.h>
#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);
    return 0;
}

3.C語言帶引數巨集定義

C語言允許巨集帶有引數。在巨集定義中的引數稱為形式引數，在巨集呼叫中的引數稱為實際引數。 對帶引數的巨集，在呼叫中，不僅要巨集展開，而且要用實參去代換形參。 帶參巨集定義的一般形式為： #define 巨集名(形參表) 字串 在字串中含有各個形參。 帶參巨集呼叫的一般形式為： 巨集名(實參表); 例如：

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

在巨集呼叫時，用實參5去代替形參y，經預處理巨集展開後的語句為： k=5*5+3*5 【例9-4】輸出兩個數中較大的數。

      
#include <stdio.h>
#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);
    return 0;
}

上例程式的第一行進行帶參巨集定義，用巨集名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) 在巨集定義中的形參是識別符號，而巨集呼叫中的實參可以是表示式。 【例9-5】輸入 n，輸出 (n+1)^2 的值。

      
#include <stdio.h>
#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);
    return 0;
}

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

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

這與函式的呼叫是不同的，函式呼叫時要把實參表示式的值求出來再賦予形參。而巨集代換中對實參表示式不作計算直接地照原樣代換。 4) 在巨集定義中，字串內的形參通常要用括號括起來以避免出錯。在上例中的巨集定義中(y)*(y)表示式的y都用括號括起來，因此結果是正確的。如果去掉括號，把程式改為以下形式(【例9.6】)：

      
#include <stdio.h>
#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);
    return 0;
}

執行結果為： input a number:3 sq=7 同樣輸入3，但結果卻是不一樣的。問題在哪裡呢？這是由於代換隻作符號代換而不作其它處理而造成的。巨集代換後將得到以下語句： sq=a+1*a+1; 由於a為3故sq的值為7。這顯然與題意相違，因此引數兩邊的括號是不能少的。即使在引數兩邊加括號還是不夠的，請看下面程式(【例9.7】)：

      
#include <stdio.h>
#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);
    return 0;
}

本程式與前例相比，只把巨集呼叫語句改為： 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。為了得到正確答案應在巨集定義中的整個字串外加括號，程式修改如下(【例9.8】)：

      
#include <stdio.h>
#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);
    return 0;
}

以上討論說明，對於巨集定義不僅應在引數兩側加括號，也應在整個字串外加括號。 帶參的巨集和帶參函式很相似，但有本質上的不同，除上面已談到的各點外，把同一表示式用函式處理與用巨集處理兩者的結果有可能是不同的。 【例9-9】用函式計算平方

      
#include <stdio.h>
int main(void){
    int i=1;
    while(i<=5)
        printf("%d^2 = %d\n", (i-1), SQ(i++));
    return 0;
}
int SQ(int y){
  return ((y)*(y));
}

執行結果： 1^2 = 1 2^2 = 4 3^2 = 9 4^2 = 16 5^2 = 25 【例9-10】用巨集計算平方

      
#include <stdio.h>
#define SQ(y) ((y)*(y))
int main(void){
    int i=1;
    while(i<=5)
        printf("%d^2 = %d\n", i, SQ(i++));
    return 0;
}

執行結果： 1^2 = 1 3^2 = 9 5^2 = 25 注意： 【例9-10】的執行結果在不同的編譯器下可能不一樣。VC6.0下輸出結果與上面相同，MinGW的輸出結果為： 3^2 = 1 5^2 = 9 7^2 = 25 這與 printf() 引數列表中表達式的計算順序和優先順序有關，這裡不深究。 在【例9-9】中函式名為SQ，形參為Y，函式體表達式為((y)*(y))。在【例9-10】中巨集名為SQ，形參也為y，字串表示式為(y)*(y))。 【例9-9】的函式呼叫為SQ(i++)，【例9-10】的巨集呼叫為SQ(i++)，實參也是相同的。從輸出結果來看，卻大不相同。 分析如下：在【例9-9】中，函式呼叫是把實參i值傳給形參y後自增1。 然後輸出函式值。因而要迴圈5次。輸出1~5的平方值。而在【例9-10】中巨集呼叫時，只作代換。SQ(i++)被代換為((i++)*(i++))。第一次迴圈，i 的值為1，(i++)*(i++)=1；第二次迴圈 i 的值為 3，(i++)*(i++)=9；第三次迴圈 i 的值為 5，(i++)*(i++)=25；第四次迴圈，i 的值為7，終止迴圈。 從以上分析可以看出函式呼叫和巨集呼叫二者在形式上相似，在本質上是完全不同的。 巨集定義也可用來定義多個語句，在巨集呼叫時，把這些語句又代換到源程式內。看下面的例子。 【例9-11】

      
#include <stdio.h>
#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);
    return 0;
}

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

4.C語言檔案包含命令

檔案包含是C預處理程式的另一個重要功能。 檔案包含命令列的一般形式為： #include "檔名" 在前面我們已多次用此命令包含過庫函式的標頭檔案。例如：

      
#include "stdio.h"
#include "math.h"

檔案包含命令的功能是把指定的檔案插入該命令列位置取代該命令列，從而把指定的檔案和當前的源程式檔案連成一個原始檔 在程式設計中，檔案包含是很有用的。一個大的程式可以分為多個模組，由多個程式設計師分別程式設計。有些公用的符號常量或巨集定義等可單獨組成一個檔案，在其它檔案的開頭用包含命令包含該檔案即可使用。這樣，可避免在每個檔案開頭都去書寫那些公用量，從而節省時間，並減少出錯。 對檔案包含命令還要說明以下幾點：

• 包含命令中的檔名可以用雙引號括起來，也可以用尖括號括起來。例如以下寫法都是允許的：

      
#include "stdio.h"
#include <math.h>

但是這兩種形式是有區別的：

• 使用尖括號表示在包含檔案目錄中去查詢(包含目錄是由使用者在設定環境時設定的)，而不在原始檔目錄去查詢；
• 使用雙引號則表示首先在當前的原始檔目錄中查詢，若未找到才到包含目錄中去查詢。使用者程式設計時可根據自己檔案所在的目錄來選擇某一種命令形式。

1. 一個include命令只能指定一個被包含檔案，若有多個檔案要包含，則需用多個include命令。
2. 檔案包含允許巢狀，即在一個被包含的檔案中又可以包含另一個檔案。

5.C語言條件編譯詳解

預處理程式提供了條件編譯的功能。可以按不同的條件去編譯不同的程式部分，因而產生不同的目的碼檔案。這對於程式的移植和除錯是很有用的。條件編譯有三種形式，下面分別介紹。

①.第一種形式

第一種形式的格式為： #ifdef 識別符號 程式段1 #else 程式段2 #endif 它的功能是，如果識別符號已被 #define命令定義過則對程式段1進行編譯；否則對程式段2進行編譯。如果沒有程式段2(它為空)，本格式中的#else可以沒有，即可以寫為： #ifdef 識別符號 程式段 #endif 【例9-12】

      
#include <stdio.h>
#define NUM ok
int main(void){
    struct stu{
        int num;
        char *name;
        char sex;
        float score;
    } *ps;
    ps=(struct stu*)malloc(sizeof(struct stu));
    ps->num=102;
    ps->name="Zhang ping";
    ps->sex='M';
    ps->score=62.5;
    #ifdef NUM
        printf("Number=%d\nScore=%f\n",ps->num,ps->score);
    #else
        printf("Name=%s\nSex=%c\n",ps->name,ps->sex);
    #endif
    free(ps);
    return 0;
}

由於在程式的第14行插入了條件編譯預處理命令，因此要根據NUM是否被定義過來決定編譯那一個printf語句。而在程式的第一行已對NUM作過巨集定義，因此應對第一個printf語句作編譯故執行結果是輸出了學號和成績。 在程式的第1行巨集定義中，定義NUM表示字串OK，其實也可以為任何字串，甚至不給出任何字串，寫為：

      
#define NUM

也具有同樣的意義。只有取消程式的第1行才會去編譯第二個printf語句。讀者可上機試作。

②.第二種形式

第二種形式的格式為： #ifndef 識別符號 程式段1 #else 程式段2 #endif 與第一種形式的區別是將“ifdef”改為“ifndef”。它的功能是，如果識別符號未被#define命令定義過則對程式段1進行編譯，否則對程式段2進行編譯。這與第一種形式的功能正相反。 第三種形式

③.第三種形式的格式為：

#if 常量表達式 程式段1 #else 程式段2 #endif 它的功能是，如常量表達式的值為真(非0)，則對程式段1 進行編譯，否則對程式段2進行編譯。因此可以使程式在不同條件下，完成不同的功能。 【例9-13】

      
#include <stdio.h>
#define R 1
int main(void){
    float c,r,s;
    printf ("input a number:  ");
    scanf("%f",&c);
    #if R
        r=3.14159*c*c;
        printf("area of round is: %f\n",r);
    #else
        s=c*c;
        printf("area of square is: %f\n",s);
    #endif
    return 0;
}

本例中採用了第三種形式的條件編譯。在程式第1行巨集定義中，定義R為1，因此在條件編譯時，常量表達式的值為真，故計算並輸出圓面積。 上面介紹的條件編譯當然也可以用條件語句來實現。 但是用條件語句將會對整個源程式進行編譯，生成的目的碼程式很長，而採用條件編譯，則根據條件只編譯其中的程式段1或程式段2，生成的目標程式較短。如果條件選擇的程式段很長，採用條件編譯的方法是十分必要的。

6.C語言預處理指令總結

預處理指令是以#號開頭的程式碼行。#號必須是該行除了任何空白字元外的第一個字元。#後是指令關鍵字，在關鍵字和#號之間允許存在任意個數的空白字元。整行語句構成了一條預處理指令，該指令將 在編譯器進行編譯之前對原始碼做某些轉換。 下面是本章涉及到的部分預處理指令：

指令	說明
#	空指令，無任何效果
#include	包含一個原始碼檔案
#define	定義巨集
#undef	取消已定義的巨集
#if	如果給定條件為真，則編譯下面程式碼
#ifdef	如果巨集已經定義，則編譯下面程式碼
#ifndef	如果巨集沒有定義，則編譯下面程式碼
#elif	如果前面的#if給定條件不為真，當前條件為真，則編譯下面程式碼
#endif	結束一個#if……#else條件編譯塊

預處理功能是C語言特有的功能，它是在對源程式正式編譯前由預處理程式完成的。程式設計師在程式中用預處理命令來呼叫這些功能。 巨集定義可以帶有引數，巨集呼叫時是以實參代換形參。而不是“值傳送”。 為了避免巨集代換時發生錯誤，巨集定義中的字串應加括號，字串中出現的形式引數兩邊也應加括號。 檔案包含是預處理的一個重要功能，它可用來把多個原始檔連線成一個原始檔進行編譯，結果將生成一個目標檔案。 條件編譯允許只編譯源程式中滿足條件的程式段，使生成的目標程式較短，從而減少了記憶體的開銷並提高了程式的效率。 使用預處理功能便於程式的修改、閱讀、移植和除錯，也便於實現模組化程式設計。 來自為知筆記(Wiz)