程序設(shè)計基礎(chǔ)（山東工商學(xué)院）知到智慧樹章節(jié)測試課后答案2024年秋山東工商學(xué)院

程序設(shè)計基礎(chǔ)（山東工商學(xué)院）知到智慧樹章節(jié)測試課后答案2024年秋山東工商學(xué)院第一章單元測試

一個C程序可能出現(xiàn)的錯誤有（）。

A:語法錯誤

B:其他三個選項中所說的錯誤都可能出現(xiàn)

C:邏輯錯誤

D:運行錯誤

答案:其他三個選項中所說的錯誤都可能出現(xiàn)

C語言源程序中一般可以包含幾個函數(shù)？（）。

A:必須兩個以上

B:0個

C:至少一個

D:1個

答案:至少一個

關(guān)于C語言，以下描述中錯誤的是（）。

A:一個C程序總是從main函數(shù)開始執(zhí)行

B:C語言的注釋通常是以"/*"開始并以"*/"結(jié)束

C:一個C程序可以包含多個main函數(shù)

D:每個語句的最后必須有一個分號

答案:一個C程序可以包含多個main函數(shù)

計算機(jī)能直接執(zhí)行的文件是（）。

A:擴(kuò)展名為txt的文件

B:擴(kuò)展名為exe的文件

C:擴(kuò)展名為obj的文件

D:擴(kuò)展名為c的文件

答案:擴(kuò)展名為exe的文件

以下敘述中正確的是（）。

A:C語句必須以分號結(jié)束

B:一條C語句必須在一行內(nèi)寫完

C:C程序中出現(xiàn)的預(yù)編譯，均為語句，如#include＜stdio.h＞就是一條C語句

D:C程序中的每一行只能寫一條語句

答案:C語句必須以分號結(jié)束

程序的運行結(jié)果不正確，這種錯誤屬于（）。

A:邏輯錯誤

B:編譯錯誤

C:語法錯誤

D:連接錯誤

答案:邏輯錯誤

在函數(shù)體中，關(guān)于數(shù)據(jù)定義語句和非數(shù)據(jù)定義語句（即執(zhí)行語句）的位置，下面說法正確的是（）。

A:C89標(biāo)準(zhǔn)規(guī)定：有些必須放在前面，有些可以放在后面

B:C89標(biāo)準(zhǔn)規(guī)定：所有數(shù)據(jù)定義語句必須在任何非數(shù)據(jù)定義語句的前面

C:C89標(biāo)準(zhǔn)對于上述兩種語句的位置沒有要求

D:C99標(biāo)準(zhǔn)規(guī)定：所有數(shù)據(jù)定義語句必須在任何非數(shù)據(jù)定義語句的前面

答案:C89標(biāo)準(zhǔn)規(guī)定：所有數(shù)據(jù)定義語句必須在任何非數(shù)據(jù)定義語句的前面

在C語言程序中（）。

A:main函數(shù)必須放在程序的開始位置

B:main函數(shù)只能出現(xiàn)在庫函數(shù)中

C:main函數(shù)可以放在其它函數(shù)的前面、后面或中間

D:main函數(shù)必須放在程序的最后

答案:main函數(shù)可以放在其它函數(shù)的前面、后面或中間

C語言屬于以下程序設(shè)計語言的哪個類別？（）。

A:面向?qū)ο笳Z言

B:機(jī)器語言

C:高級語言

D:匯編語言

答案:高級語言

下列選項中，屬于多行注釋的是（）。

A://

B:\\

C:/**/

D:/*

答案:/**/

以下四個程序中，完全正確的是（）。

A:include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n")；

return0;

}

B:#include＜stdio.h＞

intmain()；

