程序設計基礎（山東工商學院）智慧樹知到課后章節(jié)答案2023年下山東工商學院

程序設計基礎（山東工商學院）智慧樹知到課后章節(jié)答案2023年下山東工商學院山東工商學院

第一章測試

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

A:語法錯誤

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

C:邏輯錯誤

D:運行錯誤

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

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

A:至少一個

B:必須兩個以上

C:0個

D:1個

答案:至少一個

關于C語言，以下描述中錯誤的是（）。

A:C語言的注釋通常是以"/*"開始并以"*/"結束

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

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

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

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

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

A:擴展名為c的文件

B:擴展名為obj的文件

C:擴展名為txt的文件

D:擴展名為exe的文件

答案:擴展名為exe的文件

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

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

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

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

D:C語句必須以分號結束

答案:C語句必須以分號結束

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

A:編譯錯誤

B:連接錯誤

C:邏輯錯誤

D:語法錯誤

答案:邏輯錯誤

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

A:C89標準對于上述兩種語句的位置沒有要求

B:C99標準規(guī)定：所有數(shù)據(jù)定義語句必須在任何非數(shù)據(jù)定義語句的前面

C:C89標準規(guī)定：有些必須放在前面，有些可以放在后面

D:C89標準規(guī)定：所有數(shù)據(jù)定義語句必須在任何非數(shù)據(jù)定義語句的前面

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

在C語言程序中（）。

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

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

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

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

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

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

A:高級語言

B:匯編語言

C:面向對象語言

D:機器語言

答案:高級語言

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

A:/*

B:/**/

C:\

D://

答案:/**/

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

A:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！");

return0;

}

B:#include＜stdio.h＞

intmain()；

