語言的編譯系統對宏命令是

A. 以下敘述正確的是（C）

1.呵呵。#define和printf都屬於預處理命令。預處理命令都不是C語句。而預處理

命令式有ANSI C統一規定的，它不是C語句本身的組成部分。

2.正是由於預處理命令不是C語句的本身組成部分，所以，不能直接對它們進行

編譯（因為編譯程序不能識別它們），必須在對程序進行通常的編譯之前，先對

程序中的這些特殊的命令進行預處理。而宏命令正是預處理命令的一部分。

詳細請見C語言的預處理部分。

B. C語言的編譯系統對宏命令的處理是

前言：宏實質就是編譯器在對代碼進行編譯之前進行的一個「查找替換」工作，就跟你在處理文檔時用wps/word/記事本等進行「查找替換」操作一樣。
c語言的編譯系統對宏命令的處理是（）
a。在程序運行時進行的
b。在對源程序中其他成分正式編譯之前進行的
c。在程序連續時進行的
d。和c程序中的其他語句同時進行編譯
答：選b。在對源程序中其他成分正式編譯之前進行的
2,
#define
n
2
/*
在預編譯時將用下面代碼中n替換成2
*/
#define
m
n+1
/*
在預編譯時將m替換成n+1（即2+1，n會再被替換成2）*/
#define
num
2*m+1
/*
如上：在預編譯時num替換成2*m+1，即2*n+1+1，即2*2+1+1*/
main()
{int
i;
for(i=1;i<=num;i++)printf("%d\n",i);
/*
*
如上所述，上句展開為：for(i=1;i<=2*2+1+1;i++)printf("%d\n",i);
*
所以：循環將執行6次
*/
}
/*
切記注意：每一個宏百進行替換時只是替換「正文」中的內容，而不包括預編譯語句的內容，
否則就會像不少人理解的那樣，錯誤地認為第2個題中的循環將執行7次
*/

C. c語言問題

ADBCADCBAC

D. C語言編譯系統對宏替換的處理是在什麼時候進行的

是正式工作開始之前的准備工作，所以宏替換是在對程序編譯之前進行的。

宏替換是C/C++的預處理中的一部分，對於宏定義中的形參，在替換列表中，如果不是作為#或##的操作數，那麼將對應實參完全展開(相當於對實參進行求值)，然後將替換列表中的形參替換掉，如果是#或##的操作數。

(4)語言的編譯系統對宏命令是擴展閱讀：

宏的用途在於自動化頻繁使用的序列或者是獲得一種更強大的抽象能力。

計算機語言如C語言或匯編語言有簡單的宏系統，由編譯器或匯編器的預處理器實現。C語言的宏預處理器的工作只是簡單的文本搜索和替換，使用附加的文本處理語言如M4，C程序員可以獲得更精巧的宏。

宏的行為如同是函數對自身程序文本的變形，並且可以應用全部語言來表達這種變形。一個C宏可以定義一段語法的替換，然而一個Lisp的宏卻可以控制一節代碼的計算。

E. c語言中的「宏」是指什麼

是一種批量處理的稱謂。計算機科學里的宏是一種抽象（Abstraction），它根據一系列預定義的規則替換一定的文本模式。

「宏」這個詞的使用暗示著將小命令或動作轉化為一系列指令。
計算機語言如C語言或 匯編語言有簡單的宏系統，由編譯器或匯編器的預處理器實現。C語言的宏預處理器的工作只是簡單的文本搜索和替換，使用附加的文本處理語言如M4，C程序員可以獲得更精巧的宏。

在Objective-C語言源程序中，允許用一個標識符來表示一個字元串，稱為宏，被定義為宏的標識符稱為宏名。在編譯預處理時，對程序中所有出現的宏名，都用宏定義中的字元串去替換，這稱為宏替換或宏展開。

宏定義是由源程序中的宏定義命令完成的，宏替換是由預處理程序自動完成的。在Objective-C語言中，宏分為有參數和無參數兩種。

(5)語言的編譯系統對宏命令是擴展閱讀

A類宏是用G65 Hxx P#xx Q#xx R#xx或G65
Hxx P#xx Qxx
Rxx格式輸入的，xx的意思就是數值，是以um級的量輸入的，比如你輸入100那就是0.1MM #xx就是變數號，變數號就是把數值代入到一個固定的地址中，固定的地址就是變數。

一般OTD系有#0~#100~#149~#500~#531.關閉電源時變數#100~#149被初始化成「空」，而變數#500~#531保持數據。我們如果說#100=30那麼現在#100地址內的數據就是30了。

