文章目錄：
單元一：C語言概述與數據結構
單元二：順序結構程序設計
單元三：選擇結構程序設計
單元四：循環結構程序設計
單元五：數組函數指針
單元六：編譯預處理
單元七：結構體共用體
單元八：位運算
單元九：文件
單元十：程序設計題
第1-2章：概述、順序、選擇、循環結構
第3-4章：數組、指針
第5-7章：函數
位運算、預處理、結構體、共用體
文件這裏沒有後面的我自己加上：
第8-12章：預處理、結構體、共用體、位運算及文件操作
第一部分：各章節類
第1、2章(概述、順序、選擇、循環結構)練習題【58題】
一、選擇題【23題】
1.下列運算符中（C）結合性從左到右。
A. 三目 B. 賦值 C. 比較 D. 單目
2.下列for循環的次數爲（B）：for ( i=0，x=0；! x && i<=5；i++)
A. 5 B. 6 C. 1 D. 無限
3.下述關於循環體的描述中，（C）是錯誤的。
A.循環體中可以出現break語句和continue語句；B．循環體中還可以出現循環語句；
C.循環體中不能出現goto語句； D.循環體中可以出現開關語句
4．下列變量名中，（A）是合法的。
A．CHINA； B．student-num； C．double D．A+b
5．有以下程序段：
int n=0,p; do { scanf(”%d”, &p); n++;} while(p!=12345&&n<3);
此處do-while循環的結束條件是（D）。
A．p的值不等於12345並且n的值小於3 B．p的值等於12345並且n的值大於等於3
C．p的值不等於12345或者n的值小於3 D．p的值等於12345或者n的值大於等於3
6．若有定義：int a=8，b=5，C；，執行語句C=a/b+0.4;後，c的值爲（B）
A．1.4 B．1 C．2.0 D．2
7． 以下程序中，while循環的循環次數是（D）
void main( ){ int i=0; while(i<10){ if(i<1) continue; if(i==5) break; i++; } .....A．1 B．10 C．6 D．死循環，不能確定次數
溫馨提示！
break語句——只能在循環體和switch語句體內使用
當break出現在 switch語句體內時，其作用只是跳出該switch語句體。
當break出現在循環體中，但不在 switch語句體內時，則在執行break後，跳出本層循環體。
continue語句——的作用是結束本次循環，即跳過本次循環中餘下尚未執行的語句，接着再一次進行循環的條件判定。
本程序中，變量i的初始值爲0，判斷while後面括號內表達式的值爲真，執行循環體內的if語句，判斷if後面括號內表達式的值爲真，執行“continue;”語句。因continue的作用是結束本次循環，即跳過本次循環體中餘下尚未執行的語句，接着再一次進行循環的條件判斷，所以i的值未發生變化，循環條件仍然爲真，if語句也仍然成立，因此循環將無止境地進行下去。
8．下列while循環的執行次數是（A）
while(i=0) i--;A．0 B．1 C．5 D．死循環
溫馨提示！
c語言中while表達式爲真（非0）時執行循環體,題中爲假,跳出循環選
9．以下說法中正確的是：（C）
A.C語言程序總是從第一個的函數開始執行；
B.在C語言程序中,要調用的函數必須在main()函數中定義；
C.C語言程序總是從main()函數開始執行；
D.C語言程序中的main()函數必須放在程序的開始部分。
10．以下程序的輸出結果是：（D）
void main() { int x=10,y=10; printf("%d %d\n",x - -, - - y); }
A. 10 10 B.9 9 C. 9 10 D. 10 9
11．int a=1,b=3;,則下列表達式的結果爲“真”的是：（D）
A. a>=2||!b&&b<4 B. b-a&&!a||a-b&&a/b
C. a-!a%b&&!b-!b%b D.a+b&&a-b&&b-3&&a||b
12．請選出合法的C語言賦值語句（B）
A.a=b=58 B.i++; C.a=58,b=58 D.k=int(a+b);
13．若有以下定義和語句：（B）
char c1='b',c2='e'; printf("%d,%c\n",c2-c1,c2-'a'+'A');則輸出結果是:
A. 2,M B. 3,E C. 2,E D. 輸出項與對應的格式控制不一致,輸出結果不確定。https://blog.csdn.net/liu17234050/article/details/104219239
14．運行以下程序段後變量a的值是：（C）
int a=0, b=3; switch(a+b&&a&&b++&&a++) { case 0:a++; case 1:b++; case 2:a+=b; break; case 3:a-=b; default:a; }(A)-3 (B)1 (C)5 (D)6
溫馨提示！
15.在以下一組運算符中,優先級最高的運算符是：（C）
(A)<= (B)= (C)% (D)&&https://blog.csdn.net/liu17234050/article/details/104176911
溫馨提示！
16.設 int a=12，則執行完語句 a+=a-=a*a後，a的值是（D）
(A)552 (B)264 (C)144 (D)-264先計算a-=a*a，得到a=12-12*12=-132；
a+=-132，得到a=-132-132=-264。
17.C語言中基本數據類型包括 （B）
(A)整型、實型、邏輯型 (B)整型、實型、字符型
(C)整型、字符型、邏輯型 (D)整型、實型、邏輯型、字符型
18.執行下面程序片段的結果是（B）
int x=23; do{ printf("%2d",x - -); }while(!x);(A)打印出321 (B)打印出23 (C)不打印任何內容 (D) 陷入死循環
19.若k是int型變量,且有下面的程序片段：（D）
k = -3; if(k<=0) printf("####") else printf("&&&&");上面程序片段的輸出結果是
(A)#### (B)&&&& (C)####&&&& (D)有語法錯誤,無輸出結果。溫馨提示！
後面少了分號，
正確的應該是這樣：
if(k<=0) printf("####");
20.爲表示關係x≥y≥z,應使用C語言表達式 （A）
(A)(x>=y)&&(y>=z) (B)(x>=y)AND(y>=z) (C)(x>=y>=z) (D)(x>=y)&(y>=z)
21. 若c爲char類型變量，能正確判斷出c爲小寫字母的表達式是（D）
A) 'a'<=c<='z' B) (c>='a') || (c<='z') C) c>='a' || c<='z' D) c<='z' && c>='a'
22．下面程序執行後輸出sum的值是（D）
A)15 B) 14 C) 0 D) 不確定
void main(){ int i,sum; for(i=0;i<6;i++) sum+=i; printf("%d\n",sum); }溫馨提示！
答案爲不確定，因爲sum在初始化的時候沒有賦值，sum的值是不確定的，得到的只是個隨機數，幸運的話可以得到0
23.以下敘述正確的是：（D）
A) 可以把include和if定義爲用戶標識符
B) 可以把include定義爲用戶標識符，但不能把if定義爲用戶標識符
C) 可以把if定義爲用戶標識符，但不能把include定義爲用戶標識符
D) include和if都不能定義爲用戶標識符
二、 判斷下列描述的正確性，對者劃√，錯者劃╳【11題】
- switch語句中必須有break語句，否則無法退出switch語句。F
- C中標識符內的大小寫字母是沒有區別的。F
- 隱含的類型轉換都是保值映射，顯式的類型轉換都是非保值映射。F 一般是精度降低時才需要進行顯示轉換，或者是把void *類型指針轉換成某種類型的指針需要顯示轉換，例如malloc中就需要
- 運算符的優先級和結合性可以確定表達式的計算順序。T
- while循環語句的循環體至少執行一次。F
- 開關語句不可以嵌套，在開關語句的語句序列中不能再有開關語句。F
- C語言在編譯時不檢查語法；F
- 在C語言中，”A”是錯誤的char類型的常數； T（）
- 字符(char)型數據在微機內存中的存儲形式是ASCII碼；T
- C語言的源程序不必通過編譯就可以直接運行；F
- “Int”是合法的C語言關鍵字；F
三、寫出下列程序的運行結果【10題】
1. void main(){ int a=4,b=5,c=0,d; d=!a&&!b||!c; printf(“%d”, d); }溫馨提示！
＆＆和||是邏輯運算符，屬於平級運算，運算優先次序爲從左到右，❗a和❗b都是0，所以是0，所以0||❗c,❗c是1，所以最終結果是1
1
2. void main(){ int i =1, sum=0; while (i<=5){ sum+=i; i++;} printf(“sum=%d”, sum); }sum=15
3. void main(){ int a=0,i; for(i=1;i<5;i++){ switch(i){ case 0: case 3:a+=2; case 1: case 2:a+=3; default:a+=5; } } printf(“%d”, a); }溫馨提示！
31
4. void main(){ int a=15,b=21,m=0; switch(a%3){ case 0:m++;break; case 1:m++; switch(b%2){ default:m++; case 0:m++;break; } }; printf(“%d”，m);}溫馨提示！
1
5．從鍵盤輸入1325。 void main(){ int n1,n2; scanf("%d",&n2); while(n2!=0) { n1=n2%10; n2=n2/10; printf("%d",n1); } }5231
6. void main(){ int a=5,b=4,c=3,d; d=(a>b>c); printf("%d\n",d); }0
7. void main(){ int s,i; for( s=0,i=1; i<3; i++,s+=i); printf("%d\n",s); }5
8. void main() { int i; for(i=1;i<=5;i++){ if(i%2) printf("*"); else continue; printf("#"); } printf("$\n"); }溫馨提示！
*#*#*#$
9. void main ( ){ int a,b; for (a=1,b=1 ; a<=100 ; a++) { if (b>=20) break; if (b%3==1) { b+=3 ; continue ; } b-=5; } printf("%d\n",a); }溫馨提示！
8
10. //輸入m的值爲18 #include <stdio.h> void main( ){ int m,i; scanf("%d", &m); for(i=1;i<m;i++) if(m%i==0) printf("%3d",i); }1 2 3 6 9
四、完成程序【7題】
1. 程序的功能是:分別計算1到10之間奇數之和及偶數之和 void main(){ int a,b,c,i; a = c = 0; for(i=0;i<=10;i+=2) { a += i; b =（1）; c += b; } printf("偶數之和=%d\n",a); printf("奇數之和=%d\n",（2）); }i+1
c
2. 輸出100以內能被3整除且個位數爲6的所有整數。 void main() { int i, j; for(i=0; （3）; i++) { j=i*10+6; if(（4）) continue; printf("%d",j); } }i<10
j%3
3. 判斷輸入的正整數是否爲素數。 #include <math.h> void main(){ int m，i，k; scanf("%d"，&m); k=sqrt(m); for (i=2;i<=k;i++) if(（5）) break; if(（6）) printf("%d 是素數\n"，m) else printf("%d 不是素數\n"，m); }
m%i==0
i==k+1
4. 輸入學號，並輸出其中能被7或9整除的學號，當學號輸入0值時結束循環。 void main(){ int num; do{ scanf (“%d”, &num); if(（7）) printf(“%d ”, num); } while (（8）); }num%7==0||num%9==0
num!=0
5.求某數的泰勒（臺勞）級數的前n+1項之和。x的泰勒級數： void main ( ){ int i,n; float x; float t=1.0,sum=1.0; scanf(“%f, %d”, &x, &n); for(i=1;i<n;i++){ t*= （9）; （10）= t; } printf(“%f”, sum); }溫馨提示！
x/i
sum+
6. 得到一個輸入數字的反轉數，然後一次輸出這個整數。 void main(){ int n, right_digit, newnum = 0; printf("Enter the number: "); scanf("%d",&n); printf("reverse order is "); do { right_digit = n % 10; //生成所輸入數字的反轉數 newnum=newnum*10+right_digit; n =（11） ; } while (n != 0); printf("%d\n",（12）); }n/10
newnum
7．猴子喫桃問題。 猴子第一天摘下若干個桃子，當即吃了一半多一個。 第二天早上又將剩下的桃子喫掉一半多一個。 以後每天早上都喫掉前一天剩下的一半多一個。 到第5天早上喫時，只剩下一個桃子。 求第一天共摘了多少個桃子。 void main(){ int day, x1,x2; //day是天數， x1和x2表示前一天和當天剩下的桃子數 day=4; x2=1;//第4天剩下的桃子數 while(（13）){ x1=(x2+1)*2;// 當天剩桃子數：x2=x1/2-1 x2=（14）; （15）; } printf(“桃子總數=%d”,x1);}day>0
x1
day--
五、程序設計題【7題】
1.求1-5的階乘之和。 n!=(n-1)! * n sum:和。初值爲0。 factorial:積。初值爲1。 #include <stdio.h> void main(){ int i, factorial=1, sum=0; for( i=1;i<=5;i++) { factorial*=i; sum+=factorial; } printf(“%d”,sum); }
2. 輸入一行字符，分別統計出其中英文字母、空格、數字和其它字符的個數。 void main(){ char ch; int letter=0,space=0, digit=0,other=0; while( ( ch=getchar( ) ) !='\n'){ if((ch>='a' && ch<='z') ||(ch>='A' && ch<='Z')) letter++; else if (ch>='0' && ch<='9') digit++; else if(ch==' ') space++; else other++; } printf("%d,%d,%d,%d",letter,digit,space,other); }
3.求Sn=a+aa+aaa+…+aa…a 的值。其中a是一個數字。n由鍵盤輸入。 Sn=term1+term2+term3+…+termn term1 =a term2 = term1*10+a termi+1 = termi*10+a void main(){ int n,a,,i; float f,term; scanf("%d,%d", &a, &n); term=a; sum=term; for(i=1;i<n;i++){ //termi+1 = termi*10+a term=term*10+a; sum+=term; } printf("sum=%f",sum); }
4. 求前20項之和： …… (選做) 找規律： void main(){ float sum=0; int a=1,b=2, t; for(int i=1; i<=20; i++){ sum+=(float)b/a; //sum+=bi/ai t=a+b; //t=ai+bi a=b; //ai+1=bi b=t; //bi+1=ai+bi } printf(“%f”,sum); }
5. 打印圖案。（選做） void main(){ int i,j,k; for(i=0;i<=3;i++){ for(j=0;j<=2-i;j++) printf(" "); for(k=0;k<=2*i;k++) printf("*"); printf("\n"); } for(i=0;i<=2;i++){ for(j=0;j<=i;j++) printf(" "); for(k=0;k<=4-2*i;k++) printf("*"); printf("\n"); } }
6. 輸入兩個正整數m和n, 用輾轉相除法求最大公約數和最小公倍數。（選做） void main(){ int a,b,m,n,temp; printf("Please input the two number:\n"); scanf("%d,%d",&m,&n); if(m<n)//將兩個數中較大的放在m中 {temp=m; m=n; n=temp;} a=m;b=n; while(b!=0) /*a中放的是最大公約數*/ {temp=a%b; a=b; b=temp; } printf("最大公約數是：%d\n",a); printf("最小公倍數是：%d\n",m*n/a); }溫馨提示！
7. 設計具有以下功能的程序：從鍵盤上輸入若干個非負整數，統計並輸出最大數、最小數和平均數，當輸入負數時結束輸入。(自己完成，並上機驗證)
答案
一、選擇題
1
2
3
4
5
6
7
8
9
10
C
B
C
A
D
B
D
A
C
D
11
12
13
14
15
16
17
18
19
20
D
B
B
C
C
D
B
B
D
A
21
22
23
D
D
D
二、判斷題
1
2
3
4
5
6
7
8
9
10
11
F
F
F
T
F
F
F
T
T
F
F
三、讀程序
1
2
3
4
5
6
7
8
1
sum=15
31
1
5231
0
5
*#*#*#$
9
10
11
12
8
1 2 3 6 9
四、程序填空
（1）
（2）
（3）
（4）
（5）
i+1
c
i<10
j%3
m%i==0
（6）
（7）
（8）
（9）
（10）
i==k+1
num%7==0||num%9==0
num!=0
x/i
sum+
（11）
（12）
（13）
（14）
（15）
n/10
newnum
day>0
x1
day--
第3-4章(數組、指針)練習題【40題】
一：選擇題【16題】
1. 以下錯誤的字符串賦值或賦初值方式是：C
（A）char str1[]=”string”, str2[]=”12345678”;strcpy(str2,str1);
（B）char str[7]={’s’,’t’,’r’,’i’,’n’,’g’};
（C）char str[10] ;str =”string”;
（D）char *str; str=”string”;
2. 數組定義中不正確的是 ：D
（A） int a[2][3]; （B） int b[][3]={0,1,2,3};
（C） int c[100][100]={0}; （D） int d[3][]={{1,2},{1,2,3},{1,2,3,4}};
3. 以下對一維數組a正確初始化的是：C
（A）int a[10]=(0,0,0,0,); （B）int a[10]={};
（C）int a[10]={0}; （D）int a[10]=(10*2);
4.以下選項中，不能正確賦值的是： A
（A） char s1[10];s1="Ctest"; （B） char s2[]={'C', 't', 'e', 's', 't'};（C） char s3[20]="Ctest"; （D） char *s4="Ctest\n"
溫馨提示！
5.若有說明：int i, j=2，*p=&i;，則能完成i=j賦值功能的語句是： B
（A） i=*p; （B） *p=*&j; （C） i=&j; （D） i=**p;
6. 下面各語句行中,不能正確進行字符串操作的語句行是：D
(A) char st[10]={"abcde"}; (B) char s[5]={'a','b','c','d','e'};
(C) char *s; s="abcde"; (D) char *s; scanf("%s",s);溫馨提示！
7.設有如下的程序段,執行上面的程序段後，*(ptr+5)的值爲:B
char str[ ]="Hello"; char *ptr; ptr=str;
(A) 'o' (B) '\0' (C)不確定的值 (D) 'o'的地址溫馨提示！
8. 請選出以下語句的輸出結果A
printf("%d\n",strlen("\t\"\065\xff\n"));
(A)5 (B)14 (C)8 (D)輸出項不合法，無正常輸出
9.以下程序段給數組所有的元素輸入數據，請選擇正確答案填入。A
main() { int a[10],i=0; while(i<10) scanf("%d",________ ); ┇}(A)a+(i++) (B)&a[i+1] (C)a+i (D)&a[++i]
10.若有以下說明和語句，請選出哪個是對c數組元素的正確引用B
int c[10], *cp; cp=c;(A)cp+1 (B)*(cp+3) (C)**(cp+1)+3 (D)*(*cp+2)
11.設有如下一段程序, 執行下面的程序後, ab的值爲：B
int *var, ab; ab = 100; var = &ab; ab = *var + 10;(A)120 (B)110 (C)100 (D)90
12.若有以下定義：int a[10], *p=a ；則p+4表示A
A) 元素a[4]的地址 B) 元素a[4]的值 C) 元素a[5]的地址 D) 元素a[5]的值
13. 判斷字符串s1是否小於字符串s2，應當使用D
A) if(s1 < s2) B) if(strcmp(s1,s2)) C) if (strcpy(s1,s2)<0 ) D) if(strcmp(s1,s2)<0)
14.在下面的定義語句中，錯誤的是A
A)int n=20, a[n]; B) char *a[3]; C) char s[20]="test"; D) int a[]={1,2};
15.對C語言字符數組的描述中錯誤的是：C
A) 字符數組可以存放字符串。
B) 字符數組的字符串可以整體輸入輸出。
C) 可以在賦值語句中通過賦值運算符對字符數組整體賦值。
D) 不可以用關係運算符對字符數組中的字符串進行比較。
16.設有以下說明語句：
struct stu { int a; float b; } stutype;則下面的敘述不正確的是：C
A) struct 是定義結構體類型的關鍵字。 B) struct stu是用戶定義的結構體類型。
C) stutype是用戶定義的結構體類型名。 D) a 和b都是結構體成員名。
溫馨提示！
stu纔是用戶定義的結構圖類型名，stutype是用戶定義的一個stu類型的變量
二、讀程序【15題】
1. void main( ){ char *p="abcd\0efgh\0"; printf("%d"，strlen（p）); }4
2. void main( ) { char ss[][20]={"1234","56789"}, *p=sss[0]; printf("%s", p+20); }56789
3. void main( ){ char b[]="Hello,you"; b[5] = b[9]; printf("%s \n", b ); }Hello
溫馨提示！
![]()
4. void main( ){ int arr[]={40,30,25,35,12,6,8}, *p=arr; p++; printf("%d\n",*(p+4)); }6
溫馨提示！
5.void main( ){ int n[3],i,j,k; for(i=0;i<3;i++) n[i]=0; k=2; for (i=0;i<k;i++) for (j=0;j<k;j++) n[j]=n[i]+1; printf("%d\n", n[1]); }3
![]()
![]()
6. void main ( ) { int a[5]={15, 23, 4, 67, 98}; int i, m, n; m=n=a[0]; for (i=1; i<5; i++ ){ if (m>a[ i ] ) m=a[ i ]; if (n<a[ i ] ) n=a[ i ]; } printf ( “%d , %d”, m, n); }4,98
7. void main( ) { int x[]={10,20,30,40,50,60,70,80,90,100}; int s, i, *p; s=0; p=x; for(i=1;i<10;i+=2) s+=*(p+i); printf("sum=%d\n",s) }sum=300
8.劃線兩輸出語句分別輸出13ff50和4 void main( ) { int a[3][4]; printf("\n%x", a); printf("\n%d",sizeof(a[0][0])); printf("\n%x", a[0]+2); printf("\n%x", &a[1]+1); printf("\n%x", &a[0][0]+3); }13ff58
13ff70
13ff5c
9. void main( ){ int i=1,n=3,j,k=3; int a[5]={1,4,5}; while(i<=n && k>a[i]) i++; for(j=n-1;j>=i;j--) a[j+1]=a[j]; a[i]=k; for(i=0;i<=n;i++) printf("%3d",a[i]); }1 3 4 5
10. void main(){ int a[10]={10,12,13,14,15,16,17,18,19,11}; int k,s,i; float ave; for(k=s=i=0;i<10;i++){ if(a[i]%2==0) continue; s+=a[i]; k++; } if(k!=0){ ave=(float)s/k; printf("%d, %f\n",k,ave); } }5, 15.000000
11. #include <string.h> void main(){ char arr[2][4]; strcpy(arr[0],"you"); strcpy(arr[1],"me"); arr[0][3]='&'; printf("%s\n",*arr); }you& me
12. void main ( ) { int i=0; char a[]="aqid", b[ ]="abm", c[10]; while (a[i]!='\0' && b[i]!='\0') { if (a[i]>=b[i]) c[i]=a[i]-32 ; else c[i]=b[i]-32 ; i++;} c[i]='\0'; puts(c); }AQM
13. #include<string.h> void main() {char *p1,*p2,str[50]=“ABCDEFG”; p1=“abcd”; p2=“efgh”; strcpy(str+1,p2+1); strcpy(str+3,p1+3); printf(“%s”,str); }Afgd
14. void main() { char s1[20]="abcd",s2[20]="ABCD"; char *p1=s1,*p2=s2; printf("%s\n",strcat(p1+2,p2+1)); }cdBCD
15. #include <stdio.h> #include <string.h> void main() { char s1[20]="abcd",s2[20]="ABCD", str[20]="xyz"; char *p1=s1,*p2=s2; strcat(p1,p2+1); strcpy(str+2,p1); printf("%s\n",str); }xyabcdBCD
三：填空題【4題】
1.已知字符’A’的ACSII碼值爲65，以下語句的輸出結果是：B_
char ch=’B’;
printf("%c\n",ch++);
2. 指針變量的類型用來指定_該指針變量可以指向的變量___的類型；
3. 有如下程序段
int *p,a=10,b=1;
p=&a; a=*p+b;
執行該程序段後，a的值爲：_11___；
4. 下面程序輸出結構體變量sz所佔存儲單元的字節數。
struct st {char name[20]; float score; } ;
main()
{ struct st sz;
printf("sz size: %d\n", sizeof(struct st/ sz ));
}
四：編程題目【5題】
1. 比較兩個字符串。（不要用strcmp） void main() {char s1[20],s2[20]; int i;int result; gets(s1); gets(s2); i=0; while( (s1[i]= =s2[i])&&(s1[i]!='\0') ) i++; result=s1[i]-s2[i]; printf("%d\n", result); }
2.有一個3×4的矩陣，要求編程序求出其中值 最大的那個元素的值，以及其所在的行號和列號。 void main() {int i,j,row=0,colum=0,max; int a[3][4]={{1,2,3,4},{9,8,7,6},{-10,10,-5,2}}; max=a[0][0]; for (i=0;i<=2;i++) for (j=0;j<=3;j++) if (a[i][j]>max) {max=a[i][j]; row=i; colum=j; } printf("max=%d,row=%d,colum=%d\n",max,row,colum); }3. 將字符數組s2中的全部字符拷貝到字符數組s1中。不要用strcpy #include <stdio.h> void main() {char s1[20],s2[20]; int i; gets(s2); i=0; while(s2[i]!='\0') {s1[i]=s2[i]; i++;} s1[i]='\0'; puts(s1); }
4. 將兩個字符串連接起來，不要用strcat。 void main() {char s1[20],s2[20]; int i;int j; gets(s1); gets(s2); i=0; while(s1[i]!=‘\0’) /*找到s1的尾 */ i++; j=0; while(s2[j]!=‘\0’) /*逐個拷貝相應字符 */ s1[i++]=s2[j++]; s1[i]='\0'; puts(s1); }5. 編寫一個程序, 輸入一個整形數組array，將該數組的最後一個元素移到第0個位置，其它元素後移一個位置。在main中將該數組輸出。不要定義輔助數組。 void main(){ int array[10]; int i,t; for(i=0;i<10;i++) scanf("%d",&array[i]); t=array[9]; for(i=9;i>0;i--) array[i]=array[i-1]; array[0]=t; for(i=0;i<10;i++) printf(" %d",array[i]); } }
答案
一、選擇題
1
2
3
4
5
6
7
8
9
10
C
D
C
A
B
D
B
A
A
B
11
12
13
14
15
16
17
18
19
20
B
A
D
A
C
C
二、寫出程序運行結果
1
2
3
4
5
6
7
8
4
56789
Hello
6
3
4,98
sum=300
13ff58
13ff70
13ff5c
9
10
11
12
13
14
15
1 3 4 5
5, 15.000000
you& me
AQM
Afgd
cdBCD
xyabcdBCD
三、填空題
1
2
3
4
B
該指針變量可以指向的變量
11
struct st/ sz
第5-7章(函數)練習題【32題】
一：選擇題【10題】
1.有下列程序，執行後由鍵盤鍵入2時，s的值爲： D
#define P (y*y+3*y) void main() {int s,y; scanf("%d",&y); s=3*P+4*P; printf("s=%d\n",s);}（A） 36 （B）40 （C）52 （D）70
2.在C程序中，main( )的位置： C
（A）必須作爲第一個函數 （B）必須作爲最後一個函數
（C）可以任意 （D）必須放在它所調用的函數之後
3. 以下敘述中正確的是： A
（A）構成C程序的基本單位是函數 （B） 可以在一個函數中定義另一個函數
（C） main()函數必須放在其它函數之前（D） 所有被調函數一定要在調用之前進行定義
4. 在宏定義 #define PI 3.14159中，用宏名PI代替一個 D
(A)單精度數 (B)雙精度數 (C)常量 (D) 字符串
5. C語言規定，函數返回值的類型是由 B
A) return語句中的表達式類型所決定 B) 由被調用函數的類型所決定
C) 由主調函數中的實參數據類型所決定 D) 由被調函數中的形參數據類型所決定
6. 調用函數時，實參是一個數組名，則向函數形參傳遞的是 C
A) 數組的長度 B) 數組每個元素的值
C) 數組的首地址 D) 數組中每個元素的地址
7.設有一函數 f(int b[ ]），在某一主調用函數中有f（a），其中a是一個整型數組且已賦值，則正確的敘述是： C
A) a數組與b數組各佔用不同的存儲空間。 B) 對b數組值的修改不影響a數組的值。
C) 對b數組元素值的修改實際上就是修改a數組。 D) 實參與形參的結合是雙向傳遞。
8. 以下正確的說法是：在C語言中， A
A) 實參變量和與其對應的形參變量各佔用獨立的存儲單元。
B) 實參變量和與其對應的形參變量共佔用同一個存儲單元。
C) 當實參變量和對應的形參變量同名時，才佔用相同的存儲單元。
D) 形參變量是虛擬的，不佔用存儲單元。
9.若已定義的函數有返回值，則以下關於該函數調用的敘述中錯誤的是 D
A）函數調用可以作爲獨立的語句存在 B）函數調用可以作爲一個函數的實參
C）函數調用可以出現在表達式中 D）函數調用可以作爲一個函數的形參
10.有以下函數定義：void fun(int n, double x) { …… } C
若以下選項中的變量都已正確定義並賦值，則對函數fun的正確調用語句是
A）fun(int y,double m); B）k=fun(10,12.5);
C）fun(x,n); D）void fun(n,x);
二：寫出程序運行結果【16題】
1. #define AA 100 void main( ) { printf("AA"); }
2. #define f(x) x*x void main() { int i; i = f(4+4) / f(2+2); printf("i=%d\n",i); }3. int f(int a, int b); void main() { int i=2,p; p=f(i,i+1); printf("%d",p); } int f(int a, int b) { int c; if(a>b) c = 1; else if(a = = b) c = 0; else c = -1; return(c); }
4.程序輸出的最後一個值是 void main() {int n = 2, m = 4; printf(“%d,”,fun(n, m)); printf(“%d”,fun(n, m)); } int fun(int a, int b) {static int n; int m = 0; n -= a+1; m += b-2; return (n+m); } int fun(int n) {static int f=1; f=f*n; return f; }5. void fun(int *a,int *b) {int k; k=*a; *a=*b; *b=k;} void main() {int a=10,b=20,*x=&a,*y=&b; fun(x,y); printf("%d,%d",a,b); }
6. void fun(int *a,int *b) {int *k; k=a; a=b; b=k; } void main() {int a=10,b=20,*x=&a,*y=&b; fun(x,y); printf("%d,%d",a,b); }7. void fun(int x,int y) {x=x+y;y=x-y;x=x-y; } void main() {int x=2,y=3; fun(x,y); printf("%d,%d\n",x,y); }
8. void fun(int x,int y,int z) {z=x*x+y*y+10;} void main() {int a=100; fun(2,3,a); printf("%d",a); }9. int fun(int n) {if(n == 1 || n == 2) return 2; return (n-fun(n-1));} vod main() {printf(“%d\n”, fun(5)); }
10. int a=3,b=5; int max(int a, int b) {int c; c=a>b?a:b; return c;} void fmain() {int a=8; printf("%d", max(a,b)); }11.設對應的可執行文件爲mm.exe 運行時輸入：mm 1 5 9 void main(int argc, char *argv[]) {int n=0,i; for(i=1;i<argc;i++) n=n*10+*argv[i]-'0'; printf("%d\n", n); }
12. void func1(int i); void func2(int i); char st[]="hello,friend!"; void func1(int i) { printf("%c",st[i]); if(i<3) {i+=2;func2(i);} } void func2(int i) { printf("%c",st[i]); if(i<3) {i+=2; func1(i); } } void main(){ int i=0; func1(i); printf("\n"); }13. int func (int a,int b) { static int m=1,i=2; i+=m+1; m=i+a+b; return (m); } void main ( ) { int k=4,m=1,p1,p2; p1=func(k,m) ; p2=func(k,m) ; printf("%d,%d\n",p1,p2) ; }
14. 數組a的首地址爲1000（十進制數），sizeof（int）的值爲4。 void main( ) { int i,j; int a[2][3]={2,6,10,14,18,20}; int *ptr[2]={a[0],a[1] }; for(i=0;i<2;i++) for(j=0;j<3;j++) a[i][j]=*(ptr[i]+j)/2+a[i][j]; printf(“%d\n”,ptr[1]+1); for(i=0;i<2;i++) printf(“%d\n”,*(ptr[i]+2)); }15. void fun(int s[ ]) { int i; for(i = 0; i < 10; i ++) printf(“%d”, s[i]); printf(“\n\n”); } void main(){ inta[3][4] = {{9,9,2,8},{3,4,5,4},{6,7,8,2}}; fun(a[0]); }
16. void fun(int s[ ]) { int i; for(i = 0; i < 8; i ++) printf(“%d”, s[i]); printf(“\n\n”); } void main(){ inta[3][4] = {{9,9,2,8},{3,4,5,4},{6,7,8,2}}; fun(a[1]); }
三：程序填空【6題】
1．寫一個判斷素數的函數。在主函數輸入一個整數，輸出是否素數的信息。 #include <math.h> int prime(int); void main() {int m,flag; scanf("%d", &m); flag=prime(m); if(flag==1) printf("%d is a prime ",m); else printf("%d is not a prime ",m); } int prime(int m){ int i,k,result; k=sqrt(m); for(i=2;i<=k;i++) if(m%i==0) break; if(i==k+1) result=1; else result=0; return result; }2.寫一個函數，將兩個字符串連接。 void str_connect(char[], char[]); void main( ) { char str1[20],str2[20]; gets(str1); gets(str2); str_connect(str1,str2); puts(str1); } void str_connect(char s1[], char s2[]) {int i;int j; i=0; while(s1[i]!='\0') i++; j=0; while(s2[j]!='\0') s1[i++]=s2[j++]; s1[i]='\0'; } 考慮在函數str_connect中通過指針形式如何實現？3.求10個學生成績的平均分,最高分和最低分。 float average(float array[], int n, float *pmax, float *pmin) { int i; float aver,sum=array[0]; *pmax= *pmin =array[0]; for(i=1;i<n;i++) { if(array[i]>*pmax) *pmax =array[i]; else if(array[i]<*pmin) *pmin =array[i]; sum=sum+array[i]; } aver=sum/n; return (aver); } void main( ) { float ave, score[10]={10, ,0,60,70,80, 20,30,40，90,100}; int i ; float max, min; ave=average(score,10,&max, &min); printf("……", max,min, ave); }4.有n個數，使前面各數順序向後移m個位置，最後m個數變成最前面m個數。 在main中輸入n個數和輸出調整後的n個數。(遞歸算法) void move(int array[],int n,int m); void main() {int number[20],n,m,i; scanf("%d", &n); scanf("%d",&m); for(i=0;i<n;i++) scanf("%d",&number[i]); move(number,n,m); for(i=0;i<n;i++) printf("%d ",number[i]); } void move(int array[ ],int n,int m) { int *p, array_end; array_end=*(array+n-1); for(p=array+n-1;p>array;p--) *p=*(p-1); *array=array_end;; m--; if(m>0) move(array,n,m); }5. 使用遞歸函數將一個整數各個位置上的數字順序輸出。例如，輸入整數54321，則應輸出5 4 3 2 1。 #include"stdio.h" void sequence (int n){ if(n>10) (7) ; printf(“%d ”, (8) ); } void main(){ int n; scanf(“%d”,&n); sequence(n); }6. 在二維字符數組中查找所有包含“abc”的字符串。 #include "string.h" void search(char *p, int n, int i) { int j=0; if(n<3) { printf(“s[%d]不包含abc”,i); return; } for(;j<n-2;j++) if( (9) ){ printf(“s[%d]包含abc”,i); break; } if(j==n-2) printf(“s[%d]不包含abc”,i); } void main( ){ int i; char s[3][10]={“abc”,”edabcd”,”ssoabd”}; for(i=0;i<3;i++) search( (10) ,strlen(s[i]),i); }
答案
一、選擇題
1
2
3
4
5
6
7
8
9
10
D
C
A
D
B
C
C
A
D
C
二、寫出程序運行結果
1
2
3
4
5
6
7
8
AA
28
-1
-1 -4
20,10
10,20
2,3
100
9
10
11
12
13
14
15
16
2
8
159
hlo
9,19
1016
15
30
9 9 2 8 3 4 5 4 6 7
3 4 5 4 6 7 8 2
第8-12章：預處理、結構體、共用體、位運算及文件操作
一：學習的瞭解的
函數 編譯預處理 指針 結構體與共用體 文件——PPT（有助於學習）
https://www.docin.com/p-2127413549.html
結構體、共用體、位運算及文件操作——PPT（有助於學習）
https://www.doc88.com/p-7754494142869.html
二：練題
南昌大學 c答案第8章以後 函數 預處理命令 結構體與共用體 文件——【選擇題】題有答案（有助於瞭解）
https://www.doc88.com/p-5475034873373.html
編譯預處理和動態存儲分配、結構體和共用體、文件(一)——【選擇題-操作題】有答案（有助於練題）
https://www.doc88.com/p-96116630010785.html
編譯預處理和動態存儲分配、結構體和共用體、文件(二)——【選擇題-操作題】有答案（有助於練題）
https://www.doc88.com/p-96116630010784.html
三：提升
預處理指針結構體與共用體測試題——題沒有答案（有助於提升）
https://www.docin.com/p-1730265292.html
第二部分：C語言概念題解答選編【200題】
一：單項選擇題【100題】
- 下列字符列中，不是C語言提供的合法關鍵字是
① switch ② begin ③ case ④ default
【解】因C語言的關鍵字表中沒有begin，它不是C語言的關鍵字。所以解答是②。
- 下列字符列中，不是用來表達轉義字符是
① \\ ② \’ ③ 074 ④ \0
【解】轉義字符有三種書寫形式：反斜槓字符後接上某個規定的字符；反斜槓字符後接上1至3個八進制數字符；反斜槓字符和字符x之後接上1至2個十六進制數字符。後兩種分別以八進制數和十六進制數直接給出字符的ASCII代碼值。而074是八進制整數，不是轉義字符。所以解答是③。
- 字符串 ″xyz″在內存佔用的字節數是
① 3 ② 4 ③ 6 ④ 8
【解】字符串中的每個字符佔1個字節，但C程序在存儲字符串時，要在最後一個有效字符後面接上1個字符串結束的標記符’\0’。這樣，存儲字符串常量″xyz″需要4個字節。所以解答是②。
- 設變量m，n，a，b，c，d均爲0，執行(m = a==b)||(n=c==d)後，m，n的值是
① 0，0 ② 0，1 ③ 1，0 ④ 1，1
【解】計算(m = a==b)||(n=c==d)的過程是先計算邏輯或的左運算分量(m = a==b)的值，由於賦值運算符的優先級比關係運算符==的優先級低，又先計算a==b。因a，b均爲0後，所以比較結果值爲1。將1賦給變量m，使變量m的值變爲1。同時這個賦值運算的結果也是1，這樣邏輯運算的左運算分量的值爲1。由於邏輯或運算的左運算分量值爲1，按照C語言對邏輯或運算優化計算的規定，不再計算邏輯或的右運算分量，而直接得到邏輯或運算的結果爲1。由於邏輯或的右運算分量不曾計算過，所以變量n的值也不爲變化。這樣，上述表達式計算後，變量m 的值爲1，變量n的值爲0。所以解答是③。
- 設整型變量m，n，a，b，c，d均爲1，執行“(m=a>b)&&(n=a>b)”後，m，n的值是
① 0，0 ② 0，1 ③ 1，0 ④ 1，1
【解】表達式(m=a>b)&&(n=a>b)是一個邏輯表達式，它的計算過程是先計算邏輯與的左分量(m=a>b)，其中又是先計算a>b。因a>b不成立，結果爲0，將0賦給變量m，最後邏輯與的左分量結果爲0。由於邏輯運算採用特別的優化計算規則，當邏輯與的左分量結果爲0時，不再計算邏輯與的右分量，而直接以0爲邏輯與的結果。所以，上述表達式計算使m的值變爲0，而n的值沒有變，依舊爲1。所以解答是②。
- 設有語句“int a=3;”，則執行了語句“a + = a - = a*a；”後，變量a的值是
① 3 ② 0 ③ 9 ④ -12
【解】由於賦值運算符的結合性自右至左，語句“a + = a - = a*a；”的執行是先計算a*a，得到值9，再計算a - = a*a，使a 的值爲-6，接着計算a += a，使a 的值爲-12。所以解答是④。
- 在以下一組運算符中，優先級最高的運算符是
① <= ② = ③ % ④ &&
【解】常規運算符的優先級自高到低的排列順序是算術運算符、移位運算符、關係運算符、按位運算符、邏輯運算符、條件運算符、賦值運算符、逗號運算符。所以問題所給的四個運算符按優先級自高到低的排列順序是%，<=，&&，=。所以解答是③。
- 若已定義x和y爲double類型，則表達式：x=1, y = x+3/2的結果是
① 1 ② 2 ③ 2.0 ④ 2.5
【解】由於變量x和y都是double類型，表達式x=1, y = x+3/2是先計算x=1，由於1是整型的，x是double類型的，該計算先將整數1轉換成double類型的1.0L，並將1.0L賦給變量x。計算y = x+3/2是先求3/2的值，因是兩整數相除，結果是整型值1，然後在計算x+1時，也先將1轉換成1.0L，然後求得x+1的值爲2.0L，最後將該值賦給變量y，並得到整個表達式的值爲2.0L，簡寫成2.0。所以解答是③。
- 設a=1，b=2，c=3，d=4，則表達式a < b ? a : c < d ? a : d的結果爲
① 4 ② 3 ③ 2 ④ 1
【解】條件運算符的優先級比關係運算符的優先級低，並且它的結合性是自右向左的，所以表達式a < b ? a : c < d ? a : d可用圓括號等價地寫成(a < b) ? a : ((c < d) ? a : d)。因a<b成立，計算結果爲a的值1。所以解答是④。
- 設a爲整型變量，下列C表達式中，不能表達數學關係式：10<a<15的是
① 10<a<15 ② a == 11 || a == 12 || a == 13 || a == 14
③ a>10&&a<15 ④ !(a<=10)&&!(a>=15)
【解】數學關係式10<a<15表示a只能是11，12，13，14四個值之1。用C表達式表示這個條件，可寫成a >10&& a < 15，或!(a<=10)&&!(a>=15)，或a == 11 || a == 12 || a == 13 || a == 14等。若寫成10<a<15，該算式的計算順序是先求出10<a的結果0或1，然後以這個結果與15比較，是否小於15，顯然這與數學式子的意義是不一致的。所以解答是①。
- 若有以下定義：char a; int b; float c; double d;則表達式a*b+d-c值的類型爲
① float ② int ③ char ④ double
【解】基本類型的數據可以混合運算，但運算時，對要求運算分量類型相同的運算來說，如運算分量的類型不是全相同，則會有自動類型轉換髮生。類型自動轉換規則規定類型低（簡單）的向類型高（複雜）的轉換。各類型由高到低的排列順序是：
long double 、double、float、unsigned long、long、unsigned int、int。
這樣，若有定義：char a; int b; float c; double d;則表達式a*b+d-c的值的類型是double的。首先計算a*b，得到int類型的值，接着計算a*b+d，得到double類型的值，最後計算a*b+d-c，得到double類型的值。所以解答是④。
- 表達式“9！= 7”的值是
- true ② 非0值 ③ 0 ④ 1
【解】關係運算的結果只有0和1，若關係成立，則結果爲1；若關係不成立，則結果爲0。因關係式9！= 7成立，所以表達式的結果爲1。雖然1也是非0值，在供選擇的答案中有1，所以最確切的解答是④。
- 用十進制數表示表達式“12 | 012”的運算結果是
① 1 ② 0 ③ 14 ④ 16
【解】按位運算將運算分量視作二進位的位串信息，對兩運算分量的對應位進行運算，產生二進位的位串信息結果。整數12最低8位二進位是00001100，整數012是八進制數，它的最低8位二進位是00001010。這兩個二進位位串信息按位或運算，得到結果是00001110，對應十進制數14，八進制數是016。所以解答是③。
- 設字符型變量a=3，b=6，計算表達式c = (a^b)<<2後c 的二進制值是
① 00011100 ② 00000111 ③ 00000001 ④ 00010100
【解】a的值爲3，寫成8位二進制數形式是00000011，b的值爲6，寫成8位二進制數形式是00000110。表達式c = (a^b)<<2，先計算a與b的按位加，得到結果00000101，將這結果向左移2位，得到二進位的位串信息是00010100。所以解答是④。
．設ch是char型變量，其值爲’A’，則下面表達式的值是
ch = (ch>=’A’&&ch<=’Z’)?(ch-‘A’+’a’):ch
① A ② a ③ Z ④ z
【解】由於字符型變量ch的值爲’A’，計算表達式ch = (ch>=’A’&&ch<=’Z’)?(ch+32):ch，先計算其中條件表達式，由於條件(ch>=’A’&&ch<=’Z’)成立，該條件表達式以ch+32=97爲結果，將該值賦給變量ch，以字符表達這個值爲’a’。 所以解答是②。
28．設a=3，b=4，執行“printf(“%d, %d”, (a, b), (b, a));”的輸出是
- 3，4 ② 4，3 ③ 3，3 ④ 4，4
【解】在調用格式輸出函數的語句中，其中每個格式符對應一個輸出項，格式符d要求輸出項內容以十進制整數形式輸出。語句中的第一個格式符對應輸出項(a, b)是一個逗號表達式，該表達式的值是b 的值，所以先輸出4。接着輸出字符逗號。同樣輸出項(b,a)的值是a的值，輸出3。所以語句執行將輸出4, 3。正解的選擇是②。
32．設有int i=010, j=10；則執行“printf(“%d, %d\n”, ++i, j--)；”的輸出是
① 11，10 ② 9，10 ③ 010，9 ④ 10，9
【解】變量i和j的初值分別爲八進制數010和十進制數10，格式輸出函數調用printf(“%d, %d\n”, ++i, j--)中，++i的值是變量i增1後的值，原來值是八進制數010，等於十進制數8，輸出9。j--的值是變量j減1之前的值，輸出10。格式字符串中的逗號是普通字符照原樣輸出。所以問題給出的格式輸出函數調用將輸出9,10。正確的解答是②
- 假定所有變量均已正確定義，下列程序段運行後x的值是
a = b = c = 0; x = 35;
if(!a)x--;else if(b);if(c)x = 3;else x = 4;
① 34 ② 4 ③ 35 ④ 3
【解】以變量a，b，c的值均爲0，變量x的值爲35，語句：
if(!a)x--;else if(b);if(c)x = 3;else x = 4;
由兩個if語句組成。首先執行前一個if語句“if(!a)x--;else if(b)；”，因變量a的值爲0，條件!a成立，執行x--使x的值變爲34。接着執行後繼的if語句“if(c)x = 3;else x = 4;”，因變量c的值爲0，條件不成立而執行x = 4，最終使變量x的值爲4。正確解答是②。注意前一個if語句的else部分的成分語句只有“if(b)；”，這是一個單分支if語句，且其成分語句爲空語句。
下面的程序段所表示的數學函數關係是
y = -1;
if(x!=0) if(x>0) y = 1; else y = 0;
-1 (x<0) 1 (x < 0) 0 (x<0) -1 (x<0)
① y = 0 (x=0) ② y = -1 (x = 0) ③ y = -1 (x = 0) ④ y = 1 (x = 0)
1 (x>0) 0 (x > 0) 1 (x > 0) 0 (x > 0)
【解】程序段首先置變量y的值爲-1，接着按變量x值的不同情況重置變量y的值。重置的首要條件是x!=0，若變量x的值爲0，則不再重置變量y的值，所以在x值爲0情況下，y的值是-1。在變量x的值不等於0的條下，若x的值大於0，重置變量y的值爲1；若變量x的值小於0，重置變量y的值爲0。所以程序段實現當變量x的值爲0時，變量y的值爲-1；當變量x的值大於0時，置變量y的值爲1；當變量x的值小於0時，置變量y的值爲0。正確解答爲③。
38．執行下列程序段
x = 9;
while (x > 7)
{ printf(“*”); x--; }
後輸出的結果是
① **** ② *** ③ ** ④ *
【解】上述代碼以x的初值爲9，在x>7成立的情況下循環，每次循環輸出一個*字符，並讓x的值減1。共執行2次循環，也就共輸出了2個*字符。所以解答爲③。
- 下列語句中，錯誤的是
- while (x=y)5; ② do x++ while(x==10);
③ while(0); ④ do 2; while (a==b);
【解】while語句的一般形式是：
while(表達式)語句
這裏的表達式可以是任何合理的表達式，語句可以是任何語句，包括空語句，或表達式語句。可能書寫的while語句沒有任何意義，如供選擇的①while(x=y)5;和③while(0);但這兩個語句的句法沒有任何錯誤。do-while語句的一般形式是：
do 語句while (表達式)；
其中的成分語句也可以是任何語句，但供選擇答案②dox++while(x==10);中的代碼x++是一個表達式，不是語句，所以是錯誤的。正確解答是②。
- 循環語句“for（x=0, y=0; (y!=123) || (x < 4); x++）;”的循環執行
- 無限次 ② 不確定次 ③ 4次 ④ 3次
【解】for循環語句的初始化部分置變量x和y的初值爲0，循環條件是(y!=123) || (x < 4)，每次循環後變量x的值增1。由於循環過程中變量y的值未被修改過，循環條件又是一個邏輯或，其左分量(y!=123)永遠成立，也就是循環條件永遠成立。所以該循環語句將循環執行無限次。正確解答是①。
41．若i、j已定義爲int類型，則以下程序段中的內循環體的執行次數是○。
for(i = 5; i; i--)
for(j = 0; j < 4; j++) { …… }
- 20 ② 24 ③ 25 ④ 30
【解】問題所給的程序段的外循環是一個for循環語句，它的初始化部分置變量i的初值爲5，循環條件簡寫成i，即i!=0，每次循環後變量i的值減1。所以外循環共控制5次循環。內循環也是一個for循環語句，它的初始化部分置變量j的初值爲0，循環條件是j<4，每次循環後變量j的值增1。所以內循環共控制4次循環。這樣，如內循環的體內未曾對變量i和j有修改，在內、外循環一起控制下，內循環的體共被重複執行20次。正確解答是①。
42．假定a和b爲int型變量，則執行以下語句後b的值爲
a = 1; b = 10;
do { b -= a; a++;
} while (b-- < 0);
① 9 ② -2 ③ -1 ④ 8
【解】在這個程序段中，循環開始前變量a 的值爲1，b的值爲10，每次循環從變量b減去a，並讓a增1，並在循環條件判定時，又讓b減去1。第一次循環後，變量b的值變成9，變量a 的值變爲2，循環判斷時，因b的值大於0，循環條件不成立，結束循環。但在循環判斷時，讓b減去了1，所以循環結束時，變量b的值爲8。正確的解答是④。
- 設x和y爲int型變量，則執行下面的循環後，y的值爲
for(y=1, x=1; y <=50; y++) {
if(x >= 10) break;
if(x%2 == 1) { x += 5; continue;}
x -= 3;
}
① 2 ② 4 ③ 6 ④ 8
【解】for循環語句的初始化部分置變量x和y的初值爲1，循環條件是(y<=50)，每次循環後變量y的值增1，控制循環最多執行50次。循環體有三個語句：首先在發現變量x的值大於等於10時，結束循環；接着是當變量x除2的餘數爲1（即變量x是奇數）時，讓變量x值增5，讓x變成偶數，並直接進入下一輪循環；如變量x是偶數，則從變量x減去3，讓變量x變成奇數。由上述分析知，每兩次循環使變量x的值增加2。第一次循環後，變量x的值變成6。第二次循環後，變量x的值變成3。第三次循環後，變量x的值變成8。第四次循環後，變量x的值變成5。第五次循環後，變量x的值變成10。第六次循環時，因變量x的值大於等於10，直接跳出循環，這次循環是非正常結束，對變量y的修正只執行了5次。所以循環結束後，變量y的值增至6。正確的解答是③。
- 在C語言中，下列說法中正確的是
- 編程時儘量不要使用“do 語句 while（條件）”的循環
② “do 語句 while（條件）”的循環中必須使用“break”語句退出循環
③ “do 語句 while（條件）”的循環中，當條件非0時將結束循環
④ “do 語句 while（條件）”的循環中，當條件爲0時將結束循環
【解】do-while語句的一般形式是：
do 語句
while (表達式)；
其語義是重複執行其成分語句，直至表示條件的表達式值爲0時結束。do-while語句是正常使用的一種循環結構之一。do-while語句的循環結束條件由while 後的表達式值爲0所控制，並不一定要有break語句跳出循環來結束循環。do-while語句在條件值非0時，將繼續循環，而不是結束循環。條件值爲0時，才結束循環。所以正確的選擇是④。
- 若有下列說明，則數值爲4的表達式是
int a[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
char c = ‘a’, d, g;
- a[g-c] ② a[4] ③ a[‘d’-‘c’] ④ a[‘d’-c]
【解】數組元素的下標自0開始順序編號，值爲4的元素是a[3]。所以只有下標表達式的值爲3纔是正確的。下標表達式g-c中的的變量g和c的值是還未被設定的，其值不確定。a[4]的值爲5，下標爲4是不對的。’d’-‘c’的值爲1，a[1]的值是2，所以也是不對的。變量c的值爲’a’，’d’-c=3，所以正確解答是④。
- 設有定義：“char s[12]={“string”};”，則printf(“%d\n”, strlen(s));的輸出是
- 6 ② 7 ③ 11 ④ 12
【解】在C語言中，字符串是指在有效字符之後有字符串結束標記符的字符列，並約定字符串的長度是指字符串中有效字符個數，不包括字符串的結束標記符。存於字符數組s中的字符串是”string”，該字符串的長度爲6，所以輸出該字符串的長度應是6。正確的解答是①。
- 下列C代碼中，正確的是
- char a[3][ ] = {‘abc’, ‘1’}; ② char a[ ][3] = {‘abc’, ‘1’};
③ char a[3][ ] = {‘a’, “1”}; ④ char a[ ][3] = {“a”, “1”};
【解】如定義數組時有初始化，其最高維的長度可以省缺，由系統根據初始化時的初值個數確定，而其它維的長度是不可以缺省的。對兩維字符數組的初始化，可以按行用字符串對其初始化，也可以按兩維數組元素的存儲順序逐一用字符對其元素初始化。在供選擇解答①和③中，有不是最高維的長度被缺省，所以是錯誤的。在供選擇解答①和②中，還將字符串常量寫作’abc’，這也是錯誤的。只有④，用字符串按行給兩維字符數組初始化，這纔是正確的。正確的解答是④。
50．字符串”m\x43\\\np\102q”的長度是
① 7 ② 9 ③ 15 ④ 16
【解】字符串的長度是指字符串中有效字符的個數。在C程序中，組成字符串的字符可以是一般的普通字符，也可以是轉義字符。其中轉義字符又可以用多種不同形式來表達：反斜槓字符之後接上預先規定的字符，用來表示特殊字符或特定意義的控制字符。如單引號字符、雙引號字符、反斜槓字符等特殊字符，換行、回車、退格等控制字符。反斜槓字符之後接上1至3位八進制數字符，這是直接用八進制數字表示字符的ASCII代碼的方式。反斜槓字符之後接上字符x，並後接1至2個十六進制數字符，這是直接用十六進制數字表示字符的ASCII代碼的方式。後二種能表示C語言允許的任何字符。在本小題給出的字符串中，字符’\x43’是用十六進制數表示的一個字符，字符’\\’表示一個反斜槓字符，字符’\n’表示一個換行字符，字符’\102’是用八進制數表示的一個字符。這樣，所給字符串只有7個有效字符。所以，該字符串的長度是7，解答爲①。
55．設char str1[10] = “ABCDE”, str2[10] = “xyz”;
則執行語句 printf(“%d”, strlen(strcpy(str1, str2))); 後的輸出結果是
① 9 ② 8 ③ 5 ④ 3
【解】上述代碼是輸出表達式strlen(strcpy(str1, str2))的值，該表達式的求值 順序是先執行函數調用strcpy(str1, str2)，該函數調用將str2 所指字符串內容複製到str1所指的字符數組中，並返回存放於str1中的字符串的首字符的指針。經函數調用strcpy(str1, str2)後，str1中的內容變成字符串“xyz”。接着求更新成字符串“xyz”的str1中的字符串的長度，並輸出。這樣，代碼將輸出整數3。所以解答爲④。
58．在C語言中，下列說法中，錯誤的敘述是
- 函數定義可以分爲兩個部分：函數說明部分和函數體
- 主函數可以調用任何非主函數
- 任何非主函數可以調用其它任何非主函數
- 程序可以從任何函數開始執行
【解】每個C函數的定義分兩部分，函數說明部分和函數體，所以敘述①是正確的敘述。在C語言中，函數可以遞歸調用，主函數可以調用程序中的任何函數，當然可以調用任何非主函數的其它函數，所以敘述②是一個正確的敘述。同樣理由，敘述③也是正確的。C語言規定，C程序只有一個主函數，並總是從主函數開始執行，不能從非主函數開始執行。所以，說程序可以從任何函數開始執行是錯誤的。所以解答是④。
60．執行下列程序
int fun(int x1, int x2)
{ int x;
x1 > x2 ? (x = 3) : (x = 4);
return x + x1;
}
main()
{ printf(“%d\n”, fun(7, 8));
}
後輸出結果是
① 9 ② 10 ③ 11 ④ 12
【解】上述程序中，主函數以實際參數7和8調用函數fun，並輸出函數的返回值。函數fun被調用時，形式參數x1的初值是7，x2的初值是8。函數執行表達式語句
x1 > x2 ? (x = 3) : (x = 4)
這是一個條件表達式，因條件x1 > x2不成立，條件表達式求(x = 4)，該表達式的求值使函數的局部變量x的值爲4。最後，函數返回x + x1的值11。所以解答爲③。
- 若有說明語句“int a[10], *p = a;”，對數組元素的正確引用是
① a[p] ② p[a] ③ *(p+2) ④ p+2
【解】在C語言中，約定數組名單獨出現在表達式中時，它表示數組首元素的指針。有int a[10]，則a可以作爲&a[0]使用。另有整型指針變量p，代碼p=a實現p指向數組a的首元素。則表達式*(p+2)是引用數組元素a[2]。表達式a[p]和p[a]都是不正確的，下標必須是整型表達式，不可以是指針表達式。表達式p+2是指針表達式，它的值是&p[2]。所以只有表達式*(p+2)引用數組a的元素a[2]。所以解答是③。
- 下面各語句中，能正確進行賦字符串操作的語句是
① char s[5] = {“ABCDE”}; ② char s[5] = {‘A’,’B’,’C’,’D’,’E’};
③ char *s; s = “ABCDE”; ④ char *s; scanf(“%s”, s);
【解】字符串最終存儲於字符數組中，存儲字符串的字符數組可以是程序主動引入的（定義或動態分配），也可以是由系統分配的。其中字符數組用字符串常量初始化就是字符串存儲於由程序引入的字符數組的例子。給字符指針賦字符串則是系統自動分配字符串存儲空間的例子。給字符指針賦字符串常量並不是將一個長長的字符串常量存於字符指針變量中，而是將字符串常量存儲於常量區，並將存儲這個字符串常量的首字節地址賦給指針變量，讓指針變量指向字符串常量的首字符。對於以字符串常量作爲字符數組初值的情況，要求字符數組足夠的大，能存得下字符串常量。這裏有一個特別的規定，若數組的大小少於存儲字符串有效字符的字節個數，系統將報告錯誤；當字符數組的大小隻能存儲字符串的有效字符，而不能存儲字符串結束標記符時，則存儲於字符數組中的內容是字符序列，因沒有存儲字符串結束標記符，存儲的內容就不是字符串。如代碼char a[5] = “ABCDE”。另外，給字符數組元素逐一賦字符初值，並在字符初值中沒有字符串結束標記符，則存於字符數組中的內容也不是字符串。如代碼char s[5] = {‘A’,’B’, ‘C’, ‘D’, ‘E’}。特別要注意當字符指針還未指向某個字符數組的元素時，不可以通過字符指針輸入字符串。如代碼char *s; scanf(“%s”, s)。若寫成char *str; scanf(“%s”, &str)更是錯誤的了。由於C語言規定數組不能相互賦值，所以只能將字符串常量賦給某字符指針。如代碼char *s; s = “ABCDE”是正確的。實際上，字符串”ABCDE”被存儲於常量區中，向指針變量賦的是字符指針，讓s指向其中的字符’A’。 所以解答是③。
- 若有以下定義，則數值爲4的表達式○。
int w[3][4] = {{0, 1}, {2, 4}, {5, 8}}, (*p)[4] = w;
① *w[1]+1 ② p++, *(p+1) ③ w[2][2] ④ p[1][1]
【解】兩維數組定義有多種賦初值的辦法，問題給出的代碼是按行給數組的部分元素賦初值。它們分別是w[0][0] = 0、w[0][1]=1、w[1][0]=2、w[1][1] = 4、w[2][0]=5、w[2][1]=8。根據約定，未指定初值的元素自動置全0值。指針變量p是一個指向具有四個int型元素的一維數組的指針，定義時的初值使它指向數組w的第一行。①的代碼，*w[1]+1中的w[1]是指向w[1][0]的指針，*w[1]就是w[1][0]，其值是2，*w[1]+1的值是3。②的代碼是逗號表達式，“p++，*(p+1)”先使p指向數組w的第二行，*(p+1)中的p+1是指向數組w的第三行，*(p+1)是指針值，指向數組w的第三行的第一個元素，即&w[2][0]。③的代碼w[2][2]引用數組w第三行的第三列元素，其值是0。④的代碼p[1][1]引用數組w第二行的第二列元素w[1][1]，其值是4。所以解答是④。
- 若有下面的程序片段，則對數組元素的錯誤引用是○。
int a[12] = {0}, *p[3], **pp, i;
for(i = 0; i < 3; i++) p[i] = &a[i+4];
pp = p;
① pp[0][1] ② a[10] ③ p[3][1] ④ *(*(p+2)+2)
【解】上述代碼定義變量a是有12個整型元素的數組，它的初值全是0。p是有3個元素的指針數組，每個指針能指向整型變量。pp是指針的指針，它能指向一個指向整型變量的指針，i是一個整型變量。執行代碼for(i = 0; i < 3; i++) p[i] = &a[i*4]使指針數組p的元素p[0]指向a[4]，p[1]指向a[5]，p[2]指向a[6]。代碼pp = p使指針變量pp指向p[0]。①，代碼pp[0][1]用指針表達可等價地寫成*(*pp+1)。其中*pp就是p[0]，p[0]的值是&a[4]，*pp+1的值是&a[4]+1 = &a[5]，*(*pp+1)就是a[5]。②，代碼a[10]當然是引用數組a的元素。③，代碼p[3][1]因數組p只有三個元素，沒有p[3]，所以是錯誤的。④，代碼*(*(p+2)+2)中的(p+2)是&p[2]，*(p+2)是p[2]，其值是&a[6]，*(p+2)+2的值是&a[8]，*(*(p+2)+2)引用的是a[8]。所以解答是③。
- 若有如下定義和語句，則輸出結果是○。
int **pp, *p, a = 10, b = 20;
pp = &p; p = &a; p = &b; printf(“%d, %d\n”, *p, **pp);
① 10, 20 ② 10, 10 ③ 20, 10 ④ 20, 20
【解】上述代碼定義變量pp是指針的指針，它能指向一個指向整型變量的指針。定義變量p是指針，它能指向一個整型變量。a是一個整型變量，它有初值10。b也是一個整型變量，它有初值20。代碼pp=&p使pp指向p，p = &a使p指向a，p = &b又使p指向b，不再指向a。所以*p是引用b，其值爲20。**pp是通過pp間接引用p，再通過p間接引用b，所以也是20。所以解答是④。
- 若有以下定義和語句，則對w數組元素的非法引用是○。
int w[2][3], (*pw)[3]; pw = w;
① *(w[0]+2) ② *pw[2] ③ pw[0][0] ④ *(pw[1]+2)
【解】上述代碼定義2行3列的兩維數組w，定義能指向有三個整型元素一維數組的指針pw，並讓pw指向數組w的第一行。①，代碼*(w[0]+2)中的w[0]是&w[0][0]，w[0]+2是&w[0][2]，所以，*(w[0]+2)就是w[0][2]。②，代碼*pw[2]中的pw[2]是&w[2][0]，該數組w只有2行，沒有w[2][0]，所以代碼*pw[2]是對數組w元素的非法引用。③，代碼pw[0][0]就是w[0][0]。④，代碼*(pw[1]+2) 中的pw[1]就是*(pw+1)，即&w[1][0]，pw[1]+2就是&w[1][2]，所以，*(pw[1]+2)就是w[1][2]。所以解答是②。
72．函數調用語句“f((e1, e2), (e3, e4, e5))；”中參數的個數是○。
① 1 ② 2 ③ 4 ④ 5
【解】上述函數調用中，(e1, e2)和(e3, e4, e5)是兩個帶括號的表達式，所以函數調用只提供兩個實參，其中第一個實參先計算e1的值，然後計算e2，並以e2的值爲實參。第二個實參順序計算e3，e4，e5，並以e5的值爲實參。所以解答是②。
73．C語言中，函數的隱含存儲類型是○。
① auto ② static ③ extern ④ 無存儲類別
【解】由於C函數內不能再定義函數，C函數的存儲類型只能是靜態的或外部的之一。若定義函數時不指定存儲類型是靜態的，則它的存儲類型就是外部的（extern），即函數允許被程序的其它函數調用。所以解答是③。
74．以下對C語言函數的有關描述中，正確的是○。
- 在C語言中，調用函數時，只能把實參的值傳遞給形參，形參的值不能傳遞給實參
- C函數既可以嵌套定義，又可以遞歸調用
- 函數必須有返回值，否則不能使用函數
④ C程序中，有調用關係的所有函數必須放在同一個源程序文件中
【解】C語言規定，調用函數時，只能把實參的值傳遞給函數的形參。函數調用時，形參從實參表達式得到初值，形參也是函數的一種局部變量，其值可以改變，但形參的值不能傳回給對應的實參。當函數設置非指針類型的形參時，實參可以是同類型的一般表達式；當函數設置指針類型的形參時，對應的實參也必須是同類型的指針表達式。所以敘述①是正確的。C函數雖可以遞歸調用，但同時規定，在函數內不能再定義函數，所以敘述②是錯誤的。通常C函數會有返回值，但也可以沒有返回值，有許多情況，函數的執行是完成某種預定的工作，並沒有返回值，所以敘述③是不正確的。在C程序中，如函數未指定是靜態的，則就是外部的，能讓別的文件中的函數調用，但函數要調用別的文件中的函數，在調用代碼之前，需對它作說明，所以敘述④也是不正確的。正確的解答只有①。
75．設函數的功能是交換x和y的值，且通過正確調用返回交換結果。不能正確執行此功能的函數是○。
- funa(int *x, int *y)
{ int *p;
*p = *x; *x = *y; *y = *p;
}
② funb(int x, int y)
{ int t;
t = x; x = y; y = t;
}
③ func(int *x, int *y)
{ int p;
p = *x; *x = *y; *y = p;
}
④ fund(int *x, int *y)
{ int *p;
*x = *x + *y; *y = *x - *y; *x = *x - *y;
}
【解】設計實現交換兩個變量值的函數。希望函數調用能改變調用環境中的變量，方法之一是讓函數設置指針類型的形參，實參傳送給形參的是希望交換值的兩個變量的指針。函數的兩個形參得到這兩個變量的指針後，函數就能通過形參間接引用要交換值的變量，或引用它們的值，或改變它們的值。從而實現從函數傳回信息存於調用環境的變量中。以上所述是設計交換變量值函數的一般原則，具體編寫函數時還需注意對上述原則的正確應用。
對於函數funa，該函數的定義滿足設置指針形參，並通過指針形參間接引用環境變量的要求。但是在函數體中定義了指針變量p，並在p未明確設定它所指向的變量下，代碼*p = *x企圖將值存入它所指的變量中，這是初學者經常出現的一種嚴重的錯誤。該函數因有錯，不能實現交換變量值的功能。
對於函數funb，該函數不定義指針形參，函數體也沒有可用的指針間接引用調用環境中的變量，所以該函數也不能實現交換變量值的功能。
對於函數func，該函數正確定義了指針形參，函數體也正確通過指針形參間接引用環境中的變量，並正確定義了自已的局部變量。該函數能實現交換變量值的功能。
對於函數fund，該函數也正確定義指針形參和函數體通過形參間接引用環境變量。特別要指出的是，該函數是利用*x和*y的舊值與新值之間的關係實現問題要求的。其中第一個賦值使*x存有原來未交換之前的*x與*y之和；第二個賦值從這個和中減去原來的*y，並將差賦給*y，使*y的值是交換之前的*x的值；第三個賦值再次從和中減去新的*y，即減去交換之前的*x，這個差就是交換之前的*y，並將差賦給*x。經以上三個賦值，實現兩變量之間的值交換。所以不能正確執行交換變量值的函數是funa和funb，即正確選擇是①和②。
- 要求函數的功能是在一維數組a中查找x值。若找到，則返回所在的下標值；否則，返回0。設數據放在數組元素的a[1]到a[n]中。在以下給出的函數中，不能正確執行此功能的函數是○。
① funa(int *a, int n, int x)
{ *a = x;
while(a[n] != x) n--;
return n;
}
② funb(int *a, int n, int x)
{ int k;
for(k = 1; k <= n; k++)
if(a[k] == x) return k;
return 0;
}
③ func(int a[], int n, int x)
{ int *k;
a[0] = x; k = a+n;
while(*k != x) k--;
return k – n;
}
④ fund(int a[], int n, int x)
{ int k = 0;
do k++;
while((k < n+1)&&(a[k]!=x));
if((k < n+1)&&a[k] == x)) return k;
else return 0;
}
【解】在數組中找指定值是經常遇到的計算要求，有多種編程方法。在這裏，數據預放在數組下標1至n的元素中，下標爲0的元素沒有放數據，程序可以利用這個位置簡化查找函數。函數funa先將要查找的值放入a[0]，從數據表的最後一個元素開始逆序向前查找。這樣做的好處是循環條件不必擔心因數組中原先沒有值爲x的元素而一直向前，訪問不是數表的元素，需插入條件n>0。在a[0]處放入x後，這個條件就不必要了，循環至少在訪問了a[0]後終止，並返回0值。所以該函數能完成指定的功能。函數funb採用常規的辦法編寫，循環在a[1]與a[n]之間順序尋找，一旦找到立即返回找到處的下標，直至查找循環結束，查不到指定的值時，返回0值。函數func採用與函數funa相同的方法，不過是另引入一個指針變量。但是該函數return語句後的表達式有嚴重的錯誤，應返回k-a，兩指針的差是一個整數，在這裏是找到元素的下標。表達式k-n是指針k向前移n個位置的指針值。函數fund預置k爲0，循環讓k增1，並在k在界內和a[k]不等於x的情況下繼續循環。循環結束有兩種情況，或k已不在界內，或k在界內，並且a[k]等於x。若是後者，函數返回k，而若前者，函數返回0。該函數也能正確完成查找工作。這樣，不能正確完成查找工作的函數是函數func。所以正確的選擇是③。
- 以下程序的輸出結果是○。
#include <stdio.h>
sub1(char a, char b){ char c; c = a; a = b; b = c;}
sub2(char *a, char b){ char c; c = *a; *a = b; b = c;}
sub3(char *a, char *b){ char c; c = *a; *a = *b; *b = c;}
main()
{ char a, b;
a = ‘A’; b = ‘B’; sub3(&a, &b); putchar(a); putchar(b);
a = ‘A’; b = ‘B’; sub2(&a, b); putchar(a); putchar(b);
a = ‘A’; b = ‘B’; sub1(a, b); putchar(a); putchar(b);
}
① BABBAB ② ABBBBA ③ BABABA ④ BAABBA
【解】在上述程序中，函數sub1完成兩形參值的交換，與實參提供的變量無關，這是一個沒有意義的函數。函數sub2將第二個形參的值置入由第一個指針形參所指的變量中，指針形參所指的變量由調用時的實參提供。函數sub3完成將兩個形參所指的變量的值交換的工作。程序調用sub3，使變量a和b的值交換輸出BA；調用sub2，使變量b的值傳送到a，輸出BB；調用sub1，變量a和b的值不改變，輸出AB。所以程序輸出BABBAB。正確解答是①。
- 設有定義語句“int (*ptr)[10];”，其中的ptr是
- 10個指向整型變量的指針
- 指向10個整型變量的函數指針
③ 一個指向具有10個元素的一維數組的指針
④ 具有10個指針元素的一維數組
【解】代碼“int (*ptr)[10];”的分析過程是，因圓括號，括號內的ptr先與字符*結合，字符*修飾標識符ptr，使它是一種指針；接着與後面的一對方括號結合，表示是這樣一種指針，是指向一維數組的；再有方括號中的10，說明這種數組有10個元素。至此，ptr是指向含10個元素的一維數組的指針。最後，是最前面的int，表示數組元素是int類型的。所以，ptr是一個指向具有10個int型元素的一維數組的指針。所以解答是③。另外，要是①，10個指向整型變量的指針，就是一個指針數組，上述代碼應寫成“int *ptr[10];”，即ptr是一個有10個指向整型變量的數組。 要是②，返回值是指向10個整型變量的函數的指針，上述代碼應寫成“int (*(*ptr)())[10];”，即ptr是指針，指向一種函數，函數的返回值又是一種指針，指向10個元素的數組，數組的元素是整型的。下面的代碼是這樣的函數指針和函數的例子：
#include <stdio.h>
int a[][10] = {{1,2,3,4,5,6,7,8,9,0},{0,1,2,3,4,5,6,7,8,9}};
int (*(*ptr)(int))[10];
int (*f(int n))[10]
{ return a+n;
}
void main()
{ int (*p)[10], *q;
ptr = f; /* 讓ptr指向函數f */
p = ptr(0); q = *p; printf("%d\n", *q);
p = ptr(1); q = *p; printf("%d\n", *q);
}
在上述代碼中，函數有一個int型的形參。要是④，其意義與①相同，上述代碼應寫成“int *ptr[10];” ，即ptr是一個有10個元素的數組，數組元素是指向整型變量的指針。
79．計算平方數時，不可能引起二義性的宏定義是
① #define SQR(x) x*x ② #define SQR(x) (x)*(x)
③ #define SQR(x) (x*x) ④ #define SQR(x) ((x)*(x))
【解】宏調用是字符列的替換，一個宏調用被替換後，替換後的字符序列就與它前後的字符列一起構成新的源程序。常有這樣的情況，因宏定義對宏參數的獨立性注意不夠，替換後的字符列會與其前後字符列結合，產生意想不多的結果；另外，因宏調用本身獨立性注意不夠，宏展開的內容會被分裂，部分內容會與其前或後的其它部分先結合。如一個宏定義有可能發生上述情況，它就是一個有可能引起二義性的宏定義。對於①，若希望描述計算u+v的平方，用宏調用SQR(u+v)，產生的代碼將是u+v*u+v。這是因宏定義對參數的獨立性注意不夠，產生不是希望的展開代碼。對於②，若希望描述計算1.0/x2，用宏調用1.0/SQR(x)，產生的代碼將是1.0/(x)*(x)，這是因宏調用本身獨立性注意不夠而引起的。對於③，與①的情況一樣，宏調用SQR(u+v)，不能正確描述u+v的平方。對於④，在宏定義中，給參數x加上括號能保證參數的獨立性，定義給全部內容也加上括號，這也保證了整個宏調用的獨立性。所以，④是計算平方數時，不可能引起二義性的宏定義。所以解答爲④。
80．執行下列程序
#define M(a, b) (a) > (b)?(a):(b)
main()
{ int i = 10, j = 15; printf(“%d\n”, 10*M(i, j)); }
後輸出的結果是
① 10 ② 15 ③ 100 ④ 150
【解】上述程序輸出表達式10*M(i, j)的值，該表達式中有宏調用，宏展開後的表達式爲
10 *（i）> (j) ? (i) : (j)
該表達式是一個條件表達式，它的求值順序如下：先求10 *（i）>(j)，因變量i和j的值分別爲10和15，10*10大於15，結果爲1。因條件表達式中的條件子表達式爲1，以表達式(i)的結果爲條件表達式的值。(i)的值是10，條件表達式的結果亦爲10。最後，程序輸出10。所以解答爲①。
81．設有定義語句“struct { int x; int y; } d[2] = {{1, 3}, {2, 7}};”，則
printf(“%d\n”, d[0].y/d[0].x*d[1].x);
的輸出是○。
① 0 ② 1 ③ 3 ④ 6
【解】結構數組d有兩個結構元素，每個結構又由兩個整型成分組成，初始化後，d[0].x = 1,d[0].y = 3, d[1].x = 2。所以表達式d[0].y /d[0].x*d[1].x的值是6。所以正確解答是④。
82．設有定義語句“enum term { my, your = 4, his, her = his+10};”，則
printf(“%d, %d, %d, %d\n”, my, your, his, her);
的輸出是○。
① 0, 1, 2, 3 ② 0, 4, 0, 10 ③ 0, 4, 5, 15 ④ 1, 4, 5, 15
【解】按枚舉類型定義的規定，枚舉類型team的枚舉常量對應的整數分別是my=0、your=4、his=5、her=15。所以語句輸出0，4，5，15。解答是③。
83．若有如下定義，則printf(“%d\n”, sizeof(them));的輸出是○。
typedef union {long x[2]; int y[4]; char z[8]; } MYTYPE;
MYTYPE them;
① 32 ② 16 ③ 8 ④ 24
【解】共用型變量的成分是覆蓋存儲，爲共用型變量分配存儲時，以其中需要最多存儲字節的成分進行分配。設long型數據佔4個字節、int型數據佔2個字節。共用型MYTYPE有三個成分，第一個成分是有兩個long型元素的數組，它需要8個字節；第二個成分是有4個int型元素的數組，它也需要8個字節；第三個成分是有8個字符元素的數組，也是8個字節。所以MYTYPE類型的共用型變量只需要8個字節。正確解答是③。
- 根據下面的定義，能打印出字母M的語句是○。
struct person {char name[9]; int age; };
struct person c[10]={{“John”, 17},
{“Paul”,19},{“Mary”,18},{“Adam”,16}};
- printf(“%c”, c[3].name);
- printf(“%c”, c[3].name[1]);
- printf(“%c”, c[2].name[1]);
- printf(“%c”, c[2].name[0]);
【解】結構類型struct person有兩個成分：九個元素的字符數組name和一個基本整型age。元素類型爲struct person的數組c有10個元素，其中前四個元素被設定了初值。在已設定初值的元素中，只有c[2].mane[0]的值是字符M。其餘元素及元素的成分都不是字符M。解答是④。
- 設有如下定義，則對data中的a成員的正確引用是○。
struct sk {int a; float b; } data, *p = &data;
① (*p).data.a ② (*p).a ③ p->data.a ④ p.data.a
【解】結構變量data有兩個成分a和b。結構指針變量p指向結構變量data。引用結構變量data的成分a有兩種方法：一是直接由變量data引用其自己的成分a，寫成data.a。二是通過指針變量p引用它所指的結構的成分a。這又有兩種寫法，分別是p->a和（*p）.a。解答是②。
- 設有如下定義，則對pp中的name成員的正確輸入是○。
struct s {char *name; int no; } pp;
- scanf(“%s”, name);
- scanf(“%s”, pp.name);
- scanf(“%s”, &&pp.name);
- { char buf[120];
scanf(“%s”, buf);
pp.name = (char *)malloc(strlen(buf)+1);
strcpy(pp.name, buf);
}
【解】字符串最終存於某個字符數組中，而不是存於字符指針中。字符指針只是指向存放這個字符串的字符數組的首字符位置。通常對於結構變量中包含字符指針的情況，要爲它輸入字符串，得先輸入到一個較大的字符數組中暫存，然後按輸入字符串的長度向系統申請存儲字符串的空間，並讓結構的字符指針指向這個動態空間，最後將暫存於字符數組中的字符串拷貝到這個動態空間。所以解答是④。
89．設typedef union { long x[2]; short y[4][5]; char z[10];} TYPE1;
TYPE1 u1;
則printf(“%d\n”, sizeof(u1)); 的輸出是
① 8 ② 10 ③ 40 ④ 58
【解】上述代碼定義共用型TYPE1，並定義TYPE1類型的變量u1。共用型如同結構型一樣，可以有多個不同類型的成員，但共用型變量成員的內存分配方法與結構變量成員的內存分配方法不同。結構變量的成員順序分配內存，各成員獨立佔用內存。一般來說，結構變量所佔用的內存字節總數是它的各成員所佔內存字節數之和；共用型變量的成員重疊佔用內存，共用型變量佔用的字節數由其中需要最多字節數的那個成員確定。計算具體變量實際將佔用多少字節，依賴於各種基本數據類型所需字節數。以一個long型數據佔用4個字節、short型數據佔用2個字節、char型數據佔用1個字節爲標準計算。對於共用型TYPE1來說，成員x需8個字節，成員y需40個字節，成員z需10個字節。這樣共用型變量u1就需40個字節。輸出共用型變量u1佔用的字節數應是40。所以解答爲③。
92．以只寫方式打開一個二進制文件，應選擇的使用方式是
①”a+” ②”w+” ③”rb” ④”wb”
【解】程序使用文件可以有多種不同方式。在C系統中，使用方式的不同由文件打開方式指定。首先是文件信息的存儲形式，有以內存表示形式存儲的二進制文件、和以字符形式存儲的文本文件。要特別指定爲二進制形式存儲，在打開方式中要有字符b。其次是文件的讀寫方式。其中只讀一個已存在的文件，在打開方式中用字符r；若只寫建立一個新文件，或只寫重建一個文件，在打開方式中用字符w。向已存在的文件只寫追加信息，在打開方式中用字符a。若有讀有寫方式使用文件，在打開方式中有字符+。特別地，對已存在文件的有讀有寫，用雙字符r+；在文件尾部追加信息的有讀有寫，用雙字符a+；新建，或重建文件的有讀有寫，用雙字符w+。由以上說明知，以只寫方式打開一個二進制文件，在打開方式中有字符b和有字符w。所以解答爲④。
93．若文件型指針fp已指向某文件的末尾,則函數feof(fp)的返回值是
① 0 ② -1 ③ 非零值 ④ NULL
【解】當調用fopen函數時，系統將爲實參文件設定一個存放文件讀寫控制信息的控制塊。該控制塊記錄有關文件持徵、使用方式，當前讀寫位置等文件狀態，並將該控制塊的指針返回，作爲文件指針變量的值。以後程序通過該指針調用函數時，系統能訪問到這個控制塊，利用該文件控制塊中的控制信息，正確完成文件的讀或寫。所以文件指針並不真正指向文件當前讀寫位置，但通過文件指針，系統能在文件控制塊中訪問文件的當前讀寫位置。若某文件與文件指針fp相關聯着，該文件的當前讀寫位置在文件的末尾時，函數調用feof(fp)的返回值是一個非零值。所以正確解答是③。
- 下列語句中，將c定義爲文件型指針的是
① FILE c; ② FILE *c; ③ file c; ④ file *c;
【解】如上題所述，文件控制塊的類型已由系統命名爲FILE。所以定義文件指針變量是c，就得用代碼：“FILE *c；”。所以正確解答是②。
- 標準庫函數fputs(p1, p2)的功能是
- 從p1指向的文件中讀一個字符串存入p2指向的內存
- 從p2指向的文件中讀一個字符串存入p1指向的內存
- 從p1指向的內存中的一個字符串輸出到p2指向的文件
④ 從p2指向的內存中的一個字符串輸出到p1指向的文件
【解】標準函數調用fputs(p1, p2)完成的功能是將由字符指針p1所指的字符串內容輸出到與文件指針p2相關聯的文件中，即將從p1所指的內存中的字符串內容複製存入到p2所指向的文件中。所以正確解答是③。
99．以下程序中的for循環執行的次數是
#include <stdio.h>
#define N 2
#define M N+1
#define NUM (M+1)*M/2
main()
{ int i, n = 0;
for(i = 1; i <=NUM;i++) { n++; printf(“%d”, n); }
printf(“\n”);
}
① 5 ② 6 ③ 8 ④ 9
【解】代碼NUM被替換成（2+1+1）* 2+1/2，所以其值是8。所以程序中的for循環執行的次數是8次。正確解答是③。
100．設有結構類型：
typedef struct ele {
int no; char name[20];
} Ele;
另有以下變量定義：
Ele a[20], x;
以下語句希望實現向與文件指針變量fp關聯的文件輸出一個結構信息，錯誤的代碼是。
- fwrite(a, sizeof(Ele), 1, fp);
- fwrite(&a[2], sizeof(Ele), 1, fp);
- fwrite(&x, sizeof(Ele), 1, fp);
- fwrite(x, sizeof(Ele), 1, fp);
【解】函數fwrite(char *buf, int size, int count, FILE *fp)實現將從地址buf開始存儲的，每塊信息有size個字節，連續的count塊信息複製存入與文件指針fp關聯的文件中。這裏要求調用時的第一個實參是指針。在①中因a是數組，單一的a是數組a的首元素的指針，所以是正確的。②的&a[2]是數組元素a[2]的指針，也是正確的。③中的&x是取結構變量x的指針，所以也是正確的。④中的x應表示對結構變量x的值的引用，不是指針，所以是錯誤的。正確解答是④。
二：填充題【100題】
- 轉義字符是由▁▁▁▁符號開始，後接單個字符或若干字符組成。
【解】在C語言中，轉義字符由反斜槓字符開始，後接單個字符或若干個字符組成。
- 在函數內，說明變量時，若省略存儲類型符，系統默認其爲▁▁▁▁存儲類別，該存儲類別的類型符爲：▁▁▁▁。
【解】在函數內，說明變量時，若省略存儲類型符，系統就默認其爲自動存儲類別，該存儲類型用auto標識。
- 設有下列運算符:<<、+、++、&&、<=，其中優先級最高的是▁▁▁▁，優先級最低的是▁▁▁▁。
【解】對運算符<<、+、++、&&、<=，按它們的優先級自高到低的順序排列爲：
++、+、<<、<=、&&
所以，優先級最高的是++，優先級最低的是&&。
- 設二進制數A是00101101，若想通過異或運算A^B使A的高4位取反，低4位不變，則二進制數B應是▁▁▁▁。
【解】按位加運算的一個重要應用是讓某個整型變量的二進位位串信息的某些位信息反向，0變成1，而1變成0。這隻要設計這樣一個位串信息，讓要變反的位爲1，不要改變的位爲0，用這個位串信息與整型變量按位加就能得到希望的結果。要使字節的高4位取反，低4位不變，則需要位串信息是11110000，寫成八進制數是0360，寫成十六進制數爲0xF0。
- 設a=3，b=2，c=1，則a>b的值爲▁▁▁▁，a>b>c的值爲▁▁▁▁。
【解】因a的值爲3，b的值是2，條件a>b爲真，其值爲1。表達式a>b>c的求值順序是計算a>b，結果爲1，接着計算1>c，因c的值爲1，條件1>c爲假，結果爲0。
- 能表述“20<x<30或x<-100”的C語言表達式是▁▁▁▁。
【解】首先表述20<x<30的C表達式可寫成20<x && x < 30。所以表述“20<x<30或x<-100”的C表達式爲20<x && x < 30 || x < -100。
- 結構化程序設計規定的三種基本結構是▁▁▁▁結構，選擇結構和▁▁▁▁結構。
【解】結構化程序設計的三種基本控制結構是順序結構、選擇結構和循環結構。
23．以下兩條if語句可合併成一條if語句爲▁▁▁▁。
if (a <= b) x = 1;
else y = 2;
if(a > b) printf(“****y = %d\n”, y);
else printf(“####x = %d\n”, x);
【解】在以上兩條if語句中，兩個條件剛巧相反。若將前一個if語句的第一個成分語句與第二個if語句的第二個成分語句合併；第一個if語句的第二個成分語句與第二個if語句的第一個成分語句合併，寫成一條if語句如下：
if (a <= b) {x = 1; printf(“####x = %d\n”, x); }
else { y = 2; printf(“****y = %d\n”, y);}
24．設i，j，k均爲int型變量，則執行完下面的for語句後，k的值爲▁▁▁▁。
for(i = 0, j = 10; i <= j; i++, j--) k = i+j;
【解】該fot語句以i爲0、j爲10初始化，循環條件是i <= j，每次循環後i增1、j減1，循環體是將i與j的和賦給k。這樣變量k將保存的是最後一次賦給它的值。一次循環後i爲1、j爲9，二次循環後i爲2、j爲8，……，五次循環後i爲5、j爲5，繼續第六次循環，將i與j的和10存於k後，i爲6、j爲4，結束循環。所以循環執行後k爲10。
25．下列程序的功能是輸入一個整數，判斷是否是素數，若爲素數輸出1，否則輸出0，請爲程序填空。
main()
{ int i, x, y = 1;
scanf(“%d”, &x);
for(i = 2; i<=x/2; i++)
if ▁▁▁▁ { y = 0; break;}
printf(“%d\n”, y);
}
【解】爲判數x是否是素數，預置變量y的值爲1（x可能是素數），然後用循環，用2至x/2的整數i測試對x的整除性，若能被其中的某個整數整除，則x是合數，置y的值爲0（x不是素數），結束測試循環。若都不能整除，則x爲素數。i能否整除x，可用求餘運算x%i等於0來判定。所以程序中的空框可填x%i == 0。測試x爲素數的代碼可寫成：
y = 1;
for(i=2; i <=x/2; i++)
if(x%i == 0) { y = 0; break; }
- 根據變量定義“static int b[5], a[][3]={1,2,3,4,5,6}；”，b[4]=▁▁▁▁▁，a[1][2]= ▁▁▁▁▁。
【解】系統規定，靜態變量定義時，若未初始化，系統自動給定二進制代碼全0的值。所以靜態數組b的元素全爲0，當然包括b[4]也爲0。靜態數組a是兩維數組，每行有三個元素，在初始化中給出了六個初值，所以數組a有2行。由於數組的元素按行順序存儲，並按行順序初始化。前三個值是第一行，後三個值是第二行。a[1][2]是第二行的第三列元素，也是a的最後一個元素，所以其值是6。
- 下面程序的功能是輸出數組s中最大元素的下標，請填空。
main()
{ int k, p，s[ ] = {1, -9, 7, 2, -10, 3};
for(p = 0, k = p; p < 6; p++)
if(s[p] > s[k]) ▁▁▁▁▁
printf(“%d\n”, k);
}
【解】爲要尋找數組中的最大元素的下標，需先預設1個臨時最大元素的下標，並順序逐一考察數組的元素，當發現當前元素比臨時最大元素更大時，就用當前元素的下標更新臨時最大元素下標。直至考察了數組的全部元素後，這臨時最大元素下標就是數組的最大元素下標。通常預設的最大元素下標是數組的首元素下標，考察是從首元素開始順序向後繼元素考察。程序中，存儲臨時最大元素下標的變量是k，變量p控制順序考察的循環控制變量。當發現當前元素s[p]比臨時最大元素s[k]更大時，應該用p更新k。所以在空框處應填入代碼“k=p；”。
- 下面程序的功能是將一個字符串str的內容顛倒過來，如“1234567”變換成“7654321”
#include <string.h>
main()
{ int i, j; ▁▁▁▁▁ ; char str[ ] = {“1234567”};
for(i = 0, j = strlen(str) ▁▁▁▁▁ ; i < j; i++, j--)
{ k = str[i]; str[i] = str[j]; str[j] = k;}
printf(“%s\n”, str);
}
【解】顛倒一個字符串中的字符，就是首尾對應的元素兩兩交換。簡單地可用兩個遊標變量i和j，i是前端元素的下標，j是後端元素的下標，交換以這兩個變量值爲下標的元素str[i]和str[j]。開始時，i的值爲0，j的值爲字符串末元素的下標（字符串長度減1）。每次交換後，i增1，j減1。繼續交換的條件是str[i]還位於str[j]的前面，即i<j。字符串末元素的下標是它的長度減1，所以在第二個空框處應填入-1。程序爲了交換str[i]和str[j]，使用了變量k，該變量應在程序的變量定義部分中一起定義，所以在第一個空框處應填入k。
- 以下程序可把輸入的十進制數以十六進制數的形式輸出，請填空。
main()
{ char b[17] = {“0123456789ABCDEF”};
int c[64], d, i = 0, base = 16;
long n;
pointf(“Enter a number:\n”); scanf(“%ld”, &n);
do { c[i] = ▁▁▁▁▁ ; i++; n = n/base; }
while (n != 0);
printf(“Transmite new base:\n”);
for(--i; i >= 0; --i)
{ d = c[i]; printf(“%c”, b▁▁▁▁▁); }
printf(“\n”);
}
【解】程序中，字符數組b存儲十六進制的16個數字符，整型數組c存儲譯出的十六進制數的各位數值。從整數n譯出它的各位十六進制數值，需採用除16取餘的方法，即求n除16的餘，得到它的十六進制的個位數，接着將n除以16。在n不等於0的情況下循環，能順序求出n的十六進制的個位數、十位數、百位數等等。程序中變量base已預置16，所以在第一個空框處可填代碼n%base或n%16。當n的十六進制數的個位、十位、百位等依次存放於數組c中後，就從最高位至最低位，參照數組c[i]的內容d（以其內容爲下標），取十六進制數字符表中的字符b[d]輸出。所以在第二個空框處可填入代碼[d]。
32．“*”稱爲▁▁▁▁▁運算符，“&”稱爲▁▁▁▁▁運算符。
【解】單目運算符“*”稱爲取內容運算符，單目運算符“&”稱爲取地址運算符。
33．若兩個指針變量指向同一個數組的不同元素，可以進行減法運算和▁▁▁▁▁運算。
【解】若兩個指針變量指向同一個數組的不同元素，可以進行減法運算求它們所指元素相差多少元素。進行關係運算，判定它們所指元素的前後、或是否指向同一個元素等。
- 設有char *a=”ABCD”，則printf(“%s”, a)的輸出是▁▁▁▁▁；而printf(“%c”, *a)的輸出是▁▁▁▁▁。
【解】若給字符指針變量a賦一個常量字符串”ABCD”，實際上是給a賦指向字符串常量首字符’A’的指針。程序通過它訪問字符串中的各字符。如能用代碼printf(“%s”, a)輸出這個字符串常量”ABCD"的字符列ABCD，用代碼printf(“%c”, *a)輸出a所指的字符A。
- 以下程序的功能是從鍵盤上輸入若干個字符（以回車符作爲結束）組成一個字符串存入一個字符數組，然後輸出該字符數組中的字符串。請填空。
#include <ctype.h>
#include <stdio.h>
main()
{ char str[81], *sptr;
int i;
for(i = 0; i < 80; i++)
{ str[i] = getchar(); if (str[i] == ‘\n’) break; }
str[i] = ▁▁▁▁ ; sptr = str;
while(*sptr) putchar(*sptr▁▁▁▁);
}
【解】從鍵盤輸入字符行，通過循環逐一輸入字符，當發現輸入字符是換行符時，結束循環。爲了使輸入的字符列變成字符串，必須在輸入字符列之後，原存儲換行符的元素改爲存儲字符串的結束標記符，需用代碼str[i] = ‘\0’，所以在第一框填入代碼‘\0’。當要將存於字符數組str中的字符串通過循環逐一輸出字符串的字符時，可以用字符指針sptr，讓sptr遍歷整個字符串，每次循環時，輸出sptr所指字符，並讓sptr增1，即可用代碼*sptr++實現，所以在第二框填入代碼++。
- 若自定義函數要求返回一個值，則應在該函數體中有一條▁▁▁▁▁語句；若自定義函數要求不返回一個值，則應在該函數說明時加一個類型符▁▁▁▁▁。
【解】若自定義的函數有返回值，則函數返回時應執行帶表達式的return語句返回，該表達式的值將作爲函數調用的結果。爲了強調函數是一個不返回值的函數，應在該函數說明時，加上一個void類型說明符。
- 若給fun函數的形參s傳送字符串：”∪∪6354abcc” （其中∪表示空格字符），則函數的返回值是▁▁▁▁▁。
#include <ctype.h>
long fun(char s[])
{ long n; int sign;
for(; isspace(*s); s++);
sign = (*s ==’-‘) ? –1 : 1;
if (*s == ‘+’ || *s == ‘-‘) s++;
for(n = 0; isdigit(*s); s++) n = 10*n + (*s – ‘0’);
return sign*n;
}
【解】函數fun的第一個for循環跳過字符串的前導空白符，接着分析第一個非空白符是否是負號，若是置變量sign爲-1；否則，置變量sign爲1。接着的if語句在第一個非空白字符是負號或正號時，跳過該字符。以後的for循環將後面的數字符當作十進制數的各位數字譯出一個長整數n。遇字符a時，結束譯數循環。最後，函數返回sign與n的乘積。所以若調用函數時提供的實參是” ∪∪6354abc”，函數返回值是6354。
- 下面函數要求計算兩個整數x、y之和，並通過形參z傳回該和值，請填空。
void add(int x, int y, ▁▁▁▁▁ z)
{ ▁▁▁▁▁ = x+y; return; }
【解】函數希望通過形參z帶回結果，形參z必須是指針類型的，由於返回整型結果，所以z的說明是int * z。函數返回前必須先把結果通過形參z間接引用(寫成*z)傳回。
- 函數my_cmp()的功能是比較字符串s和t的大小，當s等於t時返回0，否則返回s和t的第一個不同字符的ASCII碼差值，即s > t時返回正值，當s < t時返回負值。請填空。
my_cmp(char *s, char *t)
{ while (*s == *t)
{ if (*s == ‘\0’) return 0;
++s; ++t;
}
return ▁▁▁▁▁;
}
【解】兩字符串大小比較必須從它們的首字符開始，在對應字符相等情況下循環，直至不相等結束。相等時，若字符串已到了字符串的結束標記符，則兩字符串相同，函數返回0值；如還有後繼字符，則準備比較下一對字符。對應字符不相同，循環結束。循環結束時，就以兩個當前字符的差返回。所以在空框處應填入*s-*t，保證在s > t時返回正值，當s < t時返回負值。
union aa {float x; float y; char c[6]; };
struct st{ union aa v; float w[5]; double ave; } w;
【解】共用型aa有三個成分，一個是float型成分x,一個是float型成分y，再一個是有六個元素的字符數組。若float 型數據佔4個字節，則類型aa 數據要佔用6個字節。結構變量w有三個成分，一個是共用型成分aa , 要佔用6個字節；一個是有5個float型元素的數組w，要佔用20個字節；一個是double型的ave。若double型數據要8個字節，則結構變量w要佔用34個字節。
- 在對文件進行操作的過程中，若要求文件的現行位置回到文件的開頭，應當調用的函數是▁▁▁▁函數。
【解】若要讓文件隨機地從某個現行位置回到文件的開頭，可調用庫函數rewind()。
- 下面的程序用來統計文件中字符的個數，請填空。
#include <stdio.h>
main()
{ FILE *fp;
long num = 0;
if ((fp = fopen(“fname.dat”, “r”)) == NULL)
{ printf(“Cant’t open file!\n”); exit(0); }
while ▁▁▁▁{ fgetc(fp); num++; }
printf(“num = %d\n”, num);
fclose(fp);
}
【解】若要統計文件中的字符個數，程序設計一個計數器，並預置該計數器爲0值，並打開文件。在正確打開情況下，接着是一個循環。循環在文件未結束的情況下，反覆讀入字符，並增加字符計數器。所以循環條件可寫成：!feof(fp)。程序有一個錯誤，由於num變量的類型是long型的，輸出它的值應在格式符d之前加上格式修飾符‘l’， 不加這個修飾符只有在long型與int型實現相同的系統纔是正確的。另外，要統計文件的長度，最好用二進制方式打開，通過讀入的字節數求出文件的長。這是因爲正文文件方式打開時，文件中的雙字符（回車字符和換行字符）讀入後將被當作一個字符存儲，二進制方式不進行這樣的轉換。
54．設有定義“#define F(N) 2*N”，則表達式F（2+3）的值是▁▁▁▁▁▁。
【解】F(N)被定義成2*N，表達式F(2+3)被替換成2*2+3，其值是7。
- 設有下列程序：
#include <stdio.h>
main(int argc, int *argv[ ])
{ while(--argc > 0) printf(“%s”, argv[argc]);
printf(“\n”);
}
假定上述程序編譯連接成目標程序名爲p.exe，如果輸入如下的命令：
p 123 AAA BBB↙ （其中的↙表示回車）
則輸出結果是▁▁▁▁▁▁。
【解】程序啓動時，參數argc的值是4，由於循環條件是—argc > 0，是先減1後判大於0，循環共進行三次，順序輸出argv[3]，argv[2]和argv[1]，即輸出BBBAAA123。
56．以下分別是算術、位、關係和邏輯運算符
+， &， <, !
其優先級最低的是_________ 。
【解】C語言的運算符十分豐富，並且運算符的優先級也很多。各運算符的優先級大致是按運算符的意義分類的，優先級自高到低分別是：
圓括號、數組元素運算符[]、結構或共用體成員運算符.和->
單目運算符（如否定，求反、自增自減、取地址、取內容、取正、取負、數據長度）
算術運算符（先乘、除、求餘，後加、減）
移位運算符
關係運算符（先大小，後相等和不等）
雙目位運算符（依次爲按位與、按位加、按位或）
雙目邏輯運算符（依次爲邏輯與、邏輯或）
三目條件運算符
賦值運算符（先簡單賦值，後自反賦值）
逗號運算符
本題給出的運算符+、&、<、! 分別是算術運算符的加、雙目邏輯運算符的邏輯與、關係運算符的小於和單目運算符的邏輯否定。在這4種運算符中，優先級最低的是雙目邏輯運算符的邏輯與&。所以解答是&。
58．設int a, b = 10;執行a = b << 2 + 1；後a的值是_________ 。
【解】用圓括號表示上述表達式的計算順序，可寫成
a = (b << (2+1))
即將b的值左移3位後存於變量a。一般地，在左移沒有使數值二進位丟失的情況下，每左移一位，相當於乘2。這樣，10左移3位後的值是80，上述表達式使a的值爲80。所以解答是80。
62．在C語言中，_________ 類型變量的所有成員以覆蓋方式共享存儲單元。
【解】在C語言中，只有共用型變量的所有成員以覆蓋方式共享存儲單元。共用型變量也稱爲共用體、聯合體，或union類型變量。
65．設 int a[3][4], *p = a[1]; 該指針變量p指向的元素是_________。
【解】在C語言中，一個二維數組可以看作元素是一維數組的一維數組。如問題所給的二維數組a，可以看作由3個元素a[0]、a[1]、a[2]組成的一維數組，其中a[0]、a[1]、a[2]又各自是由4個元素組成的一維數組。如a[1]表示由a[1][0]、a[1][1]、 a[1][2]、a[1][3]這4個元素組成的數組。按這一觀點，表達式a[1]就是這個一維數組首元素a[1][0]的指針。所以，問題中的指針變量p指向的是a[1][0]。按數組元素的不同標記形式，a[1][0]也可寫成*(*(a+1)+0)，或簡寫成**(a+1)。
67．將一字符串中的小寫英文字母改成大寫。
main()
{ int i = 0; char str[80];
scanf(“%s”, str);
while (______)
{ if(______) str[i] -= ‘a’ – ‘A’;
______ ;
}
printf(“%s\n”, str);
}
【解】爲了改寫字符串中的小寫英文字母，需要順序地考察字符串的每一個字符。當發現當前元素str[i]是小寫英文字母時，就改寫str[i]，減去小寫字母與對應大寫字母ASCII代碼的差。由於要順序考察字符串的每個字符，所以框1的循環條件是當前字符str[i]不是字符串結束符，寫成str[i] != ‘\0’或簡寫成str[i]。僅當str[i]是小寫英文字母時纔要改寫，表示str[i]是小寫英文字母的條件框2可寫成str[i]>=’a’ && str[i]<=’z’。每考察了一個字符後，就要準備考察下一個字符，框3處的語句是讓變量i增1，可寫成i++，或++i，或i=i+1，或i+=1等。
73．以下程序的輸出結果是______。
main()
{ static char a[ ] = {‘*’, ‘*’, ‘*’, ‘*’, ‘*’};
int i, j, k;
for(i = 0; i < 5; i++)
{ printf(“\n”);
for(j = 0; j < i; j++) printf(“%c”, ‘ ‘);
for(j = 0; j < 5; j++) printf(“%c”, a[k]);
}
printf(“\n”);
}
【解】程序的外循環控制循環5次，每次開始先輸出一個換行符，共輸出5行信息。對於i（自0開始計算）行，先輸出i個空白符，接着輸出字符數組a中的5個字符，由於a中的5個字符都是字符*，所以輸出5個*字符。這樣程序是輸出以下形式的圖案：
*****
*****
*****
*****
*****
- 以下程序的輸出結果是______。
main()
{ char *a[6] = {“AB”, “CD”, “EF”, “GH”, “U”, “KL”};
int i;
for(i = 0; i < 4; i++) printf(“%s”, a[i]);
printf(“\n”);
}
【解】程序定義了有6個元素的字符指針數組a，數組a的各元素指向字符串常量。程序的for循環遍歷了a的前4個元素，用字符串輸出格式，輸出指針數組a前4個元素所指的字符串。所以程序輸出：ABCDEFGH。
- 以下程序的功能是______。
main()
{ int i, a[10], *p = &a[9];
for(i = 0; i < 10; i++) scanf(“%d”, &a[i]);
for(; p>=a; p--) printf(“%d\n”, *p);
}
【解】程序定義了有10個元素的整型數組a，另定義指針變量p，並讓它指向a的最後一個元素a[9]。執行代碼的第一個循環是順序輸入數組a的10個元素。第二個循環利用指針p逆序遍歷數組a，將數組a的各元素逆序輸出。所以程序的功能是輸入10個整數，並逆序輸出這10個整數。
- 以下程序的輸出結果是______。
main()
{ char str[ ] = {‘A’, ‘B’, ‘C’, ‘\0’, ‘D’, ’E’, ‘F’, ‘\0’}, *p = str;
for(;p-str<sizeof(str); p++)
printf(“%s\n”, p);
}
【解】程序用字符指針，順序遍歷字符數組，該字符數組中存放着兩個字符串。當指針所指的字符還在第一個字符串中時，輸出第一個字符串中的部分內容。當指針所指的字符是第二個字符串中的字符時，輸出第二個字符串中的部分內容。所以程序輸出：
ABC
BC
C
DEF
EF
F
- 以下程序的輸出結果是______。
struct stu
{ int num; char *name; int score; };
struct stu * py(struct stu *p)
{ int s = p;
for(p++; p->no>0; p++)
if(s->score < p->score) s = p;
return s;
}
main()
{ struct stu student[ ] = {{1001, “Sun”, 76}, {1002, “Ling”, 88},
{1003, “Shen”, 76}, {0, “ “, 0}};
struct stu *p; p = py(student);
printf(“NO:%d NAME:%s SCORE:%d\n”, p->num, p->name, p->score);
}
【解】函數py的功能是在給定的結構數組中找出成績最高的結構元素，並返回該結構的指針。主函數利用該指針輸出這個結構的內容。所以程序輸出：
NO：1002 NAME:Ling SCORE:88
- 設下面的程序經編譯連接後生成的目標程序名爲：ABC.EXE，寫出輸入以下命令行後的輸出結果是______。
ABC FILE1 FILE2↙ （其中的↙表示回車）
#include <stdio.h>
main(int argc, char *argv[ ])
{ int i;
printf(“%d\n”, argc);
for(i = 0; i < argc; i++) printf(“%s “, argv[i]);
printf(“\n”);
}
【解】程序首先輸出參數argc的值3，然後循環3次，順序輸出ABC、FILE1和FILE2，並回車：
3
ABC FILE1 FILE2
- 以下程序的功能是______。（字符0的ASCII碼爲16進制的30）
main()
{ union{ char c; char i[4]; }z;
z.i[0] = 0x39; z.i[1] = 0x36;
printf(“%c\n”, z.c);
}
【解】共用型變量z有兩個成分，一個是字符型的c，另一個是有4個字符的數組i。由於共用型的成分是覆蓋存儲，成分c的內容也是成分i的首元素。程序給z的i成分的首元素置十六進制代碼0x39，即十進制數57。數57是字符’9’的ASCII代碼。用字符輸出格式，輸出該變量的值，將輸出字符’9’。
- 以下程序的輸出結果是______。
main()
{ enum em{ em1 = 3, em2 = 1, em3};
char *aa[ ] = {“AA”, “BB”, “CC”, “DD”};
printf(“%s%s%s\n”, aa[em1], aa[em2], aa[em3]);
}
【解】由枚舉類型em的定義知，枚舉常量em1的值是3，枚舉常量em2的值是1，枚舉常量em3的值是2。所以程序運行後輸出：
DD BB CC
- 假定在當前盤當前目錄下有2個文本文件，其名稱和內容如下：
文件名 a1.txt a2.txt
內容 121314# 252627#
以下程序的輸出結果是______。
#include <stdio.h>
main()
{ FILE *fp;
if((fp = fopen(“al.txt”, “r”)) == NULL)
{ printf(“Can not open file!\n”);
exit(1);
}
else { fc(fp); fclose(fp); }
if((fp = fopen(“a2.txt”, “r”)) == NULL)
{ printf(“Can not open file!\n”);
exit(1);
}
else {fc(fp); fclose(fp); }
}
void fc(fpl)
FILE *fp1;
{ char c;
while ((c = fgetc(fp1)) != ‘#’) putchar(c);
}
【解】程序以讀方式打開文件a1.txt，若能正常打開，則調用函數fc。接着同樣地，以讀方式打開文件a2.txt，若能正常打開，也調用函數fc。函數fc從指定的文件讀入字符，在讀入字符不是字符’#’情況下循環，將讀入字符輸出。對於文件a1.txt，程序輸出121314，對於文件a2.txt，程序輸出262627。所以程序輸出121314252627。
- 以下程序的輸出結果是______。
#define PR(ar) printf(“%d,”,ar)
main()
{ int j, a[ ] = {1, 3, 5, 7, 9, 11, 15}, *p = a+5;
for(j = 3; j; j--)
switch(j)
{ case 1:
case 2: PR(*p++); break;
case 3:PR(*(--p));
}
printf(“\n”);
}
【解】程序的宏定義PR以d格式輸出參數的值和逗號字符。程序給數組a賦初值，並由指針p指向元素a[5]。程序讓j從3至1，共循環3次。當j是3時，讓p減1，並輸出p所指元素的值9；當j是2和1時，輸出p所指的數組元素的值，並讓p增1，順序輸出9和11。所以程序輸出：
9，9，11，
- 以下程序的輸出結果是______。
main()
{ char str[ ] = “1234567”; int i;
for(i = 0; i < 7; i += 3)
printf(“%s\n”, str+i);
}
【解】程序中，字符數組str中存有字符串“1234567”。循環語句受變量i控制，i的初值爲0，循環條件是i < 7，每次循環後i增3。所以，i的值依次爲0、3、6，共進行了3次循環。每次循環輸出str中從str+i位置開始的部分字符串內容。第一次循環，i 的值爲0，輸出內容是“1234567”；第二次循環，i 的值爲3，輸出內容是“4567”；第三次循環，i 的值爲6，輸出內容是“ 7”。所以，程序將輸出：
1234567
4567
7
97．以下程序的輸出結果是______。
conv (b)
int b;
{ if (b >= 2) conv(b/2);
printf(“%d”, b%2);
}
main()
{ int d;
scanf(“%d”, &d); conv(d);
}
輸入22↙
【解】程序中的函數conv有一個整數形參b，該函數是一個遞歸函數。函數的遞歸算法是當形參b大於等於2時就繼續以b/2 爲實參遞歸。遞歸調用返回時，輸出b%2。即當b是偶數時，輸出0；b是奇數時，輸出1。或者說，輸出b的二進制表示的個位。主函數以輸入值22爲實參調用函數conv，使函數conv引起以下一系列的遞歸調用和輸出：
conv(b=22) → conv(b=11) → conv(b=5) → conv(b=2) → conv(b=1)
↓ ↓ ↓ ↓ ↓
輸出0 ← 輸出1 ← 輸出1 ← 輸出0 ← 輸出1
↓
主函數
由上述遞歸調用的執行過程知，對於輸入22，程序的這次執行將輸出10110。
100．以下程序的功能是_______。
#include <stdio.h>
main()
{ int a[20], i, base = 10;
int n;
printf("Enter a number!\n"); scanf("%d", &n); /* 整數輸入 */
i = 0; /* 對n進行分拆，各位數字自低位到高位存於數組a */
do { a[i++] = n % base;
n /= base;
} while (n);
for(i--; i >= 0; i--) /* 自高位到低位輸出 */
printf("%d%c", a[i], i ? ',' : '\n');
}
【解】程序的主要工作是從輸入整數分拆出它的十進制整數的各位數字，將分拆出來的各位數字存於數組中，然後將這些數字自高位到低位的順序逐位輸出。程序用一個循環將一個整數按十進制數的要求分拆，每次循環求出被分拆數除以10的餘數的辦法求出它的個位，每分拆出一位就將被分拆的數除以10。循環過程直至被分拆的數爲0結束。
文本題庫下載地址
鏈接：https://pan.baidu.com/s/1Poeqn1uMgLp07OHZc_wH2A
提取碼：amri