{

/*programming/*

printf("programming！")；

return0;

}

C:include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！")；

return0;

}

D:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！")

return0;

}

答案:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n");

return0;

}

第二章測試

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

A:b-b

B:float

C:_isw

D:123asd

答案:_isw

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

A:constinta=1;

B:intconsta=1;

C:constinta;a=1;

D:constinta;

答案:constinta=1;

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

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

B:x=y=z=5;

C:intx=y=z=5;

D:intx,y,z=5;

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

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

A:#defineN3

B:#defineN=3

C:#defineN3;

D:defineN3

答案:#defineN3

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

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

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

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

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

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

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

A:-0xcdf,01A,0xe

B:-0x48A,2e5,0x

C:-01,012,0668

D:160,-0xffff,011

答案: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

關于字符串"CHINA"，下面說法正確的是（）。

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

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

C:其他三個說法都不對

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

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

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

A:%和/

B:%

C:/

D:*

答案:%

intx=10,y=3;

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

上面程序段的運行結果是（）。

A:102

B:10,3

C:9,3

D:10,2

答案:10,2

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

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

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

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

A:2,50

B:50,2

C:3,2

D:2,2

答案:2,2

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

A:6

B:5

C:8

D:7

答案:6

關于表達式a*=b+c，下面說法正確的是（）。

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

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

C:其他三個說法都不對

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

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

若有定義

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

則正確的賦值表達式是（）。

A:6=a

B:(a+b)=c*8

C:b=10

D:a=(b+c)*6

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

關于算術運算，下面四個說法中正確的是（）。

A:-5/3的結果是-2

B:1/2的結果是0

C:5.0/9的結果是0

D:20*3%7，應先計算3%7

答案:1/2的結果是0

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

A:其他三個答案都不對

B:4

C:6

D:2

答案:4

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

A:double

B:char

C:int

D:float

答案:double

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

charc1=65,c2=66;

inta1=1,a2=2;

floatx1=1.1,x2=2.2;

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

A:a1+a2

B:c1+a1

C:c1+c2

D:x1+x2

答案:a1+a2

第三章測試

charx=0xffff;

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

上面程序段的運行結果是（）。

A:-32768

B:-1

C:-32767

D:fffe

答案:-1

doubled;

floatf;

longl;

inti;

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

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

上面程序段的運行結果是（）。

A:6,6,6.7,6.0

B:6,6,6.7,6.7

C:6,6,6.0,6.7

D:6,6,6.0,6.0

答案:6,6,6.0,6.0

unsigneda=65535;

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

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

A:65535,177777,ffff

B:-1,65535,ffff

C:-1,177777,ffff

D:65535,65535,65535

答案:-1,177777,ffff

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

A:putchar()不能對轉義字符進行操作

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

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

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

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

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

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

B:getchar(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，則正確的鍵盤輸入應該是（）。

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

B:1,2,3＜Enter＞

C:1＜Enter＞2＜Enter＞3＜Enter＞

D:12＜Tab＞3＜Enter＞

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

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

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

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

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

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

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

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

A:%X

B:%E

C:%D

D:%f

答案:%D

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

A:12,34,56

B:1,34,7

C:12,34,78

D:1,34,78

答案:12,34,78

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

c1=getchar();

c2=getchar();

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

A:程序將等待輸入第二個字符

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

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

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

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

inti;

floatf;

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

上面程序段準備把10和5.12分別存給i和f，則正確的輸入應是（）。

A:10＜Enter＞5.12＜Enter＞

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

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

D:10＜空格＞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:2223，a,123o.12

B:2223,a,原值

C:原值不變

D:2223,a,123

答案:2223,a,123

第四章測試

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

f=a＞b＞c;

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

A:2

B:1

C:0

D:不確定

答案: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;

}

上面程序的運行結果是（）。

A:0,2

B:1,1

C:0,0

D:1,0

答案:1,0

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

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

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

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

D:intx=5,y=2;if(x)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:3;

B:1

C:2

D:0

答案:2

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

if(x＞y)

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

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

A:20,30,30

B:20,10,10

C:10,20,30;

D:20,30,10

答案:20,30,30

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

A:!&&||

B:&&!||

C:!||&&

D:||&&!

答案:!&&||

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

if(表達式)語句

其中“表達式”（）。

A:必須是邏輯表達式或關系表達式

B:必須是邏輯表達式

C:可以是任意合法的表達式

D:必須是關系表達式

答案:可以是任意合法的表達式

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

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

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

C:(w==1)?(--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:0

B:NULL

C:1

D:-1

答案:0

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

y*=x;

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

A:2,4

B:賦值號級別低于&&，導致代碼存在語法錯誤第10題

C:5,10

D:5,2

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

intx,y;

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

if(x＞y)

x=y;y=x;

else

x++;y++;

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

關于上面程序段，下列說法正確的是（）。

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

B:有語法錯誤

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._______________//判斷是否為負數(shù)

20.

21.{

22._______________

23.

24.{

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

26.}

27.else

28.{

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

30.}

31.}

32.else

33.{

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

35.}

36.return0;

37.}

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

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

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

C:第19行代碼：elseif(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:1,0

D:2,2

答案: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("#");

}

}

上面程序段的運行結果是（）。

A:$

B:*#

C:*$

D:%#

答案:*#

第五章測試

關于while語句,錯誤的說法是（）。

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

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

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

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

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

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

A:while(x！=0)

B:while(x==1)

C:while(x==0)

D:while(x！=1)

答案:while(x==0)

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

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

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

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

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

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

#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ù),程序中所缺的兩處應為（）。

A:breakcontinue

B:continuecontinue

C:breakbreak

D:continuebreak

答案:continuebreak

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

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

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

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

D:f=1;for(i=1;i＜n;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;

}

上面程序的運行結果是（）。

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;

}

上面程序的運行結果是（）。

A:432543

B:233445

C:453423

D:234345

答案:453423

#include＜stdio.h＞

intmain()

{

inti=10,x=0;

for(;i＜10;i++)

x=x+i;

printf("%d",x);

return0;

}

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

A:無限

B:1

C:0

D:10

答案:0

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

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

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

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

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

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

有關for語句中，正確的是（）。

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

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

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

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

答案: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:3

B:1

C:4

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;

}

上面程序的運行結果是（）。

A:35

B:25

C:15

D:5

答案:15

#include＜stdio.h＞

intmain()

{

intx=012;

do

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

while(--x);

return0;

}

上面程序的運行結果是（）。

A:86420

B:8642

C:108642

D:10864

答案:108642

#include＜stdio.h＞

intmain()

{

ints=0,i=5;

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

printf("%d",s);

return0;

}

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

A:5

B:無限次

C:15

D:9

答案:無限次

第六章測試

下面對于函數(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:int

B:float

C:void

D:long

答案:int

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

A:doublefun(intx;inty);

B:doublefun(intx,inty);

C:doublefun(intx,y);

D:doublefun(x,y);

答案:doublefun(intx,inty);

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

A:voidfun(n,x);

B:fun(10,12.5);

C:fun(inty,doublem);

D:k=fun(10,12.5);

答案: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;

}

假設用戶輸入5,3,則上面程序的運行結果是（）。

A:2,1,3,5

B:2,1,5,3

C:1,2,5,3

D:1,2,3,5

答案: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;

}

上面程序的運行結果是（）。

A:20,10

B:456,567

C:567,456

D:10,20

答案: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是實參

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

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

B:實參可以是常量、變量或表達式

C:實參類型應與對應的形參類型一致或兼容

D:形參可以是常量、變量或表達式

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

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

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

B:實參與對應的形參共用存儲單元

C:只有當實參與對應的形參同名時才共占用存儲單元

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

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

#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)默認值

答案:該函數(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,則上面程序的運行結果是（）。

A:65

B:54

C:45

D:55

答案:55

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

A:int

B:void

C:long

D:double

答案:int

第七章測試

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

A:在復合語句中定義非法

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

C:只在該復合語句中有效

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

答案:只在該復合語句中有效

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

A:從定義處到本源文件結束

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

C:所有源文件

D:整個源文件的范圍

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

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

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

B:所有源文件

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

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

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

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

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

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

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

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

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

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

A:auto

B:extern

C:static

D:register

答案:auto

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

A:其他三種說法都不對

B:程序裝載時分配空間，程序結束時才釋放空間

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

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

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

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

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

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

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

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

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

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

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

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

C:從程序裝載到程序運行結束

D:取決于它定義的位置

答案:從程序裝載到程序運行結束

若全局變量定義時未規(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;

}

上面程序的運行結果是（）。

A:4

B:444

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;

}

上面程序的運行結果是（）。

A:120

B:5

C:100

D:24

答案:120

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

A:全局變量和局部變量

B:自動變量和臨時變量

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

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

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

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

A:主函數(shù)結束時

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

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

D:裝載exe文件時

答案:裝載exe文件時

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

A:寄存器變量

B:自動局部變量

C:全局變量

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

答案:寄存器變量

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

A:static型局部變量

B:extern型全局變量

C:register型變量

D:static型全局變量

答案:extern型全局變量

第八章測試

關于宏定義，下面說法正確的是（）。

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

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

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

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

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

關于宏展開，下面說法錯誤的是（）。

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

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

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

D:宏展開不進行語法檢查

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

設有宏定義

#definePI3.14159

在宏展開時，3.14159會被認為是（）。

A:7個文字符號

B:字符串

C:雙精度實數(shù)

D:單精度實數(shù)

答案:7個文字符號

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

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

B:兩者作用相同

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

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

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

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

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

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

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

D:其他三種說法都不對

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

關于文件包含，下面說法錯誤的是（）。

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

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

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

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

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

若有宏定義

#defineN2+1

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

A:12

B:6

C:5

D:8

答案:6

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

A:宏定義和分支結構

B:條件編譯

C:宏定義和條件編譯

D:宏定義

答案:宏定義和條件編譯

下面關于條件編譯的說法，正確的是（）。

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

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

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

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

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

若有定義

#defineM(n)a=n*2

inta;

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

A:其他三個答案都不對

B:36

C:11

D:21

答案:11

第九章測試

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

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

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

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

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

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

關于指針和指針變量，下面說法正確的是（）。

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

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

C:指針和指針變量各自有各自的范疇，互相之間沒有關系

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

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

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

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

B:直接尋址不需要指針

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

D:間接尋址必須用指針

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

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

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

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

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

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

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

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

A:int*p1,p2;

B:int*p1,int*p2;

C:int*(p1，p2);

D:int*p1,*p2;

答案:int*p1,*p2;

若有定義：

int*p;

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

A:變量類型是int

B:變量名是*p

C:變量的基類型是int*

D:變量名是p

答案:變量名是p

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

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

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

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

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

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

若有定義

intx,*p;

則能使p指向x的表達式是（）。

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)的輸出結果為（）。

A:a的地址

B:不確定值

C:511

D:b的地址

答案:511

第十章測試

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

A:intk=10;inta[k];

B:inta[0..100];

C:chara(10);

D:inta[5];

答案:inta[5];

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

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

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

C:inta[][3];

D:inta[][3]={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:10

C:6

D:20

答案: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;

}

上面程序的運行結果是（）。

A:0650

B:輸出結果不確定

C:5430

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;

}

上面程序的運行結果是（）。

A:789

B:369

C:456

D:258

答案: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;

}

上面程序的輸出結果是（）。

A:9

B:1

C:4

D:3

答案:3

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

A:a[2][2]

B:a[0][3]

C:a[2][2+1]

D:a[0][4]

答案:a[0][3]

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

A:aa+1

B:&aa[1]

C:&aa[0]++

D:&aa[0]+1

答案:&aa[0]++

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

A:i*m+j

B:i*m+j-1

C:j*m+i

D:i*m+j+1

答案:i*m+j

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

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

B:可以對整型數(shù)組進行整體輸入、輸出

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

D:可以對字符串進行整體輸入、輸出

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

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

A:存在語法錯誤

B:不確定值

C:6

D:7

答案:6

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

A:s1="books"

B:strcpy(s1,s2);

C:s1=s2

D:strcpy(s2,s1)

答案:strcpy(s1,s2);

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

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

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

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

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

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

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

A:7,12

B:12,7

C:6,12

D:12,12

答案:6,12

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

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

B:將字符串str1連接到字符串str2中后再復制到字符串str3之后

C:將字符串str2復制到字符串str1后再將字符串str3連接到字符串str1之后

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

答案:將字符串str2復制到字符串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ù)組x和數(shù)組y的長度相同

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

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

第十一章測試

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

A:a,point,*&a

B:*&point,*point,&a

C:&*a,&a,*point

D:&a,&*point,point

答案:&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:9

B:6

C:8

D:5

答案:9

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

A:a[5]

B:*(a+2)

C:*(p+5)

D:a+2

答案:*(a+2)

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

A:元素a[6]的值

B:元素a[5]的指針

C:元素a[6]的指針

D:元素a[5]的值

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

設已有定義: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=a+10;p＜a;p++);

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

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

答案: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;

}

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

A:11,11,11,12,12,13,20,20

B:20,10,11,10,11,10,11,10

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

D:11,11,11,12,12,20,20,20

答案: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;

}

上面程序的運行結果為（）。

A:8,10

B:6,8

C:7,9

D:6,10

答案:6,10

有以下定義

chara[10],*b=a;

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

A:gets(a[0])

B:gets(a)

C:gets(&a[0])

D:gets(b)

答案: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;

}

上面程序輸出結果是（）。

A:rg

B:gm

C:or

D:ga

答案:ga

第十二章測試

#include＜stdio.h＞

#include＜string.h＞

intmain()

{

char*s1="AbDeG";

char*s2="AbdEg";

s1+=2;

s2+=2;

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

return0;

}

上面程序的運行結果是一個（）。

A:0

B:不確定值

C:負數(shù)

D:正數(shù)

答案:負數(shù)

若有代碼：

chara[]="Itismine";

char*p="Itismine";

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

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

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

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

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

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

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

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

B:*(p+3)

C:p+1

D:*(p+1)+3

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

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

A:*(a+j)

B:*(a[i]+j)

C:(a+i)

D:a[i]+j

答案:a[i]+j

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

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

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

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

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

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

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

A:c=*p1+*p2;

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

C:p1=p2;

D:p2=c;

答案:p2=c;

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

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

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

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

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的地址

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

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

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

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

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

intfun(doublex[10],int*n)

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

A:intfun(doublex,int*n);

B:intfun(double*x,intn);

C:intfun(double*,int*);

D:intfun(double,int)

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

intmain()

{

chara;

char*str=&a;

strcpy(str,"hello");

printf(str);

return0;

}

上面程序的運行結果是（）。

A:Null

B:h

C:hell

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

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

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

A:int*p(int,int);

B:int*p;

C:int(*p)(int);

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

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

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

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

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

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

D:*p(a,b);

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

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

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

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

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

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

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

第十三章測試

下列對結構類型變量不正確的定義是（）。

A:struct{

intnum;

intage;

}teacher

B:struct{

intnum;

intage;}teacher1,teacher2;

C:structteacher{

intnum,age;

}a;

D:structteacher{

intnum;

intage;

}teacher1;

答案:struct{

intnum;

intage;

}teacher

設有以下定義語句：

structstudent{

intnum;

charname[10];

floatscore;

}wang,zhang;

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

A:10

B:24

C:20

D:18

答案:20

假設有如下的定義：

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;

}

上面程序的輸出結果是（）。

A:7

B:5

C:6

D:8

答案:6

有以下說明和定義語句

structstudent{

intage;

charnum[8];

};

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

structstudent*p=stu;

則以下選項中引用結構體變量成員錯誤的是（）。

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",class[3].name[1]);

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

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

D:printf("%c",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;

...

}

則以下表達式中值為5的是（）。

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

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

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

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);

上面程序的運行結果是（）。

A:8,100

B:8,65

C:8,321

D:10,100

答案:8,321

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

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

B:共用體類型的定義可以出現(xiàn)在結構類型定義中

C:在定義共用體變量的同時允許對它的第一個成員進行初始化

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

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

intmain()

{

structcmplx{intx;inty;}

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

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

return0;

}

上面程序的輸出結果是（）。

A:1

B:6

C:3

D:0

答案:6

#include＜stdio.h＞

unionutype{

inti;

floatf;

}u[2];

intmain(){

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

return0;

}

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

A:4

B:8

C:16

D:6

答案: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í)行結果是（）。

A:其他三個答案都不對

B:130

C:513

D:258

答案:258

關于typedef，以下敘述中錯誤的是（）。

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

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

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

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

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

設有以下語句

typedefstructS{

intg;

charh;

}T;

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

A:T是structS類型的變量

B:可用S定義結構體變量

C:S是struct類型的變量

D:可以用T定義結構體變量

答案:可以用T定義結構體變量

設有以下定義語句

structstudent{

intnum;

charname[8];

floatscore;

}a[2];

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

A:20

B:16

C:32

D:40

答案:32

第十四章測試

表達式7&&8和7&8的值分別是（）。

A:10

B:01

C:11

D:00

答案:10

表達式7||8和7|8的值分別是（）。

A:015

B:01

C:115

D:11

答案:115

表達式7^16的值是（）。

A:23

B:1

C:0

D:21

答案:23

intmain()

{

charx=040;

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

return0;

}

以上程序的輸出結果是（）。

A:64

B:100

C:120

D:160

答案:64

若有定義：

inta=20,b=28,C;

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

A:112

B:5

C:80

D:7

答案:5

chara=3,b=6,c;

c=a^b＜＜2;

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

A:00011100

B:00010100

C:00011000

D:00011011

答案:00011011

若有代碼：

inta=11,b=2,c;

c=(a＞＞2)|