B類宏能完成某一功能的一系列指令像子程序那樣存入存儲器，用戶可以設定M、S、T、G代碼調用它們，使用時只需給出這個指令代碼就能執行其功能，也可以像調用子程序一樣使用。

F. 宏命令的宏命令（計算機科學）

對於編譯語言，宏展開在編譯時發生，進行宏展開的工具常被稱為宏展開器。宏這一術語也常常被用於許多類似的環境中，它們是源自宏展開的概念，這包括鍵盤宏和宏語言。絕大多數情況下，「宏」這個詞的使用暗示著將小命令或動作轉化為一系列指令。
計算機語言如C語言或匯編語言有簡單的宏系統，由編譯器或匯編器的預處理器實現。C語言的宏預處理器的工作只是簡單的文本搜索和替換，使用附加的文本處理語言如M4，C程序員可以獲得更精巧的宏。 應用程序也可以使用一種和宏類似機理的系統來允許用戶將一系列（一般是最常使用到的操作）自定義為一個步驟。也就是用戶執行一系列操作，並且讓應用程序來「記住」這些操作以及順序。更高級的用戶可以通過內建的宏編程來來直接使用那些應用程序的功能。
當使用一種不熟悉的宏語言來編程時，比較有效的方法就是記錄一連串用戶希望得到的操作，然後通過閱讀應用程序記錄下來的宏文件來理解宏命令的結構組成。

G. C語言幫忙對一下答案

這是老師給的一分以前卷子的參考題目和答案，明天就要補考了，題目很簡單的應該，但我基本不懂，可我發現好象答案不對的，誰能幫我對一下謝謝了。答案附在後面

A卷
一、單項選擇題（每小題2分，共40分）。
1． 一個C語言程序至少包含一個（ ）函數
A. printf B. scanf C. main D.自定義
2.以下敘述正確的是（ ）
A． 在C程序中，main( )函數必須位於程序的最前面
B． C程序的每行中只能寫一個語句
C． C語言本身沒有輸入輸出語句
D． 在對C語言進行編譯的過程中，可以發現注釋中的錯誤
3.下列C語句不正確的有（ ）
A．x=y=14; B.int x,y,z;
C.x=4,y=13; D.z=x+y;
4. 在int(*prt)[3];語句中，關於標識符prt正確的選項是（ ）
A.定義不合法
B.一個指向整型變數的指針
C.一個指針，它指向一個具有3個元素的一維數組
D.一個指針數組名，每個元素是一個指向整型變數的指針
5. 與十六進制數200等值的十進制數為 ( )
A . 256 B. 512 C .1024 D. 2048

6.以下敘述中正確的是（ ）
A. C語言的源程序不必通過編譯就可以直接運行
B. C語言中的每條可執行語句最終都將被轉換成二進制的機器指令
C. C源程序經編譯形成的二進制代碼可以直接運行
D. C語言中的函數不可以單獨進行編譯

7. putchar函數可以向終端輸出一個( )。
A． 整型變數表達式值 B .實型變數值
C. 字元串 D. 字元或字元變數值
8.已知float a=10.6,a/=2的結果是( )
A.5.3 B.5.300000 C.5.0 D.5
9. 在下列符號中，哪個是合法的變數名？（ ）
A、 #jhgf B、 _gh3 C、 -76t D、 3ab
10. 有如下輸入語句scanf(「a=%d,b=%d,b=%d」,&a,&b,&c);為使變數a的值為1,b 的值為3,c的值為2,從鍵盤輸入數據的正確形式應是( ).
A.132<CR> B.1,3,2<CR> C.a=1,b=3,c=2<CR> D.a=1 b=3 c=2<CR>