{

/*programming/*

printf("programming！\n")；

return0;

}

C:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n")

return0;

}

D:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n");

return0;

}

答案:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n");

return0;

}

第二章單元測試

以下哪個選項中是合法的用戶自定義標(biāo)識符?（）。

A:b-b

B:float

C:_isw

D:123asd

答案:_isw

下面選項中，屬于合法的字符常量的是（）。

A:'ab'

B:"\0"

C:'\084'

D:'\x43'

答案:'\x43'

下面幾組代碼中正確的是（）。

A:intconsta=1;

B:constinta;a=1;

C:constinta;

D:constinta=1;

答案:constinta=1;

能正確定義3個變量并為它們賦初值5的是（）。

A:intx,y,z=5;

B:intx=y=z=5;

C:intx=5,y=5,z=5;

D:x=y=z=5;

答案:intx=5,y=5,z=5;

下面4個選項中，能使符號常量代表3的定義是（）。

A:#defineN3;

B:#defineN3

C:defineN3

D:#defineN=3

答案:#defineN3

設(shè)整數(shù)和實數(shù)的大小都不超過各自變量的存儲范圍，下面4種說法中，正確的是（）。

A:整數(shù)的存儲不都是精確的，實數(shù)的存儲都不是精確的

B:整數(shù)和實數(shù)的存儲都不是精確的

C:整數(shù)的存儲都是精確的，實數(shù)的存儲不都是精確的

D:整數(shù)的存儲都是精確的，實數(shù)的存儲都不是精確的

答案:整數(shù)的存儲都是精確的，實數(shù)的存儲不都是精確的

下面4個選項中，全部都是合法整型常量的是（）。

A:-0xcdf,01A,0xe

B:-01,012,0668

C:160,-0xffff,011

D:-0x48A,2e5,0x

答案:160,-0xffff,011

下面4個選項中，均不是合法浮點數(shù)的選項是（）。

A:-.18,123e4,0.0

B:123,2e4.2,e5

C:160.,0.12,e3

D:-e3,.234,1e3

答案:123,2e4.2,e5

c是字符變量，關(guān)于語句“c='A'+'6'-3;”,下面說法正確的是（）。

A:執(zhí)行后c的值是'D'

B:無法執(zhí)行

C:執(zhí)行后c的值是't'

D:執(zhí)行后c的值是68

答案:執(zhí)行后c的值是't'

關(guān)于字符串"CHINA"，下面說法正確的是（）。

A:它可以用一個字符串變量存儲，存儲它的字符串變量占用5個字節(jié)的內(nèi)存

B:其他三個說法都不對

C:它在內(nèi)存中占6個字節(jié)

D:它在內(nèi)存中占5個字節(jié)

答案:它在內(nèi)存中占6個字節(jié)

參與運算的對象必須是整數(shù)的運算符是（）。

A:%和/

B:%

C:*

D:/

答案:%

intx=10,y=3;

printf("%d,%d\n",x--,--y);

上面程序段的運行結(jié)果是（）。

A:10,3

B:102

C:10,2

D:9,3

答案:10,2

chara='1',b='2';

printf("%c,",b++);

printf("%d\n",b-a);

數(shù)字0的ASCII碼是48，上面程序段的運行結(jié)果是（）。

A:2,50

B:3,2

C:2,2

D:50,2

答案:2,2

字符串"ab\108g"在內(nèi)存中占的字節(jié)數(shù)是（）。

A:8

B:7

C:6

D:5

答案:6

關(guān)于表達(dá)式a*=b+c，下面說法正確的是（）。

A:其他三個說法都不對

B:它與a=a*b+c等價

C:它與a=a*b=b+c等價

D:它與a=a*(b+c)等價

答案:它與a=a*(b+c)等價

若有定義

inta=10,c=2;constintb=5;

則正確的賦值表達(dá)式是（）。

A:b=10

B:(a+b)=c*8

C:a=(b+c)*6

D:6=a

答案:a=(b+c)*6

關(guān)于算術(shù)運算，下面四個說法中正確的是（）。

A:1/2的結(jié)果是0

B:-5/3的結(jié)果是-2

C:5.0/9的結(jié)果是0

D:20*3%7，應(yīng)先計算3%7

答案:1/2的結(jié)果是0

設(shè)a、b都是int型變量,則表達(dá)式（a=1,a+=1,b=a,b*2,a+b）的值是（）。

A:2

B:4

C:6

D:其他三個答案都不對

答案:4

表達(dá)式('A'+0.32f)計算結(jié)果的類型是（）。

A:int

B:double

C:char

D:float

答案:double

設(shè)有數(shù)據(jù)定義

charc1=65,c2=66;

inta1=1,a2=2;

floatx1=1.1,x2=2.2;

則下面四個選項中，系統(tǒng)不進(jìn)行類型轉(zhuǎn)換就能直接運算的是（）。

A:a1+a2

B:c1+c2

C:x1+x2

D:c1+a1

答案:a1+a2

第三章單元測試

charx=0xffff;

printf("%d\n",x--);

上面程序段的運行結(jié)果是（）。

A:-32767

B:fffe

C:-32768

D:-1

答案:-1

doubled;

floatf;

longl;

inti;

i=f=l=d=20/3;

printf("%d,%1d,%.1f,%.1f,",i,l,f,d);

上面程序段的運行結(jié)果是（）。

A:6,6,6.0,6.0

B:6,6,6.7,6.0

C:6,6,6.0,6.7

D:6,6,6.7,6.7

答案:6,6,6.0,6.0

unsigneda=65535;

printf("%d,%o,%x",a,a,a);

TC中整型變量占2個字節(jié)，則上面程序段的運行結(jié)果是（）。

A:65535,177777,ffff

B:65535,65535,65535

C:-1,65535,ffff

D:-1,177777,ffff

答案:-1,177777,ffff

關(guān)于putchar()的說法正確的是（）。

A:putchar()可用于輸出字符串

B:putchar()函數(shù)括號中可以寫字符變量或常量，也可以寫整型變量或常量

C:其作用是由用戶向計算機(jī)輸出一個字符

D:putchar()不能對轉(zhuǎn)義字符進(jìn)行操作

答案:putchar()函數(shù)括號中可以寫字符變量或常量，也可以寫整型變量或常量

要從鍵盤給兩個整型變量a、b輸入數(shù)據(jù)，輸入格式是1,2＜Enter＞，能完成此任務(wù)的代碼是（）。

A:getchar(a,b);

B:scanf("%d%d",&a,&b);

C:scanf("%d%d",a,b);

D:scanf("%d,%d",&a,&b);

答案:scanf("%d,%d",&a,&b);

想通過代碼“scanf("%d%d,%d",&a,&b,&c);”把1、2、3分別存入3個整型變量a、b、c，則正確的鍵盤輸入應(yīng)該是（）。

A:1＜Enter＞2＜Enter＞3＜Enter＞

B:1＜Enter＞＜Tab＞2,3＜Enter＞

C:12＜Tab＞3＜Enter＞

D:1,2,3＜Enter＞

答案:1＜Enter＞＜Tab＞2,3＜Enter＞

關(guān)于格式控制字符串%-m.ns,正確的說法是（）。

A:如果n＞m，則截取n個字符輸出，突破m的限制

B:m表示輸出的字符串最少占m列，n為小數(shù)精度

C:如果n＜m，則字符串向右靠攏，左端補0

D:如果n＞m，則只截取m個字符，其余的舍棄

答案:如果n＞m，則截取n個字符輸出，突破m的限制

以下不屬于格式控制字符的是（）。

A:%E

B:%D

C:%X

D:%f

答案:%D

a、b、c都是整型變量，用“scanf("%d%2d%*2d%d",&a,&b,&c);”給3個變量輸入數(shù)據(jù)，設(shè)輸入格式是12345678＜Enter＞,則3個變量的值分別是（）。

A:12,34,78

B:1,34,78

C:1,34,7

D:12,34,56

答案:12,34,78

charc1='1',c2='2';

c1=getchar();

c2=getchar();

上面的程序段運行時從鍵盤輸入a＜Enter＞,則正確的敘述是（）。

A:c1被賦予字符a,c2無確定值

B:c1被賦予字符a,c2被賦予換行符

C:程序?qū)⒌却斎氲诙€字符

D:c1被賦予字符a,c2維持原值

答案:c1被賦予字符a,c2被賦予換行符

inti;

floatf;

scanf("i=%d,f=%f",&a,&f);

上面程序段準(zhǔn)備把10和5.12分別存給i和f，則正確的輸入應(yīng)是（）。

A:10＜Enter＞5.12＜Enter＞

B:10＜空格＞5.12＜Enter＞

C:i=10,f=5.12＜Enter＞

D:i=10＜Enter＞f=5.12＜Enter＞

答案:i=10,f=5.12＜Enter＞

inta;

charb;

floatc;

scanf("%d%c%f",&a,&b,&c);

若上面程序段運行時鍵盤輸入的字符序列為2223a123o.12,則a、b、c的值分別是（）。

A:原值不變

B:2223，a,123o.12

C:2223,a,123

D:2223,a,原值

答案:2223,a,123

第四章單元測試

inta=3,b=2,c=1,f;

f=a＞b＞c;

上面程序段執(zhí)行后，f的值是（）。

A:不確定

B:2

C:1

D:0

答案:0

#include＜stdio.h＞

intmain()

{

inta=1,b=2,m=0,n=0,k;

k=(n=b＞a)||(m=a＜b);

printf("%d,%d",k,m);

return0;

}

上面程序的運行結(jié)果是（）。

A:1,1

B:1,0

C:0,2

D:0,0

答案:1,0

以下四個選項中，執(zhí)行完程序段后y的值不為3的是（）。

A:intx=5,y=2;if(x)y=3;

B:intx=0,y=0;if(x=y)y=3;

C:intx=5,y=2;if(2)y=3;

D:intx=0,y=2;if(x=y)y=3;

答案:intx=0,y=0;if(x=y)y=3;

inta=2,b=-1,c=2;

if(a＜b)

if(b＜0)

c=0;

elsec++;

上面的程序段執(zhí)行后，c的值是（）。

A:2

B:0

C:3;

D:1

答案:2

intx=10,y=20,z=30;

if(x＞y)

z=x;x=y;y=z;

上面代碼段執(zhí)行后，x，y，z的值是（）。

A:20,10,10

B:10,20,30;

C:20,30,10

D:20,30,30

答案:20,30,30

邏輯運算符中，運算優(yōu)先級按從高到低正確排序的是（）。

A:!||&&

B:||&&!

C:&&!||

D:!&&||

答案:!&&||

以下是if語句的基本形式：

if(表達(dá)式)語句

其中“表達(dá)式”（）。

A:必須是關(guān)系表達(dá)式

B:可以是任意合法的表達(dá)式

C:必須是邏輯表達(dá)式

D:必須是邏輯表達(dá)式或關(guān)系表達(dá)式

答案:可以是任意合法的表達(dá)式

若有表達(dá)式(！w)?(--x):(++y),則下列選項中與其等價的表達(dá)式是（）。

A:(w!=0)?(--x):(++y)

B:(w==1)?(--x):(++y)

C:(w==0)?(--x):(++y)

D:(w!=1)?(--x):(++y)

答案:(w==0)?(--x):(++y)

intw='b',x=14,y=15;

w=((x||y)&&(w＜'a'));

執(zhí)行上面程序段后，w的值為（）。

A:1

B:NULL

C:0

D:-1

答案:0

if((x=y=2)＞=x&&x=5)

y*=x;

上面程序段執(zhí)行后，整型變量x、y的值分別是（）。

A:5,2

B:5,10

C:2,4

D:賦值號級別低于&&，導(dǎo)致代碼存在語法錯誤第10題

答案:賦值號級別低于&&，導(dǎo)致代碼存在語法錯誤第10題

intx,y;

scanf("%d%d",&x,&y);

if(x＞y)

x=y;y=x;

else

x++;y++;

printf("%d,%d",x,y);

關(guān)于上面程序段，下列說法正確的是（）。

A:有語法錯誤

B:若輸入“43”，輸出“3,4”

C:若輸入“34”，輸出“4,5”

D:若輸入“43”，輸出“4,4”

答案:有語法錯誤

1.#include＜stdio.h＞

2.intmain()

3.{

4.intm;

5.printf("Inputm:");

6.scanf("%d",&m);//輸入一個整數(shù)

7.if(m＞0)//是否為正數(shù)

8.{

9.if(m%2==0)//是正數(shù)，且能被2整除，則是正偶數(shù)

10.{

11.printf("%disapositiveeven\n",m);

12.}

13.else//不能被2整除，則是正奇數(shù)

14.{

15.printf("%disapositiveodd\n",m);

16.}

17.}

18.

19._______________//判斷是否為負(fù)數(shù)

20.

21.{

22._______________

23.

24.{

25.printf("%disanegativeeven\n",m);//是負(fù)偶數(shù)

26.}

27.else

28.{

29.printf("%disanegativeodd\n",m);//是負(fù)奇數(shù)

30.}

31.}

32.else

33.{

34.printf("%diszero.Itisaneven\n",m);

35.}

36.return0;

37.}

上面程序代碼的功能是判斷輸入整數(shù)的正負(fù)性和奇偶性，能將代碼補充完整且正確的選項是（）。

A:第19行代碼：if(m＜0)，第22行代碼：if(m%2!=0)

B:第19行代碼：elseif(m＜0)，第22行代碼：if(m%2==0)

C:第19行代碼：if(m＜0),第22行代碼：if(m%2==0)

D:第19行代碼：elseif(m＜0)，第22行代碼：if(m%2!=0)

答案:第19行代碼：elseif(m＜0)，第22行代碼：if(m%2==0)

以下程序段中,與語句:k=a＞b?(b＞c?1:0):0;功能相同的是（）。

A:if((a＞b)||(b＞c))k=1;elsek=0;

B:if(a＞b)k=1;elseif(b＞c)k=1;elsek=0;

C:if((a＞b)&&(b＞c))k=1;elsek=0;

D:if(a＜=b)k=0;elseif(b＜=c)k=1;

答案:if((a＞b)&&(b＞c))k=1;elsek=0;

intx=1,a=0,b=0;

switch(x)

{

case0:b++;

case1:a++;

case2:a++;b++;

}

上面程序段執(zhí)行后，a，b的值分別是（）。

A:2,1

B:1,1

C:2,2

D:1,0

答案:2,1

intx=1,y=2,z=3;

switch(x=1){

case1:

switch(y==2){

case1:printf("*");break;

case2:printf("%");break;

}

case0:

switch(z){

case1:printf("$");break;

case2:printf("&");break;

default:printf("#");

}

}

上面程序段的運行結(jié)果是（）。

A:*$

B:*#

C:%#

D:$

答案:*#

第五章單元測試

關(guān)于while語句,錯誤的說法是（）。

A:循環(huán)體至少要執(zhí)行一次

B:可以用條件控制循環(huán)體的執(zhí)行次數(shù)

C:循環(huán)體可以是包含若干條語句的復(fù)合語句

D:循環(huán)體有可能一次也不執(zhí)行

答案:循環(huán)體至少要執(zhí)行一次

對于整型變量x,與while(！x)等價的是（）。

A:while(x！=0)

B:while(x==1)

C:while(x！=1)

D:while(x==0)

答案:while(x==0)

關(guān)于do-while循環(huán),以下敘述正確的是（）。

A:do-while循環(huán)由do開始,用while(表達(dá)式)結(jié)束,在while(表達(dá)式)后面必須寫分號

B:由于do-while循環(huán)中循環(huán)體語句只能是一條可執(zhí)行語句,所以循環(huán)體內(nèi)不能使用復(fù)合語句

C:do-while循環(huán)中,根據(jù)情況可以省略while后面的表達(dá)式3題

D:在do-while循環(huán)體中,一定要有能使while后面表達(dá)式的值變成零("假")的操作

答案:do-while循環(huán)由do開始,用while(表達(dá)式)結(jié)束,在while(表達(dá)式)后面必須寫分號

#include＜stdio.h＞

intmain()

{

intx,i;

for(x=3;x＜=100;x++){

if(x%2==0)_____;

for(i=2;i＜=x-1;i++)

if(x%i==0)_____;

if(i==x)printf("%d",x);

}

return0;

}

上面程序的功能是找出3～100間的素數(shù),程序中所缺的兩處應(yīng)為（）。

A:breakbreak

B:continuecontinue

C:breakcontinue

D:continuebreak

答案:continuebreak

設(shè)變量已正確定義,下面程序中能計算f=n!的是（）。

A:f=1;for(i=1;i＜n;i++)f*=i;

B:f=1;for(i=n;i＞1;i++)f*=i;

C:f=0;for(i=1;i＜=n;i++)f*=i;

D:f=1;for(i=n;i＞=2;i--)f*=i;

答案:f=1;for(i=n;i＞=2;i--)f*=i;

#include＜stdio.h＞

intmain()

{

intx,s=0;

for(x=1;x＜=5;x++){

switch(x%3){

case0:

default:s+=3;格式不對

case1:s+=1;break;

case2:s+=2;

}

}

printf("%d",s);

return0;

}

上面程序的運行結(jié)果是（）。

A:10

B:6

C:13

D:7

答案:10

#include＜stdio.h＞

intmain()

{

inti,j;

for(i=3;i＞=1;i--)

{

for(j=1;j＜=2;j++)

printf("%d",i+j);7題

printf("");

}

return0;

}

上面程序的運行結(jié)果是（）。

A:233445

B:234345

C:432543

D:453423

答案:453423

#include＜stdio.h＞

intmain()

{

inti=10,x=0;

for(;i＜10;i++)

x=x+i;

printf("%d",x);

return0;

}

上面程序運行后,循環(huán)體運行的次數(shù)為（）。

A:1

B:無限

C:0

D:10

答案:0

以下不是死循環(huán)的選項是（）。

A:for(;(c=getchar())!='\n';)printf("%c",c);

B:for(;;x+=k);

C:while(1){x++;}

D:for(k=10;;k--)sum=sum+k;

答案:for(;(c=getchar())!='\n';)printf("%c",c);

關(guān)于循環(huán)的控制，以下說法正確的是（）。

A:在循環(huán)體內(nèi)使用break和continue的作用相同

B:continue語句的作用是結(jié)束整個循環(huán)的執(zhí)行

C:從多層循環(huán)嵌套內(nèi)退出時,必須使用goto語句

D:只能在循環(huán)體內(nèi)和switch語句內(nèi)使用break語句

答案:只能在循環(huán)體內(nèi)和switch語句內(nèi)使用break語句

有關(guān)for語句中，正確的是（）。

A:for循環(huán)是先執(zhí)行循環(huán)體,后判斷表達(dá)式

B:for循環(huán)中,不能用break跳出循環(huán)體

C:for循環(huán)只能用于循環(huán)次數(shù)已經(jīng)確定的情況

D:for語句的循環(huán)體只能是一條語句

答案:for語句的循環(huán)體只能是一條語句

#include＜stdio.h＞

intmain()

{

inti=1,n=1;

for(;i＜3;i++)

{

continue;

n=n+i;

}

printf("%d",n);

return0;

}

上面程序運行后,變量n的值為（）。

A:1

B:4

C:3

D:2

答案:1

#include＜stdio.h＞

intmain()

{

intx,s;

for(x=0,s=0;x＜=10;x++)

{

if(x%3==0)

continue;

else

{

if(x%4==0)

continue;

elses+=x;

if(s%5==0)break;

}

}

printf("%d",s);

return0;

}

上面程序的運行結(jié)果是（）。

A:5

B:15

C:35

D:25

答案:15

#include＜stdio.h＞

intmain()

{

intx=012;

do

printf("%d",x--);

while(--x);

return0;

}

上面程序的運行結(jié)果是（）。

A:10864

B:8642

C:86420

D:108642

答案:108642

#include＜stdio.h＞

intmain()

{

ints=0,i=5;

while(s+=i,i-=2)

printf("%d",s);

return0;

}

上面程序的運行時,循環(huán)的執(zhí)行次數(shù)是（）。

A:15

B:無限次

C:9

D:5

答案:無限次

第六章單元測試

下面對于函數(shù)的描述中,正確的是（）。

A:函數(shù)的定義和函數(shù)的調(diào)用都可以嵌套

B:函數(shù)的定義不可以嵌套,但函數(shù)的調(diào)用可以嵌套

C:函數(shù)的定義和函數(shù)的調(diào)用都不可以嵌套

D:函數(shù)的定義可以嵌套,但函數(shù)的調(diào)用不可以嵌套

答案:函數(shù)的定義不可以嵌套,但函數(shù)的調(diào)用可以嵌套

fun(floatx)

{

floaty;

longz;

y=x*x;

z=(long)y;

return(z);

}

上面fun函數(shù)的類型是（）。

A:float

B:int

C:void

D:long

答案:int

以下函數(shù)聲明中正確的是（）。

A:doublefun(intx;inty);

B:doublefun(x,y);

C:doublefun(intx,y);

D:doublefun(intx,inty);

答案:doublefun(intx,inty);

有以下函數(shù)定義:voidfun(intn,doublex){…},若以下選項中的變量都已經(jīng)正確定義且賦值,則對函數(shù)fun的正確調(diào)用語句是（）。

A:fun(10,12.5);

B:voidfun(n,x);

C:k=fun(10,12.5);

D:fun(inty,doublem);

答案:fun(10,12.5);

#include＜stdio.h＞

inta=1,b=2;

voidswap(intc,intd)

{

intt;

t=a;a=b;b=t;

t=c;c=d;d=t;

}

intmain()

{

intc,d;

scanf("%d,%d",&c,&d);

swap(c,d);

printf("%d,%d,%d,%d\n",a,b,c,d);

return0;

}

假設(shè)用戶輸入5,3,則上面程序的運行結(jié)果是（）。

A:2,1,5,3

B:2,1,3,5

C:1,2,3,5

D:1,2,5,3

答案:2,1,5,3

#include＜stdio.h＞

voidfun(inta,intb)

{

intt;

a=456;

b=567;

t=a,a=b,b=t;

}

intmain()

{

intx=10,y=20;

fun(x,y);

printf("%d,%d\n",x,y);

return0;

}

上面程序的運行結(jié)果是（）。

A:567,456

B:456,567

C:10,20

D:20,10

答案:10,20

#include＜stdio.h＞

voidf(intx)

{}

intmain()

{

inta=1;

f(a);

return0;

}

對于上面的程序,以下說法正確的是（）。

A:x是實參,a是形參

B:x是形參,a是實參

C:x是形參,a也是形參

D:x是實參,a也是實參

答案:x是形參,a是實參

關(guān)于實參和形參，以下說法中不正確的是（）。

A:實參個數(shù)與形參個數(shù)必須相等

B:實參可以是常量、變量或表達(dá)式

C:實參類型應(yīng)與對應(yīng)的形參類型一致或兼容

D:形參可以是常量、變量或表達(dá)式

答案:形參可以是常量、變量或表達(dá)式

關(guān)于實參和形參占用內(nèi)存空間問題，以下說法正確的是（）。

A:若實參是變量,則它和對應(yīng)的形參各自占用獨立的存儲單元

B:形參是虛擬的,不占用存儲單元

C:實參與對應(yīng)的形參共用存儲單元

D:只有當(dāng)實參與對應(yīng)的形參同名時才共占用存儲單元

答案:若實參是變量,則它和對應(yīng)的形參各自占用獨立的存儲單元

#include＜stdio.h＞

longfib(intg)

{

switch(g)

{

case0:return0;

case1:

case2:return1;

}

return___________;

}

intmain()

{

longk;

k=fib(7);

printf("k=%ld\n",k);

}

上面的程序是用遞歸的方法求菲波拉契數(shù)列1、1、2、3、5、8……第7項fib(7),橫線處所缺的代碼是（）。

A:fib(7)

B:fib(g-1)+fib(g-2)

C:fib(g)+fib(g)

D:fib(g)+fib(g-1)

答案:fib(g-1)+fib(g-2)

函數(shù)中沒有return語句,則下面說法中正確的是（）。

A:該函數(shù)被調(diào)用時將返回一個不確定的值

B:該函數(shù)被調(diào)用時不會返回任何值

C:該函數(shù)被調(diào)用時將返回NULL

D:該函數(shù)被調(diào)用時將返回一個系統(tǒng)默認(rèn)值

答案:該函數(shù)被調(diào)用時將返回一個不確定的值

#include＜stdio.h＞

intfun(intn)

{

if(n==1)

return1;

else

return(n+fun(n-1));

}

intmain(){

intx;

scanf("%d",&x);

x=fun(x);

printf("%d",x);

return0;

}

若程序運行時鍵盤輸入10,則上面程序的運行結(jié)果是（）。

A:65

B:55

C:54

D:45

答案:55

若定義函數(shù)時不寫返回值的類型,則函數(shù)值的類型是（）。

A:long

B:void

C:int

D:double

答案:int

第七章單元測試

若在一個函數(shù)的復(fù)合語句中定義了一個變量，則該變量（）。

A:在本源文件范圍內(nèi)有效

B:在復(fù)合語句中定義非法

C:在整個函數(shù)中有效

D:只在該復(fù)合語句中有效

答案:只在該復(fù)合語句中有效

某源文件中定義了一個全局變量，其作用范圍是（）。

A:從定義處到本源文件結(jié)束

B:整個源文件的范圍

C:不知道有無聲明，所以不確定

D:所有源文件

答案:不知道有無聲明，所以不確定

在函數(shù)體中定義的局部變量，其作用范圍是（）。

A:定義它的函數(shù)內(nèi)

B:定義它的大括號內(nèi)

C:定義它的源文件內(nèi)

D:所有源文件

答案:定義它的大括號內(nèi)

關(guān)于函數(shù)的形參，下列說法正確的是（）。

A:形參只是一個符號，不是變量

B:形參是動態(tài)局部變量

C:形參是靜態(tài)局部變量

D:函數(shù)形參的聲明不在任何大括號內(nèi)，所以形參是全局變量

答案:形參是動態(tài)局部變量

定義局部變量時不指定存儲類型，則其存儲類型是（）。

A:extern

B:register

C:static

D:auto

答案:auto

關(guān)于靜態(tài)局部變量，正確的說法是（）。

A:其他三種說法都不對

B:執(zhí)行到它的作用域時分配空間，離開它的作用域時釋放空間

C:程序裝載時分配空間，程序結(jié)束時才釋放空間

D:從分配空間到程序結(jié)束，它一直存在，期間在任何地方都可以使用它

答案:程序裝載時分配空間，程序結(jié)束時才釋放空間

定義了一個變量但未賦初值，關(guān)于它的初值，下面說法正確的是（）。

A:若是靜態(tài)局部變量，則為0；若是自動變量或寄存器變量，則不確定

B:若是static型的全局變量，為0；若是extern型的全局變量，則不確定

C:若是動態(tài)存儲，則為0；若是靜態(tài)存儲，則不確定

D:若是全局變量，則為0；若是局部變量，則不確定

答案:若是靜態(tài)局部變量，則為0；若是自動變量或寄存器變量，則不確定

關(guān)于全局變量的生存期，下面說法正確的是（）。

A:從程序裝載到程序運行結(jié)束

B:取決于它定義的位置

C:從源文件開始執(zhí)行到源文件執(zhí)行結(jié)束

D:取決于它所在的源文件

答案:從程序裝載到程序運行結(jié)束

若全局變量定義時未規(guī)定屬性，則它的屬性是（）。

A:auto

B:register

C:static

D:extern

答案:extern

#include＜stdio.h＞

inta=2,b=3;

intmax(inta,intb)

{

intc;

c=a＞b?a:b;

printf("%d",c);

returnc;

}

intmain()

{

inta=4;

max(a,b);

printf("%d",max(a,b));

return0;

}

上面程序的運行結(jié)果是（）。

A:444

B:4

C:34

D:24

答案:444

intfac(intn)

{

staticintf=1;

f*=n;

returnf;

}

intmain()

{

inti,n;

for(i=1;i＜=5;i++)

n=fac(i);

printf("%d",n);

return0;

}

上面程序的運行結(jié)果是（）。

A:120

B:5

C:24

D:100

答案:120

根據(jù)變量的作用域可將變量分為（）。

A:全局變量和局部變量

B:自動變量和寄存器變量

C:靜態(tài)變量和動態(tài)變量

D:自動變量和臨時變量

答案:全局變量和局部變量

全局變量和局部靜態(tài)變量分配空間的時機(jī)是（）。

A:執(zhí)行到變量作用域的時候

B:主函數(shù)執(zhí)行時

C:裝載exe文件時

D:主函數(shù)結(jié)束時

答案:裝載exe文件時

在程序運行過程中不占內(nèi)存空間的變量是（）。

A:寄存器變量

B:全局變量

C:自動局部變量

D:靜態(tài)局部變量

答案:寄存器變量

允許在其它源文件中使用的是（）。

A:static型全局變量

B:register型變量

C:extern型全局變量

D:static型局部變量

答案:extern型全局變量

第八章單元測試

關(guān)于宏定義，下面說法正確的是（）。

A:宏定義不是語句，最后可以沒有分號

B:宏定義不是語句，最后不能有分號

C:宏定義雖是語句，但最后可以沒有分號

D:宏定義是一條語句，最后必須有分號

答案:宏定義不是語句，最后可以沒有分號

關(guān)于宏展開，下面說法錯誤的是（）。

A:宏展開可以發(fā)現(xiàn)宏定義中的錯誤

B:宏展開只是簡單地文本替換

C:宏展開不進(jìn)行語法檢查

D:宏展開不做數(shù)據(jù)類型的判別

答案:宏展開可以發(fā)現(xiàn)宏定義中的錯誤

設(shè)有宏定義

#definePI3.14159

在宏展開時，3.14159會被認(rèn)為是（）。

A:7個文字符號

B:單精度實數(shù)

C:雙精度實數(shù)

D:字符串

答案:7個文字符號

文件包含時，可以用＜＞也可以用""將被包含文件括起來，關(guān)于這兩種包含方式，下面說法正確的是（）。

A:能用＜＞的一般也可以用""

B:兩者作用相同

C:能用＜＞的不能用""，反之亦然

D:能用""的一般也可以用＜＞

答案:能用＜＞的一般也可以用""

文件包含命令中用＜＞包括被包含的文件，表示（）。

A:要到本源文件所在的目錄中查找它

B:其他三種說法都不對

C:到系統(tǒng)設(shè)定的包含目錄中查找它

D:既到系統(tǒng)設(shè)定的目錄中查找，又到本源文件所在目錄查找

答案:到系統(tǒng)設(shè)定的包含目錄中查找它

關(guān)于文件包含，下面說法錯誤的是（）。

A:被包含的文件可以是頭文件也可以是源文件

B:文件包含就是把被包含文件的內(nèi)容插入到包含命令所在處

C:文件包含可以用尖括號也可以用雙引號，但作用不同

D:同一個文件不允許用兩個#include命令包含兩次或兩次以上

答案:同一個文件不允許用兩個#include命令包含兩次或兩次以上

若有宏定義

#defineN2+1

則printf("%d",N*(N+1))的輸出結(jié)果是（）。

A:8

B:5

C:12

D:6

答案:6

有一種方法可以避免一個文件的內(nèi)容被包含兩次或以上，該方法除了文件包含命令外，還需要使用（）。

A:宏定義和分支結(jié)構(gòu)

B:條件編譯

C:宏定義和條件編譯

D:宏定義

答案:宏定義和條件編譯

下面關(guān)于條件編譯的說法，正確的是（）。

A:條件編譯兩個分支中若都有代碼，則這兩部分代碼都要參加編譯

B:條件編譯就是在正式編譯時，根據(jù)條件選擇一部分代碼留下參與編譯，另一部分舍棄

C:若一個程序既能寫成條件編譯，又能寫成分支結(jié)構(gòu)，則用條件編譯寫成的源程序比用分支結(jié)構(gòu)寫成的源程序生成的可執(zhí)行文件更短

D:條件編譯就是在程序執(zhí)行時，根據(jù)條件選擇一部分代碼執(zhí)行，另一部分不執(zhí)行

答案:若一個程序既能寫成條件編譯，又能寫成分支結(jié)構(gòu)，則用條件編譯寫成的源程序比用分支結(jié)構(gòu)寫成的源程序生成的可執(zhí)行文件更短

若有定義

#defineM(n)a=n*2

inta;

則printf("%d",M(5+1)*3)的輸出結(jié)果是（）。

A:其他三個答案都不對

B:36

C:21

D:11

答案:11

第九章單元測試

下面四段程序中，能正確輸出變量a的值的是（）。

A:inta=1,*p;*p=&a;printf("%d",*p);

B:inta=1,*p;*p=a;printf("%d",*p);

C:inta=1,*p=a;printf("%d",*p);

D:inta=1,*p=&a;printf("%d",*p);

答案:inta=1,*p=&a;printf("%d",*p);

關(guān)于指針和指針變量，下面說法正確的是（）。

A:指針和指針變量是同一個東西

B:指針和指針變量各自有各自的范疇，互相之間沒有關(guān)系

C:指針變量的范疇包含著指針的范疇

D:指針的范疇包含著指針變量的范疇

答案:指針的范疇包含著指針變量的范疇

關(guān)于直接尋址和間接尋址，下面說法錯誤的是（）。

A:直接尋址比間接尋址直觀

B:直接尋址不需要指針

C:間接尋址必須用指針

D:間接尋址比直接尋址高效

答案:間接尋址比直接尋址高效

關(guān)于指針變量的屬性以及它是否占用內(nèi)存空間，下面說法正確的是（）。

A:指針變量的值是一個整數(shù)

B:指針變量既有值，又有地址

C:char*型的指針變量，占1字節(jié)的內(nèi)存空間

D:指針變量不占內(nèi)存空間

答案:指針變量既有值，又有地址

要定義兩個指針變量，下面代碼正確的是（）。

A:int*p1,int*p2;

B:int*p1,*p2;

C:int*p1,p2;

D:int*(p1，p2);

答案:int*p1,*p2;

若有定義：

int*p;

則以下說法正確的是（）。

A:變量類型是int

B:變量名是p

C:變量名是*p

D:變量的基類型是int*

答案:變量名是p

關(guān)于指針變量指向哪里，下面說法正確的是（）。

A:若定義指針變量（局部自動型）但是不賦值，則它指向內(nèi)存0單元處

B:若定義指針變量并且賦值為NULL，表示它指向內(nèi)存0單元處的對象

C:若定義指針變量（局部自動型）但是不賦值，則它不指向任何對象

D:若定義指針變量并且賦值為NULL，表示它不指向任何實際對象

答案:若定義指針變量并且賦值為NULL，表示它不指向任何實際對象

若有定義

intx,*p;

則能使p指向x的表達(dá)式是（）。

A:p=*x

B:p=&x

C:*p=x

D:p=x

答案:p=&x

若有定義：

int*p,a=1,b;

則以下正確的程序段是（）。

A:p=&b;scanf("%d"，&p);

B:p=&b;scanf("%d"，p);

C:p=&b;scanf("%d"，*p);

D:scanf("%d",&b）;*p=b;

答案:p=&b;scanf("%d"，p);

若有定義：

inta=511,*b=&a;

則printf("%d\n",*b)的輸出結(jié)果為（）。

A:511

B:不確定值

C:b的地址

D:a的地址

答案:511

第十章單元測試

以下對一維數(shù)組a的定義中，正確的是（）。

A:intk=10;inta[k];

B:inta[5];

C:chara(10);

D:inta[0..100];

答案:inta[5];

以下對一維數(shù)組的定義中，不正確的是（）。

A:doublex[5]={2.0,4.0,6.0,8.0,10.0};

B:inty[5]={0,1,3,5,7,9};

C:charch1[]={'1','2','3','4','5'};

D:charch2[]={'\x10','\xa','\x8'};

答案:inty[5]={0,1,3,5,7,9};

以下對二維數(shù)組的定義中，正確的是（）。

A:inta[][3]={1，2，3，4，5，6};

B:inta[][3];

C:inta[][]＝{{1,2,3},{4,5,6}}

D:inta[4][]={1，2，3，4，5，6};

答案:inta[][3]={1，2，3，4，5，6};

假定一個int型變量占用兩個字節(jié)，若有定義：intx[10]={0,2,4};則數(shù)組x在內(nèi)存中所占字節(jié)數(shù)是（）。

A:3

B:6

C:20

D:10

答案:20

#include＜stdio.h＞

intmain()

{

inta[4][4]={{1,3,5},{2,4,6},{3,5,7}};

printf("%d%d%d%d\n",a[0][3],a[1][2],a[2][1],a[3][0]);

return0;

}

上面程序的運行結(jié)果是（）。

A:5430

B:輸出結(jié)果不確定

C:0650

D:1470

答案:0650

#include＜stdio.h＞

intmain()

{

intm[][3]={1,4,7,2,5,8,3,6,9};

inti,j,k=2;

for(i=0;i＜3;i++){

printf("%d",m[k][i]);

}

return0;

}

上面程序的運行結(jié)果是（）。

A:258

B:789

C:456

D:369

答案:369

#include＜stdio.h＞

intmain()

{

intb[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=0;

for(i=0;i＜3;i++)

for(j=i;j＜=i;j++)

t=t+b[i][b[j][j]];

printf("%d\n",t);

return0;

}

上面程序的輸出結(jié)果是（）。

A:3

B:4

C:1

D:9

答案:3

若有定義：inta[2][4];，則引用下標(biāo)變量正確的是（）。

A:a[0][3]

B:a[2][2]

C:a[0][4]

D:a[2][2+1]

答案:a[0][3]

若有定義：intaa[8];，則不能代表數(shù)組元素aa[1]地址的是（）。

A:&aa[1]

B:&aa[0]+1

C:aa+1

D:&aa[0]++

答案:&aa[0]++

若二維數(shù)組y有m列，則排在y[i][j]前的變量個數(shù)為（）。

A:i*m+j+1

B:i*m+j-1

C:i*m+j

D:j*m+i

答案:i*m+j

若想定義一個名為s且初值為字符串"123"的字符數(shù)組，則下列定義錯誤的是（）。

A:chars[]={’1'，'2'，'3'，'\0'}

B:chars[]={"123\n"};

C:chars[4]={'1'，'2'，'3'}

D:chars[]={"123"};

答案:chars[]={"123\n"};

關(guān)于數(shù)組，下列描述中不正確的是（）。

A:不能在賦值語句中通過賦值運算符"="對字符型數(shù)組進(jìn)行整體賦值

B:字符型數(shù)組中可以存放字符串

C:可以對字符串進(jìn)行整體輸入、輸出

D:可以對整型數(shù)組進(jìn)行整體輸入、輸出

答案:可以對整型數(shù)組進(jìn)行整體輸入、輸出

語句printf("%d\n",strlen("school"));的輸出結(jié)果是（）。

A:6

B:存在語法錯誤

C:7

D:不確定值

答案:6

若有語句：chars1[10],s2[10]="books";，則能將字符串books存入數(shù)組s1的語句是（）。

A:s1="books"

B:s1=s2

C:strcpy(s1,s2);

D:strcpy(s2,s1)

答案:strcpy(s1,s2);

若有定義inta[3][4];則能輸入其第3行第2列元素（這是生活中計數(shù)方式）的正確語句為（）。

A:scanf("%d",a[3,2])

B:scanf("%d",*(*(a+2)+1))

C:scanf("%d",*(a[2]+1))

D:scanf("%d",*(a+2)+1)

答案:scanf("%d",*(a+2)+1)

設(shè)有定義：chars[12]="string";則printf("%d,%d",strlen(s),sizeof(s));的輸出結(jié)果是（）。

A:12,7

B:7,12

C:12,12

D:6,12

答案:6,12

語句strcat(strcpy(str1,str2),str3);的功能是（）。

A:將字符串str1連接到字符串str2中后再復(fù)制到字符串str3之后

B:將字符串str2復(fù)制到字符串str1后再將字符串str3連接到字符串str1之后

C:將字符串str1復(fù)制到字符串str2中后再連接到字符串str3之后

D:將字符串str2連接到字符串str1后再將字符串str1復(fù)制到字符串str3中。

答案:將字符串str2復(fù)制到字符串str1后再將字符串str3連接到字符串str1之后

若有如下定義：charx[]="abcdefg";chary[]={'a','b','c','d','e','f','g'};，則正確的敘述為:（）。

A:數(shù)組x和數(shù)組y的長度相同

B:數(shù)組x和數(shù)組y等價

C:數(shù)組y的長度大于數(shù)組x的長度

D:數(shù)組x的長度大于數(shù)組y的長度

答案:數(shù)組x的長度大于數(shù)組y的長度

第十一章單元測試

若有語句int*point,a=4;和point=&a;下面均代表指針的一組選項是（）。

A:&*a,&a,*point

B:a,point,*&a

C:&a,&*point,point

D:*&point,*point,&a

答案:&a,&*point,point

有以下程序段

inta[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;

b=p[5];

執(zhí)行后b中的值是（）。

A:8

B:5

C:6

D:9

答案:9

若有定義inta[5],*p=a;則對a數(shù)組元素的正確引用是（）。

A:*(p+5)

B:*(a+2)

C:a+2

D:a[5]

答案:*(a+2)

若有定義inta[7],*p=a;則p+5表示（）。

A:元素a[6]的值

B:元素a[6]的指針

C:元素a[5]的指針

D:元素a[5]的值

答案:元素a[5]的指針

設(shè)已有定義:inta[10]={15,12,7,31,47,20,16,28,13,19}，*p;則下列語句中正確的是（）。

A:for(p=a;p＜(a+10);p++);

B:for(p=a;a＜(p+10);a++);

C:for(p=a;a＜p+10;++a);

D:for(p=a,a=a+10;p＜a;p++);

答案:for(p=a;p＜(a+10);p++);

#include＜stdio.h＞

intmain()

{

intx[]={10,20,30};

int*px=x;

printf("%d,",++*px);printf("%d,",*px);

px=x;

printf("%d,",(*px)++);printf("%d,",*px);

px=x;

printf("%d,",*px++);printf("%d,",*px);

px=x;

printf("%d,",*++px);printf("%d\n",*px);

return0;

}

上面程序運行后的輸出結(jié)果是（）。

A:20,10,11,20,11,12,20,20

B:11,11,11,12,12,13,20,20

C:11,11,11,12,12,20,20,20

D:20,10,11,10,11,10,11,10

答案:11,11,11,12,12,20,20,20

#include＜stdio.h＞

intmain()

{

intarr[]={6,7,8,9,10};

int*ptr;

ptr=arr;

*(ptr+2)+=2;

printf("%d,%d\n",*ptr,*(ptr+2));

return0;

}

上面程序的運行結(jié)果為（）。

A:6,10

B:6,8

C:7,9

D:8,10

答案:6,10

有以下定義

chara[10],*b=a;

則不能給數(shù)組a輸入字符串的語句是（）。

A:gets(b)

B:gets(a[0])

C:gets(&a[0])

D:gets(a)

答案:gets(a[0])

#include＜stdio.h＞

intmain()

{

chara[]="programming",b[]="language";

char*p1,*p2;

inti;

p1=a;

p2=b;

for(i=0;i＜7;i++)

if(*(p1+i)==*(p2+i))

printf("%c",*(p1+i));

return0;

}

上面程序輸出結(jié)果是（）。

A:gm

B:or

C:ga

D:rg

答案:ga

第十二章單元測試

char*s="abcde";

s+=2;printf("%d",s);

上面程序段的輸出結(jié)果是（）。

A:字符串的后半部分：cde

B:字符'c'的地址

C:不確定的輸出結(jié)果

D:字符'c'

答案:字符'c'的地址

#include＜stdio.h＞

#include＜string.h＞

intmain()

{

char*s1="AbDeG";

char*s2="AbdEg";

s1+=2;

s2+=2;

printf("%d\n",strcmp(s1,s2));

return0;

}

上面程序的運行結(jié)果是一個（）。

A:0

B:負(fù)數(shù)

C:不確定值

D:正數(shù)

答案:負(fù)數(shù)

若有代碼：

chara[]="Itismine";

char*p="Itismine";

則以下錯誤的敘述是（）。

A:p中只能存放10個字符

B:p可以指向另外的字符串，并且另外的字符串的長度不受限制

C:p變量中存放的地址值可以改變

D:a+1是字符t的指針

答案:p中只能存放10個字符

若有以下代碼：intc[4][5],(*p)[5];p=c;則能正確引用下標(biāo)變量的是（）。

A:p+1

B:*(p+1)+3

C:*(p[0]+2))

D:*(p+3)

答案:*(p[0]+2))

若有定義：inta[2][3];則屬于a數(shù)組的第i行j列元素的指針的表達(dá)式是（）。

A:*(a+j)

B:*(a[i]+j)

C:(a+i)

D:a[i]+j

答案:a[i]+j

設(shè)已有定義:char*st="howareyou";則下列程序段中能正確執(zhí)行不越界的是（）。

A:chara[11];strcpy(a,st);

B:chara[11],*p;strcpy(p=a+1,&st[4]);

C:chara[15];strcpy(++a,st)；

D:chara[],*p;strcpy(p=&a[1],st+2);

答案:chara[11],*p;strcpy(p=a+1,&st[4]);

設(shè)變量p1和p2指向同一個字符串的首字母，c為字符變量，則以下不能正確執(zhí)行的賦值語句是（）。

A:c=*p1+*p2;

B:p1=p2;

C:c=*p1*(*p2);

D:p2=c;

答案:p2=c;

以下四個程序段中，能正確執(zhí)行的是（）。

A:charstr[20];scanf("%s",&str[2]);

B:charstr[20],*p=str;scanf("%s",*p);

C:char*p;scanf("%s",p);

D:charstr[20],*p=str;scanf("%s",p[2]);

答案:charstr[20];scanf("%s",&str[2]);

若有int**pp;int*p,a=1;p=&a;則能使pp指向變量p的代碼是（）。

A:pp=&p;

B:pp=*p;

C:pp=p;

D:*pp=p;

答案:pp=&p;

已定義以下函數(shù)

int*fun(int*p)

{

returnp;

}

該函數(shù)的返回值是（）。

A:形參p中存放的整數(shù)

B:形參p所指單元的地址

C:形參p所指單元中的值

D:形參p的地址

答案:形參p所指單元的地址

若有以下函數(shù)首部

intfun(doublex[10],int*n)

則下面針對此函數(shù)的函數(shù)聲明語句中正確的是（）。

A:intfun(double,int)

B:intfun(double*,int*);

C:intfun(doublex,int*n);

D:intfun(double*x,intn);

答案:intfun(double*,int*);

intmain()

{

chara;

char*str=&a;

strcpy(str,"hello");

printf(str);

return0;

}

上面程序的運行結(jié)果是（）。

A:h

B:運行時出現(xiàn)異常錯誤

C:hell

D:Null

答案:運行時出現(xiàn)異常錯誤

下面選項中屬于函數(shù)指針的是（）。

A:int*p;

B:int(*p)(int);

C:(int*)p(int,int);

D:int*p(int,int);

答案:int(*p)(int);

若有函數(shù)max(a,b)，并且已使函數(shù)指針變量p指向函數(shù)max，當(dāng)調(diào)用該函數(shù)時，正確的調(diào)用方法是（）。

A:(*p)(a,b);

B:*p(a,b);

C:*p(max(a,b));

D:(*p)max(a,b);

答案:(*p)(a,b);

對于語句int*pa[5]；下列描述中正確的是（）。

A:pa是一個具有5個元素的指針數(shù)組，每個元素是一個int*型指針

B:pa是一個指向某數(shù)組中第5個元素的指針，該元素是int型變量

C:pa是一個指向數(shù)組的指針，所指向的數(shù)組有5個int型元素

D:pa[5]表示某個元素的第5個元素的值

答案:pa是一個具有5個元素的指針數(shù)組，每個元素是一個int*型指針

第十三章單元測試

下列對結(jié)構(gòu)類型變量不正確的定義是（）。

A:struct{

intnum;

intage;}teacher1,teacher2;

B:structteacher{

intnum,age;

}a;

C:struct{

intnum;

intage;

}teacher

D:structteacher{

intnum;

intage;

}teacher1;

答案:struct{

intnum;

intage;

}teacher

設(shè)有以下定義語句：

structstudent{

intnum;

charname[10];

floatscore;

}wang,zhang;

則變量wang所占的內(nèi)存字節(jié)數(shù)（注：在VC環(huán)境下要考慮內(nèi)存對齊規(guī)則）是（）。

A:18

B:20

C:10

D:24

答案:20

假設(shè)有如下的定義：

struct{

intn;

charc;

floatf;

}rec;

則以下各個輸入語句中，正確的是（）。

A:scanf("%d",rec);

B:scanf("%c",&rec.c);

C:scanf("%f",&rec);

D:scanf("%s",&rec.c);

答案:scanf("%c",&rec.c);

#include＜stdio.h＞

structabc{

inta,b,c;

};

intmain()

{structabcs[2]={{1,2,3},{4,5,6}};

intt;

t=s[0].a+s[1].b;

printf("%d\n",t);

return0;

}

上面程序的輸出結(jié)果是（）。

A:8

B:7

C:6

D:5

答案:6

有以下說明和定義語句

structstudent{

intage;

charnum[8];

};

structstudentstu[3]={{20,"200401"},{21,"200402"},{19,"200403"}};

structstudent*p=stu;

則以下選項中引用結(jié)構(gòu)體變量成員錯誤的是（）。

A:(p++)-＞num

B:p-＞num

C:(*p).num

D:stu[2]-＞age

答案:stu[2]-＞age

structperson{

charname[9];

intage;

};

structpersonclass[10]={"John",17,"Paul",19,"Mary",18,"Adam",16};

根據(jù)上面的定義，能打印出字母M的語句是（）。

A:printf("%c\n",class[2].name[1]);

B:printf("%c\n",class[3].name[1]);

C:printf("%c\n",class[3].name);

D:printf("%c\n",class[2].name[0]);

答案:printf("%c\n",class[2].name[0]);

若有以下程序段：

structst{

intn;

int*m;

};

inta=2,b=3,c=5;

structsts[3]=({101,&a},{102,&b},{103,&c});

intmain(){

structst*p;

p=s;

...

}

則以下表達(dá)式中值為5的是（）。

A:*((p+2).m)

B:*((p+2)-＞n)

C:*((p+2)-＞m)

D:((p+2)-＞m)

答案:*((p+2)-＞m)

union{

shortm;

chara[8];

}a,*p=&a;

a.m=100;

a.a[0]='A’;

p-＞a[1]=1;

printf("%d,%d",sizeof(a),a.m);

上面程序的運行結(jié)果是（）。

A:8,65

B:10,100

C:8,100

D:8,321

答案:8,321

以下對共用體類型數(shù)據(jù)的描述中，錯誤的是（）。

A:共用體類型的定義可以出現(xiàn)在結(jié)構(gòu)類型定義中

B:共用體變量所占的內(nèi)存大小，等于占用內(nèi)存最多的成員所占的內(nèi)存大小

C:同一個共用體變量中，各成員長度不同，所以它們的首地址是不相同的

D:在定義共用體變量的同時允許對它的第一個成員進(jìn)行初始化

答案:同一個共用體變量中，各成員長度不同，所以它們的首地址是不相同的

intmain()

{

structcmplx{intx;inty;}

cnum[2]={1,3,2,7};

printf("%d\n",cnum[0].y/cnum[0].x*cnum[1].x);

return0;

}

上面程序的輸出結(jié)果是（）。

A:3

B:1

C:0

D:6

答案:6

#include＜stdio.h＞

unionutype{

inti;

floatf;

}u[2];

intmain(){

printf("%d\n",sizeof(u));

return0;

}

在VC環(huán)境下上面程序的運行結(jié)果是（）。

A:6

B:4

C:8

D:16

答案:8

unionU{

shorta;

charb[4];

}u;

u.b[0]=2;

u.b[1]=1;

u.b[2]=3;

printf("%hd\n",u.a);

VC中，上面程序的執(zhí)行結(jié)果是（）。

A:513

B:其他三個答案都不對

C:258

D:130

答案:258

關(guān)于typedef，以下敘述中錯誤的是（）。

A:用typedef定義新的類型名后，原有類型名仍有效

B:可以通過typedef增加新的類型

C:可以用typedef將已存在的類型名用一個新的名字來代表

D:用typedef可以給各種已有類型起別名，但不能給變量起別名

答案:可以通過typedef增加新的類型

設(shè)有以下語句

typedefstructS{

intg;

charh;

}T;

則下面敘述中正確的是（）。

A:可用S定義結(jié)構(gòu)體變量

B:S是struct類型的變量

C:可以用T定義結(jié)構(gòu)體變量

D:T是structS類型的變量

答案:可以用T定義結(jié)構(gòu)體變量

設(shè)有以下定義語句

structstudent{

intnum;

charname[8];

floatscore;

}a[2];

則在VC環(huán)境下數(shù)組a所占內(nèi)存的字節(jié)數(shù)是（）。

A:40

B:16

C:20

D:32

答案:32

第十四章單元測試

表達(dá)式7&&8和7&8的值分別是（）。

A:01

B:10

C:00

D:11

答案:10

表達(dá)式7||8和7|8的值分別是（）。

A:01

B:11

C:115

D:015

答案:115

表達(dá)式7^16的值是（）。

A:23

B:1

C:21

D:0

答案:23

intmain()

{

charx=040;

printf("%d\n",x=(x＜＜1));

return0;

}

以上程序的輸出結(jié)果是（）。

A:100

B:64

C:160

D:120

答案:64

若有定義：

inta=20,b=28,C;

則執(zhí)行語句C=(a&b)＞＞2;后C的值為（）。

A:5

B:112

C:80

D:7

答案:5

chara=3,b=6,c;

c=a^b＜＜2;

以上程序執(zhí)行后c的二進(jìn)制值是（）。

A:00010100

B:000