預編譯處理命令行後不加分號
⑴ 在c語言中什麼語句後要加分號,什麼語句後不用分號
分號代表語句結束假設你有一個數組int
a[5];那麼你可以這樣給數組賦值for(int
i
=
0;i<5;i++)
a[i]=i;這個是沒加分號的，那麼a[0]=0,a[1]=1....a[4]=4;for(int
i
=
0;i<5;i++);這樣加了分號，就代表結束了，相當於循環只執行了i，然後就退出循環了
a[i]=i;//這樣相當於只有a[4]=4;
c語言中，分號代表語句結束
⑵ 電氣三班c語言選擇題
下面說法不正確的是（）。
調用函數時，實參可以是表達式
調用函數時，實參和形參可以共用內存單元
調用函數時，將實參的值復制給形參，使實參變數和形參變數在數值上相等
調用函數時，實參與形參的類型必須一致
~B
~~~6
下面函數調用語句含有實參的個數為（）。
func((exp1,exp2),(exp3,exp4,exp5));
1
2
3
5
~B
~~~6
在C語言中，函數調用時（）。
實參和形參各占獨立的存儲單元
實參和形參共用存儲單元
由系統自動確定實參和形參是否共用存儲單元
由用戶指定實參和形參是否共用存儲單元
~A
~~~6
C語言規定，程序中各函數之間（）。
既允許直接遞歸調用也允許間接遞歸調用
既不允許直接遞歸調用也不允許間接遞歸調用
允許直接遞歸調用不允許間接遞歸調用
不允許直接遞歸調用允許間接遞歸調用
~A
~~~8
下列能正確定義一維數組的選項是（）。
int a[5]={0,1,2,3,4,5};
char a[]={0,1,2,3,4,5};
char a={'A','B','C'};
int a[5]="0123";
~B
~~~8
下列敘述中錯誤的是（）。
對於double類型數組，不可以直接用數組名對數組進行整體輸入或輸出
數組名代表的是數組所佔存儲區的首地址，其值不可改變
在程序執行中，數組元素的下標超出所定義的下標范圍時，系統將給出「下標越界」的出錯信息
可以通過賦初值的方式確定數組元素的個數
~C
~~~8
有下列程序：
#include <string.h>
main()
{ char p[]={'a','b','c'},q[10]={'a','b','c'};
printf("%d%d\n",strlen(p),strlen(q));
}
下列敘述中正確的是（）。
在給p和q數組賦初值時，系統會自動添加字元串結束符，故輸出的長度都為3
由於p數組中沒有字元串結束符，長度不能確定，但q數組中字元串長度為3
由於q數組中沒有字元串結束符，長度不能確定，但p數組中字元串長度為3
由於p和q數組中都沒有字元串結束符，故長度都不能確定
~A
~~~8
若要求從鍵盤讀入含有空格字元的字元串，應使用函數（）。
getc()
gets()
getchar()
scanf()
~B
~~~8
當用戶要求輸入的字元串中含有空格時，應使用的輸入函數是（）。
scanf()
getchar()
gets()
getc()
~C
~~~8
當有定義語句：char s[10];,若要從終端給s輸入5個字元，錯誤的輸入語句是（）。
gets(&s[0]);
scanf("%s",s+1);
gets(s);
scanf("%s",s[1]);
~D
~~~8
當以下敘述中錯誤的是（）。
gets函數用於從終端讀入字元串
getchar函數用於從磁碟文件讀入字元
fputs函數用於把字元串輸出到文件
fwrite函數用於以二進制形式輸出數據到文件
~B
下列關於字元串的敘述中正確的是（）。
C語言中有字元串類型的常量和變數
兩個字元串中的字元個數相同時才能進行字元串大小的比較
可以用關系運算符對字元串的大小進行比較
空串一定比空格打頭的字元串小
~D
~~~8
下面能正確進行字元串賦值的是（）。
char s[5]={"ABCDE"};
char s[5]={'A','B','C','D','E'};
char*s; s="ABCDE";
char*s;printf("%s",s);
~C
~~~8
字元串"\\\"ABCDEF\"\\"的長度是（）。
15
10
7
8
~B
~~~8
下面各語句行中，能正確進行賦值字元串操作的是（）。
char s[5]={'a','b','c','d','e'};
char *s;gets(s);
char *s;*s="ABCDEF";
char s[5];scanf("%s",&s);
~B
~~~8
設已執行預編譯命令#include<string.h>,以下程序段的輸出結果是（）。
char s[]="abcdefg";
printf("%d\n",strlen(s));
7
8
9
10
~A
~~~8
若已包括頭文件<string.h>且已有定義char s1[18],s2={"ABCDE"}和int i，現要將字元串"ABCDE"賦給s1,下述語句錯誤的是（）。
strcpy(s1,s2);
strcpy(s1,"ABCDE");
s1="ABCDE";
for(i=0;i<6;i++)
s1[i]=s2[i];
~C
###
~~~7
*以下程序的輸出結果是[<4>]。
*#include<stdio.h>
*main()
*{
* int a[5]={2,4,6,8,10},*p;
* p=a;p++;
* printf("%d",*p);
*}
~~~7
*以下程序的輸出結果是[<3 5>]。
*#include<stdio.h>
*void swap(int *a,int *b)
*{
* int *t ;
* t=a;a=b;b=t;
*}
*main()
*{
* int i=3,j=5,*p=&i,*q=&j;
* swap(p,q);printf("%d %d",*p,*q);
*}
~~~7
*下面程序段的運行結果是[<68>]。
*char str[]="ABCD",*p=str;
*printf("%d\n",*(p+3));
###
~~~7
設已有定義：float x;，則下列對指針變數p進行定義且賦初值的語句中正確的是( )。
float *p=1024;
int *p=(float)x;
float p=&x;
float *p=&x;
~D
~~~7
設有定義語句int (*f)(int);，則以下敘述正確的是( )。
f是基類型為int的指針變數
f是指向函數的指針變數，該函數具有一個int類型的形態
f是指向int類型一維數組的指針變數
f是函數名，該函數的返回值是其類型為int類型的地址
~B
~~~7
設有定義：int n1=0,n2,*p=&n2,*q=&n1;，以下賦值語句中與n2=n1;語句等價的是( )。
*p=*q
p=q
*p=&n1;
p=*q
~A
~~~7
在16位編譯系統上，若有定義int a[]={10,20,30},*p=&a;，當執行p++;後，下列說法錯誤的是( )。
p向高地址移了一個位元組
p向高地址移了一個存儲單元
p向高地址移了兩個位元組
p與n+1等價
~A
~~~7
若有定義語句：int k[2][3],*pk[3];，則下列語句中正確的是( )。
pk=k;
pk[0]=&k[1][2];
pk=k[0];
pk[1]=k;
~B
~~~7
若有定義：char(*p)[6];則標識符p( )。
是一個指向字元型變數的指針
是一個指針數組名
是一個指針變數，它指向一個含有6個字元型元素的一維數組
定義不合法
~C
~~~7
下面程序段的運行結果是( )。
#include<stdio.h>
void main()
{ char str[]="abc",*p=str;
printf("%d\n",*(p+3));
}
67
0
字元'C'的地址
字元'C'
~B
~~~7
若有以下定義，則對a數組元素的正確引用是( )。
int a[5],*p=a;
*&a[5]
*a+1
*(p+5)
*(a+2)
~D
###
~~~3
C語言中用[<非0>]表示邏輯"真"，用[<0>]表示邏輯值"假"。
~~~3
C語言中邏輯運算符[<!>]的優先順序高於算術運算符。
~~~3
當a=1，b=2，c=3時，以下if語句執行後，a、b、c中的值分別為[<3>]、[<2>]、[<2>]。
if(a>c)
b=a;a=c;c=b;
~~~3
以下程序段的輸出結果是[<死循環>]
int k,n,m;
n=10;m=1;k=1;
while(k<=n) m*=2;
printf("%d\n",m);
~~~3
以下程序的輸出結果是[<-1>]
main()
{
int x=2;
while(x--);
printf("%d\n",x);
}
~~~3
以下程序段：
s=1.0;
for(k=1;k<=n;k++)
s=s+1.0/(k*(k+1))
printf("%f\n",s);
請填空，使下面的程序段的功能完全與之等同。
s=0.0
[<d=1.0>]
k=0;
do
{
s=s+d;
[<k++>]
d=1.0/(k*(k+1));
}
while[<k<=n>]
printf("%f\n",s);
~~~3
以下程序功能是：從鍵盤上輸入若干個學生的成績，統計並輸出最高成績和最低成績，當輸入負數時結束輸入。請填空。
main()
{
float x,amax,amin;
scanf("%f",&x);
amax=x;
amin=x;
while[<x>=0>]
{
if(x>amax) amax=x;
if[<x<amin>] amin=x;
scanf("%f",&x);
}
printf("\namax=%f\namin=%f\n",amax,amin);
}
~~~5
若有定義int a[3][5];則排列在數組中的第九個元素是[<a[1][3]>]
~~~5
strlen("How are you\n")的值是[<12>]
~~~5
C語言中字元串結束的標志是[<'\0'>]
~~~5
寫出一個名為s的單精度實型一維數組，長度是6，所有元素初值均為0，其數組定義語句是[<float s[6]={0};>]
~~~5
strcmp("how","How")的值是[<32或者>0>]
~~~6
C語言程序執行的開始處是[<main函數>]
~~~6
C程序中的一個函數由兩部分組成，即[<聲明部分>]和[<執行部分>]
~~~6
為了保證被調用函數不返回任何值，其函數定義的類型應為[<void>]
~~~6
下面pi函數的功能是，根據以下公式返回滿足精度ε要求的∏的值。請填空。∏/2=1+1/3+(1/3)*(2/5)+(1/3)*(2/5)*（3/7)+(1/3)*(2/5)*（3/7)*(4/9)+...
double pi(double eps)
{double s=0.0,t=1.0;
int n;
for([<n=1>];t>eps;n++)
{
s+=t;
t=n*t/(2*n+1);
}
return (2.0*[<s>]);
}
~~~6
以下函數用以求x的y次方。請填空。
double fun(double x,int y)
{
int i;double z;
for(i=1;i[<<=y>];i++)
z=[<Z*x>];
return z;
}
~~~6
以下程序的功能是計算s=0!+1!+2!+3!+...+n!。請填空。
long f(int n)
{ int i; long s;
s=[<1L>];
for(i=1;i<=n;i++) s=[<S*i>];
return s;
}
main()
{
long s;int k,n;
scanf("%d",&n);
s=[<0>];
for(k=0;k<=n;k++) s=s+[<f(k)>];
printf("%ld\n",s);
}
###
~~~3
下列運算符中優先順序最高的運算符是()。
!
%
-=
&&
~A
~~~3
下列運算符中優先順序最低的運算符是()。
||
!=
<=
+
~A
~~~3
為表示關系x≥y≥z,應使用的C語言表達式是()。
(x>=y)&&(y>=z)
(x>=y)AND(y>=z)
(x>=y>=z)
(x>=y)&(y>=z)
~A
~~~3
設a、b和c都是int型變數，且a=3，b=4，c=5；則以下的表達式中，值為0的表達式是()。
a&&b
a<=b
a||b+c&&b-c
!(a<b)&&!c||1
~D
~~~5
若有int s[4]={1,2,3,4};則s[s[0]+2*s[2]-s[3]]的值是()。
1
2
3
4
~D
~~~5
對數組的描述正確的是()。
數組一旦定義去大小是固定的，但數組元素的類型可以不同
數組一旦定義去大小是固定的，但數組元素的類型必須相同
數組一旦定義去大小是可變的，但數組元素的類型可以不同
數組一旦定義去大小是可變的，但數組元素的類型必須相同
~B
~~~5
對字元串"Boy"進行完整賦值的操作是()
char s[3]={'B','o','y'}
char s[]="Boy"
char s[3]={"Boy"}
char s[3];s="Boy"
~B
~~~5
在c語言中引用數組元素時，其數組下標的數組類型允許是()
整型常量
整型表達式
整型常量或整型表達式
任何類型的表達式
~C
~~~5
對以下說明語句的正確理解是()
*int a[10]={6,7,8,9,10}
將5個初值依次賦給a[1]至a[5]
將5個初值依次賦給a[0]至a[4]
將5個初值依次賦給a[6]至a[10]
因為數組長度與初值的個數不相同，所以此語句不正確
~B
~~~5
以下程序段給數組所有元素輸入數據，應在下劃線處填入的是()
*main()
*{
*int a[10],i=0;
*while(i<10) scanf("%d",_______);
*:
*:
*}
a+(i++)
&a(i+1)
a+i
&a[++i]
~D
~~~5
以下程序的輸出結果是()
*main()
*{
* int a[]={2,4,6,8},y=1,x,*p;
*p=&a[1];
*for(x=0;x<3;x++) y+=*(p+x);
*printf("%d\n",y);
*}
17
18
19
20
~C
~~~6
下述函數定義形式正確的是()
int f(int x;int y)
int f(int x, y)
int f(int x,int y)
int f(x,y:y)
~C
~~~6
關於函數參數，說法正確的是()
實參與其對應的形參各自佔用獨立的內存單元
實參與其對應的形參共同佔用一個內存單元
只有當實參和形參同名時才佔用同一個內存單元
形參是虛擬的，不佔用內存單元
~A
~~~6
用數組名作為函數的實參時，傳遞給形參的是()
數組的首地址
數組的第一個元素
數組中的全部元素
數組的元素個數
~A
~~~6
復合語句中定義的變數的作用范圍是()
整個源文件
整個函數
整個程序
所定義的復合語句
~D
~~~6
一個函數的返回值由()確定
return語句中的表達式
調用函數的類型
系統默認的類型
被調用函數的類型
~D
~~~6
以下說法正確的是()
C語言程序總是從第一個定義的函數開始執行
在C語言程序設計中，要調用的函數必須在main函數中定義
C語言程序總是從main函數開始執行
C語言程序中的main函數必須放在程序的開始部分
~C
~~~6
以下函數的類型是()
*fff(float x)
*{
*printf("",x*x);
*}
與參數x的類型相同
void類型
int類型
無法確定
~C
~~~6
以下程序的輸出結果是()
*fun(int a,int b)
*{int c;
*c=a+b;
*retutn c;
*}
*main()
*{int x=6,y=7,z=8,r;
*r=func((x--,y++,x+y),z--);
*printf("%d\n",r);
*}
11
20
21
31
~C
~~~10
當說明一個結構體變數時，系統分配給它的內存是()
各成員所需內存總量的總和
結構中第一個成員所需內存量
成員中占內存量最大者所需的容量
結構中最後一個成員所需內存量
~A
~~~10
設有以下說明語句：
*struct stu
*{int a;
* float b;
*}stutype;
*則下面敘述不正確的是()
strut是結構體類型的關鍵字
strut stu是用戶定義的結構體類型
stutype是用戶定義的結構體類型名
a和b都是結構體成員名
~C
~~~10
C語言結構體類型變數在執行期間()
所有成員一直駐留在內存中
只有一個成員駐留在內存中
部分成員駐留在內存中
沒有成員駐留在內存中
~A
~~~11
若想對文本文件只進行讀操作，打開此文件的方式為()
"r"
"W"
"a"
"r+"
~A
~~~11
如果要打開C盤file文件夾下的abc.dat文件，fopen函數中第一個參數應為()
c:file\abc.dat
c:\file\abc.dat
"c:\file\abc.dat"
"c:\\file\\abc.dat"
~D
~~~11
用fopen函數打開文件，操作完畢後用()函數關閉它
fopen
open
fclose
close
~C
~~~11
以下可作為函數fopen中第一個參數的正確格式是()
c:user\test.txt
c:\user\test.txt
"c:\user\test.txt"
"c:\\user\\test.txt"
~D
~~~11
若執行fopen函數時發生錯誤，則函數的返回值是()
地址值
0
1
EOF
~B
~~~11
若要用fopen函數打開一個新的二進制文件，該文件要既能讀也能寫，則文件方式字元串應是()
"ab++"
"wb+"
"rb+"
"ab"
~B
若以"a+"方式打開一個已存在的文件，則以下敘述正確的是()
文件打開時，原有文件內容不被刪除，位置指針移到文件末尾，可作添加和讀操作
文件打開時，原有文件內容不被刪除，位置指針移到文件開頭，可作重寫和讀操作
文件打開時，原有文件內容不被刪除，只可作寫操作
以上各種說法皆不正確
~A
###
~~~9
下列程序的功能時：給r輸入數據後計算半徑為r的圓面積s。程序在編譯時出錯。
main()
{ int r; float s;
scanf("%d",&r);
s=pi*r*r;
printf("s=%f\n",s);
}
出錯的原因是（）。
注釋語句書寫位置錯誤
存放圓半徑的變數r不應該定義為整型
輸出語句中格式描述符號非法
計算圓面積的賦值語句中使用了非法變數
~D
~~~9
以下敘述錯誤的是（）。
在程序中凡是以「#」開始的語句行都是預處理命令行
預處理命令行的最後不能以分號表示結束
#define MAX是合法的宏定義命令行
C程序對預處理命令行的處理是在程序執行的過程中進行的
~C
~~~9
下列敘述中正確的是（）。
預處理命令行必須位於源文件的開頭
在源文件的一行上可以有多條預處理命令
宏名必須用大寫字母表示
宏替換不佔用程序的運行空間
~D
~~~9
若程序中有宏定義行：#define N 100，則下列敘述中正確的是（）。
宏定義中定義了標識符N的值為整數100
在編譯程序對C源程序進行預處理時用100替換標識符N
對C源程序進行編譯時用100替換標識符N
在運行時用100替換標識符N
~B
~~~9
程序
#include <stdio.h>
#define M 5
#define N M+M
main()
{ int k;
k=N*N*5;
printf("%d\n",k);
}
的輸出結果是（）。
100
50
55
45
~C
~~~9
下列敘述中正確的是（）。
預處理命令行必須位於C源程序的起始位置
在C語言中，預處理命令行都以#開頭
每個C程序必須在開頭包含預處理命令行：#include<stdio.h>
C語言的預處理不能實現宏定義和條件編譯的功能
~B
~~~9
C語言的編譯系統對宏命令的處理是（）。
在系統對源程序進行編譯前
和其他語句的編譯同時進行
在程序連接時進行
在程序運行時進行
~A
~~~9
以下敘述中不正確的是（）。
預處理命令行都必須以「#」號開始，結尾不加分號
在程序中凡是以「#」開始的語句行都是預處理命令行
C程序在執行過程中對預處理命令進行處理
預處理命令可以放在程序的任何位置
~C
~~~9
下面敘述中正確的是（）。
C語言中預處理是指完成宏替換和文件包含指定的文件的調用
預處理命令只能位於C源程序文件的首部
預處理命令可以放在程序中的任何位置
預處理命令結尾需要加分號
~C
~~~9
以下有關宏替換的敘述不正確的是（）。
使用宏定義可以嵌套
宏定義僅僅是符號替換
雙引號中出現的宏名不替換
宏名必須用大寫字母表示
~D
⑶ 預處理程序的代碼
宏定義是由源程序中的宏定義命令完成的。 宏代換是由預處理程序自動完成的。在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)
main(){
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；這相當於； 3y�2+3y+4y�2+3y+5y�2+3y；顯然與原題意要求不符。計算結果當然是錯誤的。 因此在作宏定義時必須十分注意。應保證在宏代換之後不發生錯誤。對於宏定義還要說明以下幾點：
1. 宏定義是用宏名來表示一個字元串，在宏展開時又以該字元串取代宏名，這只是一種簡單的代換，字元串中可以含任何字元，可以是常數，也可以是表達式，預處理程序對它不作任何檢查。如有錯誤，只能在編譯已被宏展開後的源程序時發現。
2. 宏定義不是說明或語句，在行末不必加分號，如加上分號則連分號也一起置換。
3. 宏定義必須寫在函數之外，其作用域為宏定義命令起到源程序結 束。如要終止其作用域可使用# undef命令，例如： # define PI 3.14159
main()
{
……
}
# undef PIPI的作用域
f1()
....表示PI只在main函數中有效，在f1中無效。
4. 宏名在源程序中若用引號括起來，則預處理程序不對其作宏代換。
#define OK 100
main()
{
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. 對「輸出格式」作宏定義，可以減少書寫麻煩。例9.3 中就採用了這種方法。
#define P printf
#define D "%d\n"
#define F "%f\n"
main(){
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
main(){
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均出現在條件表達式中。程序第七行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)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}
上例中第一行為宏定義，形參為y。程序第七行宏調用中實參為a+1，是一個表達式，在宏展開時，用a+1代換y，再用(y)*(y) 代換SQ，得到如下語句： sq=(a+1)*(a+1); 這與函數的調用是不同的， 函數調用時要把實參表達式的值求出來再賦予形參。 而宏代換中對實參表達式不作計算直接地照原樣代換。
4. 在宏定義中，字元串內的形參通常要用括弧括起來以避免出錯。 在上例中的宏定義中(y)*(y)表達式的y都用括弧括起來，因此結果是正確的。如果去掉括弧，把程序改為以下形式：
#define SQ(y) y*y
main(){
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)
main(){
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))
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
}
以上討論說明，對於宏定義不僅應在參數兩側加括弧， 也應在整個字元串外加括弧。
5. 帶參的宏和帶參函數很相似，但有本質上的不同，除上面已談到的各點外，把同一表達式用函數處理與用宏處理兩者的結果有可能是不同的。main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
SQ(int y)
{
return((y)*(y));
}#define SQ(y) ((y)*(y))
main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
在上例中函數名為SQ，形參為Y，函數體表達式為((y)*(y))。在例9.6中宏名為SQ，形參也為y，字元串表達式為(y)*(y))。 兩例是相同的。例9.6的函數調用為SQ(i++)，例9.7的宏調用為SQ(i++)，實參也是相同的。從輸出結果來看，卻大不相同。分析如下：在例9.6中，函數調用是把實參i值傳給形參y後自增1。 然後輸出函數值。因而要循環5次。輸出1～5的平方值。而在例9.7中宏調用時，只作代換。SQ(i++)被代換為((i++)*(i++))。在第一次循環時，由於i等於1，其計算過程為：表達式中前一個i初值為1，然後i自增1變為2，因此表達式中第2個i初值為2，兩相乘的結果也為2，然後i值再自增1，得3。在第二次循環時，i值已有初值為3，因此表達式中前一個i為3，後一個i為4， 乘積為12，然後i再自增1變為5。進入第三次循環，由於i 值已為5，所以這將是最後一次循環。計算表達式的值為5*6等於30。i值再自增1變為6，不再滿足循環條件，停止循環。從以上分析可以看出函數調用和宏調用二者在形式上相似， 在本質上是完全不同的。
6. 宏定義也可用來定義多個語句，在宏調用時，把這些語句又代換到源程序內。看下面的例子。
#define SSSV(s1,s2,s3,v) s1=l*w;s2=l*h;s3=w*h;v=w*l*h;
main(){
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 個語句展開並用實參代替形參。使計算結果送入實參之中。
文件包含
文件包含是C預處理程序的另一個重要功能。文件包含命令行的一般形式為： #include"文件名" 在前面我們已多次用此命令包含過庫函數的頭文件。例如：
#include"stdio.h"
#include"math.h"
文件包含命令的功能是把指定的文件插入該命令行位置取代該命令行， 從而把指定的文件和當前的源程序文件連成一個源文件。在程序設計中，文件包含是很有用的。 一個大的程序可以分為多個模塊，由多個程序員分別編程。 有些公用的符號常量或宏定義等可單獨組成一個文件， 在其它文件的開頭用包含命令包含該文件即可使用。這樣，可避免在每個文件開頭都去書寫那些公用量， 從而節省時間，並減少出錯。
對文件包含命令還要說明以下幾點：
1. 包含命令中的文件名可以用雙引號括起來，也可以用尖括弧括起來。例如以下寫法都是允許的： #include"stdio.h" #include<math.h> 但是這兩種形式是有區別的：使用尖括弧表示在包含文件目錄中去查找(包含目錄是由用戶在設置環境時設置的)， 而不在源文件目錄去查找； 使用雙引號則表示首先在當前的源文件目錄中查找，若未找到才到包含目錄中去查找。 用戶編程時可根據自己文件所在的目錄來選擇某一種命令形式。
2. 一個include命令只能指定一個被包含文件， 若有多個文件要包含，則需用多個include命令。3. 文件包含允許嵌套，即在一個被包含的文件中又可以包含另一個文件。
條件編譯
預處理程序提供了條件編譯的功能。 可以按不同的條件去編譯不同的程序部分，因而產生不同的目標代碼文件。 這對於程序的移植和調試是很有用的。 條件編譯有三種形式，下面分別介紹：
1. 第一種形式：
#ifdef 標識符
程序段1
#else
程序段2
#endif
它的功能是，如果標識符已被 #define命令定義過則對程序段1進行編譯；否則對程序段2進行編譯。如果沒有程序段2(它為空)，本格式中的#else可以沒有， 即可以寫為：
#ifdef 標識符
程序段 #endif
#define NUM ok
main(){
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);
}
由於在程序的第16行插入了條件編譯預處理命令， 因此要根據NUM是否被定義過來決定編譯那一個printf語句。而在程序的第一行已對NUM作過宏定義，因此應對第一個printf語句作編譯故運行結果是輸出了學號和成績。在程序的第一行宏定義中，定義NUM表示字元串OK，其實也可以為任何字元串，甚至不給出任何字元串，寫為： #define NUM 也具有同樣的意義。 只有取消程序的第一行才會去編譯第二個printf語句。讀者可上機試作。
2. 第二種形式：
#ifndef 標識符
程序段1
#else
程序段2
#endif
與第一種形式的區別是將「ifdef」改為「ifndef」。它的功能是，如果標識符未被#define命令定義過則對程序段1進行編譯， 否則對程序段2進行編譯。這與第一種形式的功能正相反。
3. 第三種形式：
#if 常量表達式
程序段1
#else
程序段2
#endif
它的功能是，如常量表達式的值為真(非0)，則對程序段1 進行編譯，否則對程序段2進行編譯。因此可以使程序在不同條件下，完成不同的功能
#define R 1
main(){
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
}
本例中採用了第三種形式的條件編譯。在程序第一行宏定義中，定義R為1，因此在條件編譯時，常量表達式的值為真， 故計算並輸出圓面積。上面介紹的條件編譯當然也可以用條件語句來實現。 但是用條件語句將會對整個源程序進行編譯，生成的目標代碼程序很長，而採用條件編譯，則根據條件只編譯其中的程序段1或程序段2， 生成的目標程序較短。如果條件選擇的程序段很長， 採用條件編譯的方法是十分必要的。
本章小結
1. 預處理功能是C語言特有的功能，它是在對源程序正式編譯前由預處理程序完成的。程序員在程序中用預處理命令來調用這些功能。
2. 宏定義是用一個標識符來表示一個字元串，這個字元串可以是常量、變數或表達式。在宏調用中將用該字元串代換宏名。
3. 宏定義可以帶有參數，宏調用時是以實參代換形參。而不是「值傳送」。
4. 為了避免宏代換時發生錯誤，宏定義中的字元串應加括弧，字元串中出現的形式參數兩邊也應加括弧。
5. 文件包含是預處理的一個重要功能，它可用來把多個源文件連接成一個源文件進行編譯，結果將生成一個目標文件。
6. 條件編譯允許只編譯源程序中滿足條件的程序段，使生成的目標程序較短，從而減少了內存的開銷並提高了程序的效率。
7. 使用預處理功能便於程序的修改、閱讀、移植和調試，也便於實現模塊化程序設計
⑷ c語言中預處理命令都有哪些
我們可以在C源程序中插入傳給編譯程序的各中指令，這些指令被稱為預處理器指令，它們擴充了程序設計的環境。現把常用的預處理命令總結如下：
1. 預處理程序
按照ANSI標準的定義，預處理程序應該處理以下指令：
#if #ifdef #ifndef #else #elif
#endif
#define
#undef
#line
#error
#pragma
#include
顯然，上述所有的12個預處理指令都以符號#開始，，每條預處理指令必須獨佔一行。
2. #define
#define指令定義一個標識符和一個串（也就是字元集），在源程序中發現該標識符時，都用該串替換之。這種標識符稱為宏名字，相應的替換稱為宏代換。一般形式如下：
#define macro-name char-sequence
這種語句不用分號結尾。宏名字和串之間可以有多個空白符，但串開始後只能以新行終止。
例如：我們使用LEFT代表1，用RIGHT代表0，我們使用兩個#define指令：
#define LEFT 1
#define RIGHT 0
每當在源程序中遇到LEFT或RIGHT時，編譯程序都用1或0替換。
定義一個宏名字之後，可以在其他宏定義中使用,例如：
#define ONE 1
#define TWO ONE+ONE
#define THREE ONE+TWO
宏代換就是用相關的串替代標識符。因此，如果希望定義一條標准錯誤信息時，可以如下定義：
#define ERROR_MS 「Standard error on input \n」
如果一個串長於一行，可在行尾用反斜線」\」續行，如下：
#define LONG_STRING 「This is a very very long \
String that is used as an example」
3. #error
#error指令強制編譯程序停止編譯，它主要用於程序調試。#error指令的一般形式是：
#error error-message
注意，宏串error-message不用雙引號包圍。遇到#error指令時，錯誤信息被顯示，可能同時還顯示編譯程序作者預先定義的其他內容。
4. #include
程序中的#include指令要求編譯程序讀入另一個源文件。被讀入文件的名字必須用雙引號(「」)或一對尖括弧(<>)包圍，例如：
#include 「stdio.h」
#include <stdio.h>
都使C編譯程序讀入並編譯頭文件以用於I/O系統庫函數。
包含文件中可以包含其他#include指令，稱為嵌套包含。允許的最大嵌套深度隨編譯器而變。
文件名被雙括弧或尖括弧包圍決定了對指定文件的搜索方式。文件名被尖括弧包圍時，搜索按編譯程序作者的定義進行，一般用於搜索某些專門放置包含文件的特殊目錄。當文件名被雙括弧包圍時，搜索按編譯程序實時的規定進行，一般搜索當前目錄。如未發現，再按尖括弧包圍時的辦法重新搜索一次。
通常，絕大多數程序員使用尖括弧包圍標準的頭文件，雙引號用於包圍與當前程序相關的文件名。
5. 條件編譯指令
若干編譯指令允許程序員有選擇的編譯程序源代碼的不同部分，這種過程稱為條件編譯。
5.1#if、#else、#elif #endif
條件編譯指令中最常用的或許是#if,#else,#elif和#endif。這些指令允許程序員根據常數表達式的結果有條件的包圍部分代碼。
#if的一般形式是：
#if constant-expression
Statement sequence
#endif
如#if後的常數表達式為真，則#if和#endif中間的代碼被編譯，否則忽略該代碼段。#endif標記#if塊的結束。
#else指令的作用與C語言的else相似，#if指令失敗時它可以作為備選指令。例如：
#include <stdio.h>
#define MAX 100
Int main(void)
{
#if MAX>99
printf(「Compiled for array greater than 99.\n」);
#else
printf(「Complied for small array.\n」);
#endif
return 0;
}
注意，#else既是標記#if塊的結束，也標記#else塊的開始。因為每個#if只能寫一個#endif匹配。
#elif指令的意思是「否則，如果」，為多重編譯選擇建立一條if-else-if（如果-否則-如果鏈）。如果#if表達式為真，該代碼塊被編譯，不測試其他#elif表達式。否則，序列中的下一塊被測試，如果成功則編譯之。一般形式如下：
#if expression
Statement sequence
#elif expression1
Statement sequence
#elif expression2
Statement sequence
.
.
.
#elif expression
Statement sequence
#endif
5.2#ifdef和#ifndef
條件編譯的另一個方法是使用編譯指令#ifdef和#ifndef，分別表示「如果已定義」和「如果未定義」。#ifdef的一般形式如下：
#ifdef macro-name
Statement sequence
#endif
如果macro-name原先已經被一個#define語句定義，則編譯其中的代碼塊。
#ifndef的一般形式是：
#ifndef macro-name
Statement sequence
#endif
如果macro-name當前未被#define語句定義，則編譯其中的代碼塊。
我認為，用這種，可以很方便的開啟/關閉整個程序的某項特定功能。
#ifdef和#ifndef都可以使用#else或#elif語句。
#inlucde <stdio.h>
#define T 10
Int main(void)
{
#ifdef t
Printf(「Hi T\n」);
#else
Printf(「Hi anyone\n」);
#endif
#ifndef M
Printf(「M Not Defined\n」);
#endif
Return 0;
}
6. #undef
#undef指令刪除前面定義的宏名字。也就是說，它「不定義」宏。一般形式為：
#undef macro-name
7. 使用defined
除#ifdef之外，還有另外一種確定是否定義宏名字的方法，即可以將#if指令與defined編譯時操作符一起使用。defined操作符的一般形式如下：
defined macro-name
如果macro-name是當前定義的，則表達式為真，否則為假。
例如，確定宏MY是否定義，可以使用下列兩種預處理命令之一：
#if defined MY
或
#ifdef MY
也可以在defined之前加上感嘆號」!」來反轉相應的條件。例如，只有在DEBUG未定義的情況下才編譯。
#if !defined DEBUG
Printf(「Final Version!\n」);
#endif
使用defined的一個原因是，它允許由#elif語句確定的宏名字存在。
8. #line
#line指令改變__LINE__和__FILE__的內容。__LINE__和__FILE__都是編譯程序中預定義的標識符。標識符__LINE__的內容是當前被編譯代碼行的行號，__FILE__的內容是當前被編譯源文件的文件名。#line的一般形式是：
#line number 「filename」
其中，number是正整數並變成__LINE__的新值；可選的「filename」是合法文件標識符並變成__FILE__的新值。#line主要用於調試和特殊應用。
9. #pragma
#pragma是編譯程序實現時定義的指令，它允許由此向編譯程序傳入各種指令。例如，一個編譯程序可能具有支持跟蹤程序執行的選項，此時可以用#pragma語句選擇該功能。編譯程序忽略其不支持的#pragma選項。#pragma提高C源程序對編譯程序的可移植性。
10. 預處理操作符#和##
有兩個預處理操作符：#和##，它們可以在#define中使用。
操作符#通常稱為字元串化的操作符，它把其後的串變成用雙引號包圍的串。例如：
#include <stdio.h>
#define mkstr(s) #s
int main(void)
{
Printf(mkstr(I like C));
Return 0;
}
預處理程序把以下的語句：
Printf(mkstr(I like C));
變成
Printf(「I like C」);
操作符##把兩個標記拼在一起，形成一個新標記。例如：
#include <stdio.h>
#define concat(a,a) a##b
int main(void)
{
Int xy = 10;
Printf(「%d」,concat(x,y));
Return 0;
}
預處理程序把以下語句：
Printf(「%d」,concat(x,y));
變成
Printf(「%d」,xy);
操作符#和##主要作用是允許預處理程序對付某些特殊情況，多數程序中並不需要。
11. 預定義宏
C規范了5個固有的預定義宏，它們是：
__LINE__
__FILE__
__DATE__
__TIME__
__STDC__
__LINE__和__FILE__包含正在編譯的程序的行號和文件名。
__DATE__和內容形如month/day/year(月/日/年)的串，代表源文件翻譯成目標碼的日期。
__TIME__中的串代表源代碼編譯成目標碼的時間，形如hour:minute:second(時：分：秒)
如果__STDC__的內容是十進制常數1，則表示編譯程序的實現符合標准C。
⑸ 幫我看看define
#define 是預編譯語句，它不同於函數內的聲明語句，不需要分號。
⑹ 為什麼A是對的，預處理命令行都必須以#號開始 才是對的把
因為如果代碼是注釋它就不起作用了。
如/*注釋#define。
B、預處理命令行不可以 宏定義是可以的。
C、程序在執行過程中對預處理命令行進行處理。是在執行過程之前，所以才稱為預處理，就是先於程序處理的意思，這是對的。
宏定義又稱為宏代換、宏替換，簡稱「宏」。格式：#define標識符文本，其中的標識符就是所謂的符號常量，也稱為「宏名」。
D、對預處理命令行的處理是在編譯之前完成的，不是程序執行的過程中，選D。
(6)預編譯處理命令行後不加分號擴展閱讀：
正確的宏定義是#define S(r) ((r)*(r))
（2）宏名和參數的括弧間不能有空格
（3）宏替換只作替換，不做計算，不做表達式求解
（4）函數調用在編譯後程序運行時進行，並且分配內存。宏替換在編譯前進行，不分配內存
（5）宏的啞實結合不存在類型，也沒有類型轉換。
（6）宏展開使源程序變長，函數調用不會
（7）宏展開不佔運行時間，只佔編譯時間，函數調用占運行時間（分配內存、保留現場、值傳遞、返回值）。
⑺ c語言頭文件末尾為什麼不加分號
C語言用分號來表示一條語句的結束，起語句間的分隔作用。而#include 是的預編譯命令，根本就不是C語言的語句，當然它後面就不用分號結尾了。
⑻ 下列敘述中錯誤的是A在程序中凡是以"#"開頭的語句都是預處理命令行B預處理命令行的最後不能以分號結束
程序設計語言的預處理的概念：在編譯之前進行的處理。 C語言的預處理主要有三個方面的內容： 1.宏定義； 2.文件包含； 3.條件編譯。 預處理命令以符號「#」開頭。
預處理命令在編譯前處理，編譯早於程序執行
⑼ c語言幾個問題
strlen計算字元串s的（unsigned int型）長度，不包括'\0'在內
sizeof是C/C++中的一個操作符（operator），簡單的說其作用就是返回一個對象或者類型所佔的內存位元組數。包括了'\0'在內
strlen(\\\\\\\\vn\vcn\1vb\0bvbv) 是12
sizeof(\\\\\\\\vn\vcn\1vb\0bvbv) 是 18
BCD好像都不正確
B）在程序中凡是以#號開始的語句行都是預處理命令行
答：不一定
C）宏替換不佔用運行時間，只佔用編譯時間
宏替換佔用的是預編譯時間
D）在以下定義是正確的：#define PI 3.1415926;
末尾不要分號
⑽ C語言：預處理是什麼意思就是看不懂這句話的解釋！越具體越好，也可以通俗一點！
第十一章 預處理概述
在前面各章中，已多次使用過以「#」號開頭的預處理命令。如包含命令# include，宏定義命令# define等。在源程序中這些命令都放在函數之外， 而且一般都放在源文件的前面，它們稱為預處理部分。所謂預處理是指在進行編譯的第一遍掃描(詞法掃描和語法分析)之前所作的工作。預處理是Ｃ語言的一個重要功能， 它由預處理程序負責完成。當對一個源文件進行編譯時， 系統將自動引用預處理程序對源程序中的預處理部分作處理， 處理完畢自動進入對源程序的編譯。Ｃ語言提供了多種預處理功能，如宏定義、文件包含、 條件編譯等。合理地使用預處理功能編寫的程序便於閱讀、修改、 移植和調試，也有利於模塊化程序設計。本章介紹常用的幾種預處理功能。宏定義
在Ｃ語言源程序中允許用一個標識符來表示一個字元串， 稱為「宏」。被定義為「宏」的標識符稱為「宏名」。在編譯預處理時，對程序中所有出現的「宏名」，都用宏定義中的字元串去代換， 這稱為「宏代換」或「宏展開」。宏定義是由源程序中的宏定義命令完成的。 宏代換是由預處理程序自動完成的。在Ｃ語言中，「宏」分為有參數和無參數兩種。 下面分別討論這兩種「宏」的定義和調用。 無參宏定義
無參宏的宏名後不帶參數。其定義的一般形式為： #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)
main(){
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；這相當於； 3y�2+3y+4y�2+3y+5y�2+3y；顯然與原題意要求不符。計算結果當然是錯誤的。 因此在作宏定義時必須十分注意。應保證在宏代換之後不發生錯誤。對於宏定義還要說明以下幾點：1. 宏定義是用宏名來表示一個字元串，在宏展開時又以該字元串取代宏名，這只是一種簡單的代換，字元串中可以含任何字元，可以是常數，也可以是表達式，預處理程序對它不作任何檢查。如有錯誤，只能在編譯已被宏展開後的源程序時發現。2. 宏定義不是說明或語句，在行末不必加分號，如加上分號則連分號也一起置換。3. 宏定義必須寫在函數之外，其作用域為宏定義命令起到源程序結 束。如要終止其作用域可使用# undef命令，例如： # define PI 3.14159
main()
{
……
}
# undef PIPI的作用域
f1()
....表示PI只在main函數中有效，在f1中無效。
4. 宏名在源程序中若用引號括起來，則預處理程序不對其作宏代換。
#define OK 100
main()
{
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. 對「輸出格式」作宏定義，可以減少書寫麻煩。例9.3 中就採用了這種方法。
#define P printf
#define D "%d\n"
#define F "%f\n"
main(){
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);
}帶參宏定義Ｃ語言允許宏帶有參數。在宏定義中的參數稱為形式參數， 在宏調用中的參數稱為實際參數。對帶參數的宏，在調用中，不僅要宏展開， 而且要用實參去代換形參。帶參宏定義的一般形式為： #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
main(){
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均出現在條件表達式中。程序第七行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)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}
上例中第一行為宏定義，形參為y。程序第七行宏調用中實參為a+1，是一個表達式，在宏展開時，用a+1代換y，再用(y)*(y) 代換SQ，得到如下語句： sq=(a+1)*(a+1); 這與函數的調用是不同的， 函數調用時要把實參表達式的值求出來再賦予形參。 而宏代換中對實參表達式不作計算直接地照原樣代換。4. 在宏定義中，字元串內的形參通常要用括弧括起來以避免出錯。 在上例中的宏定義中(y)*(y)表達式的y都用括弧括起來，因此結果是正確的。如果去掉括弧，把程序改為以下形式：
#define SQ(y) y*y
main(){
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)
main(){
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:3sq=160為什麼會得這樣的結果呢?分析宏調用語句，在宏代換之後變為： sq=160/(a+1)*(a+1);a為3時，由於「/」和「*」運算符優先順序和結合性相同， 則先作160/(3+1)得40，再作40*(3+1)最後得160。為了得到正確答案應在宏定義中的整個字元串外加括弧， 程序修改如下
#define SQ(y) ((y)*(y))
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
}
以上討論說明，對於宏定義不僅應在參數兩側加括弧， 也應在整個字元串外加括弧。5. 帶參的宏和帶參函數很相似，但有本質上的不同，除上面已談到的各點外，把同一表達式用函數處理與用宏處理兩者的結果有可能是不同的。main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
SQ(int y)
{
return((y)*(y));
}#define SQ(y) ((y)*(y))
main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
在上例中函數名為SQ，形參為Y，函數體表達式為((y)*(y))。在例9.6中宏名為SQ，形參也為y，字元串表達式為(y)*(y))。 兩例是相同的。例9.6的函數調用為SQ(i++)，例9.7的宏調用為SQ(i++)，實參也是相同的。從輸出結果來看，卻大不相同。分析如下：在例9.6中，函數調用是把實參i值傳給形參y後自增1。 然後輸出函數值。因而要循環5次。輸出1～5的平方值。而在例9.7中宏調用時，只作代換。SQ(i++)被代換為((i++)*(i++))。在第一次循環時，由於i等於1，其計算過程為：表達式中前一個i初值為1，然後i自增1變為2，因此表達式中第2個i初值為2，兩相乘的結果也為2，然後i值再自增1，得3。在第二次循環時，i值已有初值為3，因此表達式中前一個i為3，後一個i為4， 乘積為12，然後i再自增1變為5。進入第三次循環，由於i 值已為5，所以這將是最後一次循環。計算表達式的值為5*6等於30。i值再自增1變為6，不再滿足循環條件，停止循環。從以上分析可以看出函數調用和宏調用二者在形式上相似， 在本質上是完全不同的。6. 宏定義也可用來定義多個語句，在宏調用時，把這些語句又代換到源程序內。看下面的例子。
#define SSSV(s1,s2,s3,v) s1=l*w;s2=l*h;s3=w*h;v=w*l*h;
main(){
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 個語句展開並用實參代替形參。使計算結果送入實參之中。文件包含文件包含是C預處理程序的另一個重要功能。文件包含命令行的一般形式為： #include"文件名" 在前面我們已多次用此命令包含過庫函數的頭文件。例如：
#include"stdio.h"
#include"math.h"
文件包含命令的功能是把指定的文件插入該命令行位置取代該命令行， 從而把指定的文件和當前的源程序文件連成一個源文件。在程序設計中，文件包含是很有用的。 一個大的程序可以分為多個模塊，由多個程序員分別編程。 有些公用的符號常量或宏定義等可單獨組成一個文件， 在其它文件的開頭用包含命令包含該文件即可使用。這樣，可避免在每個文件開頭都去書寫那些公用量， 從而節省時間，並減少出錯。對文件包含命令還要說明以下幾點：
1. 包含命令中的文件名可以用雙引號括起來，也可以用尖括弧括起來。例如以下寫法都是允許的： #include"stdio.h"#include<math.h> 但是這兩種形式是有區別的：使用尖括弧表示在包含文件目錄中去查找(包含目錄是由用戶在設置環境時設置的)， 而不在源文件目錄去查找； 使用雙引號則表示首先在當前的源文件目錄中查找，若未找到才到包含目錄中去查找。 用戶編程時可根據自己文件所在的目錄來選擇某一種命令形式。2. 一個include命令只能指定一個被包含文件， 若有多個文件要包含，則需用多個include命令。3. 文件包含允許嵌套，即在一個被包含的文件中又可以包含另一個文件。條件編譯預處理程序提供了條件編譯的功能。 可以按不同的條件去編譯不同的程序部分，因而產生不同的目標代碼文件。 這對於程序的移植和調試是很有用的。 條件編譯有三種形式，下面分別介紹：
1. 第一種形式：
#ifdef 標識符
程序段1
#else
程序段2
#endif
它的功能是，如果標識符已被 #define命令定義過則對程序段1進行編譯；否則對程序段2進行編譯。如果沒有程序段2(它為空)，本格式中的#else可以沒有， 即可以寫為：
#ifdef 標識符
程序段 #endif
#define NUM ok
main(){
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);
}
由於在程序的第16行插入了條件編譯預處理命令， 因此要根據NUM是否被定義過來決定編譯那一個printf語句。而在程序的第一行已對NUM作過宏定義，因此應對第一個printf語句作編譯故運行結果是輸出了學號和成績。在程序的第一行宏定義中，定義NUM表示字元串OK，其實也可以為任何字元串，甚至不給出任何字元串，寫為： #define NUM 也具有同樣的意義。 只有取消程序的第一行才會去編譯第二個printf語句。讀者可上機試作。2. 第二種形式：
#ifndef 標識符
程序段1
#else
程序段2
#endif
與第一種形式的區別是將「ifdef」改為「ifndef」。它的功能是，如果標識符未被#define命令定義過則對程序段1進行編譯， 否則對程序段2進行編譯。這與第一種形式的功能正相反。3. 第三種形式：
#if 常量表達式
程序段1
#else
程序段2
#endif
它的功能是，如常量表達式的值為真(非0)，則對程序段1 進行編譯，否則對程序段2進行編譯。因此可以使程序在不同條件下，完成不同的功能
#define R 1
main(){
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
}
本例中採用了第三種形式的條件編譯。在程序第一行宏定義中，定義R為1，因此在條件編譯時，常量表達式的值為真， 故計算並輸出圓面積。上面介紹的條件編譯當然也可以用條件語句來實現。 但是用條件語句將會對整個源程序進行編譯，生成的目標代碼程序很長，而採用條件編譯，則根據條件只編譯其中的程序段1或程序段2， 生成的目標程序較短。如果條件選擇的程序段很長， 採用條件編譯的方法是十分必要的。