11.已知字母A的ASCII碼是65,以下程序的執行結果是( )
# include <stdio.h>
main ( )
{char c1=』A』,c2=』E』;
printf (「%d,%d」,c1,c2);}
A. A , E B. 65 , 65 C. 65 , 69 D. 65 ,70
12. 在C語言中switch語句可以和（ ）關鍵字配合使用來構成多分支選擇語句。
A. case B.break C. goto D. else
13.如果a=4,b=4,則！（a>b）的值為（ ）
A． 真 B 假 C 不確定
14.能正確表示「m≥5或m≤3」的關系表達式是（ ）
A．m>=5 or m<=3」 B m>=5|m<=3
C. m>=5||m<=3 D.m>=5 + m<=3
15.已知一個函數的定義為： void abc ( ) { … }
則函數中 void 的含義是( )
A、 執行該函數後函數沒有返回值 B、 執行該函數後不返回
C、 該函數可以返回任意類型的數據 D、 以上都不對
16.C語言的編譯系統對宏命令的處理是( )
A.、在程序運行時進行
B、在程序連接時進行
C、和C程序中的其他語句同時進行編譯的
D、在對源程序中其他成分正式編譯之前進行
17.判斷字元串s1是否大於字元串s2,應當使用（ ）
A．if (s1>s2) B. if （strcmp (s1,s2) ）
C. if (strcmp(s2,s1)>0) D.if (strcmp(s1,s2)>0)
18.設有數組定義：char array[ ]=」China」;則數組array所佔的空間為（ ）個位元組。
A． 4 B. 5 C. 6 D. 7
19. 若有定義：int x=7, p=&x; 則執行*p=*p+1; x=x+2; 以後x的值是： ( )
A. 7 B. 8 C. 9 D. 10
20. 以下在任何情況下計算平方數時都不會引起二義性的宏定義是（ ）
A. #define POWER(x) x*x
B. #define POWER(x) (x)*(x)
C.#define POWER(x) (x*x)
D.#define POWER(x) ((x)*(x))
二、填空題(每空2分，計20分)
1一個C源程序至少應包括一個_______。
2.程序三種最基本的結構是___________、_______________、_________________。
3.若a是int 型變數，且a的初值為6，則計算表達式a+=a*a; 後a的值為______。
4. 指針變數的含義是指向變數的_______
5.若有以下定義：float w[16]; 則w數組元素下標的取值范圍是______到______。
6..設a=3, b=2, c=1, 則表達式a>b+c的值是_____________。
7..以下程序段的運行結果是______
char a[7]=」abcdef」;
printf(「%c」,a[5]);
三、讀程序，寫出運行結果（5*4分）
1．下面程序的運行結果是_______________________________________
# include <stdio.h>
main ( )
{ int a, b;
a = 10;
b = a*9;
printf(「b = %d\n」, b);
}
2． 以下程序段的運行結果是__________
# define ADD(x) x+x
main( )
{ int m=1, n=2, k=3;
int sum=ADD(m+n)*k;
printf (「sum=%d」,sum);
}

3. 以下程序輸入123456<CR>後的執行結果是______
# include <stdio.h>
main( )
{int a,b;
scanf (「%2d%3d」,&a,&b);
printf (「a=%d,b=%d\n」,a,b);
}
4.下面程序的運行結果是_______________________________________。
main ( )
{ int i;
for (i=1;i<=5;i++)
{ if (i%2)
printf (「*」);
printf (「#」);
}
printf (「#」);
}
5.以下程序的運行結果是_______
#include <stdio.h>
int a=10,b,*p;
main( )
{p=&a;
b=(*p)++;
printf(「%d,%d\n」,a,b);
}

答案
1.A 2．C 3．C 4．C 5．B 6．C 7．D 8．B
9．B 10．C 11．C 12．A 13．A 14．C 15．A 16．D
17．B 18．C 19．C 20．A

二、填空題(每空2分，計20分)
1、主函數 2、順序，選擇條件，循環結構 3、42 4、地址 5、0，15
6、0 7、f

三、讀程序，寫出運行結果（5*4分）
1、 b=90 2、sum=10 3、a=12,b=345 4、*##*##*## 5、11，10

B卷
一、單項選擇題（每小題2分，共40分）。
1.一個 C語言程序是由( )
A.函數組成
B.若干個過程組成
C.若乾子程序組成
D一個主程序和若乾子程序組成
2.以下敘述不正確的有（ ）
A. C程序中，語句之間必須用分號（；）分隔
B. C程序中，多行語句可以寫在一行中
C. C程序中，可以不必包含主函數
D. C程序中，可以由多個函數組成
3.下列C語句不正確的有（ ）
A．x=y=14; B.int x,y,z; C.x=4,y=13; D.z=x+y;
4.已知int a = 5, 則執行a = a/2; 後的a值是 ( )
A. 2.5 B. 2 C. 2.0 D. 3
5.判斷整數a和b是否相等，應當使用 ( )
A．if (a==b) B. if (a=b) C. if (a, b) D. if (a!=b)
6.C語言的標識符的第一個字元必須為( )
A.字母 B.下劃線 C. 字母或下劃線 D. 字母或下劃線或數字
7. 已知字母A的ASCII碼值為66，執行下面的程序：
main( )
{ char c1=』A』;
printf(「%d %c\n」, c1, c1);
} 執行後輸出結果是（ ）
A. 66 A B. A 66 C. 65 A D. A 65
8.在C語言中if語句可以和（ ）關鍵字配合使用來構成分支選擇語句。
A. else B.break C. goto D. int
9. putchar函數可以輸出一個( )。
A． 整型變數表達式值
B． 實型變數值
C． 字元串
D． 字元
10. C語言中while和do-while循環的主要區別是( )。
A． do-while的循環體至少無條件執行一次
B． while的循環控制條件比do-while的循環控制條件嚴格
C． do-while允許從外部轉到循環體內
D. do-while的循環體不能是復合語句

11. 如果a=4,b=4,則（a<b）的值為（ ）
A． 真 B 假 C 不確定
12.下面對變數說明錯誤的是（ ）
A. char c1, int x; B. int a, b; float x, y;
C. int a; int b; D. char c1; int x;
13.若有a=1,b=2,c=3,d=4則條件表達式 a > b? c : d的值為 ( )
A. 2 B. 1 C. 4 D. 3
14. 設變數a是整型，f是實型，i是double型，則表達式10+』a』+i*f的值的數據類型為（ ）
A.整型 B. float C.double D.不確定
15.若有定義：int x, *pb; 則以下正確的賦值表達式是：
A）pb=&x; B)pb=x; C)*pb=&x; D)*pb=*x;
16.在C語言程序中，（ ）。
A． 函數的定義可以嵌套，但函數的調用不可以嵌套
B． 函數的定義不可以嵌套，但函數的調用可以嵌套
C． 函數的定義和函數均不可以嵌套
D. 函數的定義和函數均可以嵌套
17.以下程序段的運行結果是( )
char a[7]=」abcdef」;
printf(「%c」,a[5]);
A. d B. f C. e D.
18.凡是在函數中未指定存儲類別的局部變數，其隱含的存儲類別為（）
A．自動（auto） B.靜態（static） C.外部（extern） D.寄存器（register）
19.在int(*prt)[3];語句中，關於標識符prt正確的選項是（）
A. 定義不合法
B. 一個指向整型變數的指針
C. 一個指針，它指向一個具有3個元素的一維數組
D. 一個指針數組名，每個元素是一個指向整型變數的指針
20.判斷char型變數c1是否為小寫字母的正確表達式是（ ）
A. (c1>=』a』)&&(c1<=『z』 ) B. (c1>=a)&&(c1<=z )
C. (』a』<= c1 <=『z』 ) D. ( a<= c1 <= z )
二、填空題(每空2分，計20分)
1.在C語言中，表示邏輯「假」值用______ 。
2.在C語言中（以微型機為例），一個char型數據在內存中所佔的位元組數是_____;一個float型數據在內存中所佔的位元組數是_____;一個double型數據在內存中所佔的位元組數是__________。
3．若a是int 型變數，且a的初值為3，則計算表達式a+=a*a; 後a的值為______。
4．C源程序的基本單位是_______
5若有以下定義：int score[6]; 則score數組元素下標的取值范圍是______到______。
6. 字元『0』的十進制ASCII碼值是48，則字元『9』的十進制ASCII碼值是_______
7.有表達式 「20 < x <30」, 用C語言正確描述它應該是__________________________。

三、讀程序，寫出運行結果（5*4分）
1．執行下面的程序：
void main( )
{ int x=3, y＝1;
if ( x < y ) printf(「*****\n」);
else printf(「#####\n」);
}
其輸出的結果是__________________________。

2.下面程序的運行結果是______________________________________(畫□表示空格)。
假設輸入1.23 50
# include <stdio.h>
main ( )
{ float x, y;
scanf(「%f%f」, &x, &y);
printf(「x=%7.2f, y=%7.2f\n」, x, y );
}

3.寫出下面程序的輸出結果_______________________________________________。
main ( )
{ int a=10, b=14, c=3;
if ( a < b ) a = b;
if ( a < c ) a = c;
printf(「a=%d, b=%d, c=%d\n」, a, b, c );
}

4.下面程序的輸出結果是_____________
main()
{int number=0;
while (number++>=1)
printf (「*%d\n」,number);
printf(「**%d\n」,number);
}

5以下程序的運行結果是_______
void increment( )
{int x=0;
x+=1;
printf(「%d」,x);
}
main( )
{increment( );
increment( );
increment( );
}

一、單項選擇題（每小題2分，共40分）。
1．A 2．C 3．C 4．B 5．A 6．C 7．A 8．A
9．D 10．A 11．B 12．A 13．C 14．C 15．A 16．B
17．B 18．A 19．D 20．A
二、填空題(每空2分，計20分)
1、1 2、1,4,8 3、42 4、函數 5、0，5 6、57 7、x>20&&x<30
三、讀程序，寫出運行結果（5*4分）
1、##### 2、x= 1.25 y= 50.00 3、a=14,b=14,c=3
4、**1 5、111

H. 電氣三班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