計算機編程智慧樹知到答案章節(jié)測試2023年上海財經大學

第一章測試有定義inta=9,b=6,c;執(zhí)行語句c=a/b+0.5;后,c的值為(

)。

A:1

B:2

C:1.4

D:2.0

答案:AC++語言源代碼文件擴展名為（

）。

A:.exe

B:.cpp

C:.obj

D:.c++

答案:B以下用戶標識符中，合法的是（）。

A:Ling@li

B:Int

C:moon

D:%123

答案:Cintx=10，y=5；則表達式x+=x*=y+8的值為（

）。

A:130

B:260

C:230

D:150

答案:B5、有定義inta=9,b=6,c;執(zhí)行語句c=a/b+0.5;后,c的值為(

)。

A:1

B:2.0

C:2

D:1.4

答案:A以下標識符中，不能作為合法的C++用戶定義標識符的是（

）。

A:_if

B:answer

C:to

D:signed

答案:D下列字符串中可以用作C++標識符的是（

）。

A:class

B:5char

C:_256

D:delete

答案:C下列C++標點符號中表示一條預處理命令開始的是（

）。

A:}

B:;

C://

D:#

答案:D9、以下程序的運行結果是(

)。main()

{

inta,b,d=241;

a=d/100%9;b=(-1)&&(-1);

cout<<a<<”,”<<b;}

A:2,0

B:6,0

C:2,1

D:6,1

答案:C語句while(!E);中的表達式!E等價于(

)

A:E!=0

B:E==0

C:E!=1

D:E==1

答案:B下面程序段的運行結果是：(

)。inta=1;b=2;c=2;while(a<b<c){t=a;a=b;b=t;c–;}cout<<a<<”,”<<b<<”,”<<c;

A:1,2,1

B:

2,1,1

C:1,2,0

D:2,1,0

答案:C設有程序段：

int

x=0,s=0;while(!x!=0)s+=++x;cout<<s;輸出(

)。

A:程序段執(zhí)行無限次

B:程序段中的控制表達式是非法的

C:運行程序段后輸出0

D:運行程序段后輸出1

答案:D以下程序的正確運行結果是(

)。

#include<stdio.h>

voidnum()

{

externintx,y;inta=15,b=10;

x=a-b;

y=a+b;

}

intx,y;

voidmain()

{

inta=7,b=5;

x=a+b;

y=a-b;

num();

cout<<x<<”,”<<y<<endl;

}

A:12,2

B:5,25

C:不確定

D:1,12

答案:B已知:intm=5；下列表示引用的方法中，正確的是：（

）。

A:float&f=&m；

B:int&Z；

C:int&X=m；

D:int&t=5；

答案:CC++語言源程序的基本單位是(

)。

A:過程

B:函數

C:子程序

D:標識符

答案:B下面程序段的輸出結果是（

)。chara[7]=”abcdef”;charb[4]=”ABC”;strcpy(a,b);cout<<a;

A:b

B:e

C:f

D:

答案:C下面程序段的輸出結果是（

）。charc[]=”\0will”;cout<<strlen(c);

A:6

B:9

C:3

D:14

答案:C第二章測試結構化程序設計所規(guī)定的三種基本控制結構是：（

）

。

A:樹形、網形、環(huán)形

B:主程序、子程序、函數

C:順序、選擇、循環(huán)

D:輸入、處理、輸出

答案:C下面程序的輸出結果是（

）。main(){

charstr[]=”SSWLIA”,C;

intk;

for(k=2;(c=str[k])!=’\0’;k++){

switch(c){

case‘I’:++k;break;

case‘L’:continue;

default:putchar(c);continue;

}

putchar(’’);

}}

A:WA

B:W

C:W*

D:SW

答案:CC++語言中，while和do-while循環(huán)的主要區(qū)別是：(

)。

A:while的循環(huán)控制條件比do-while的循環(huán)控制條件嚴格

B:

do-while的循環(huán)體至少無條件執(zhí)行一次

C:do-while允許從外部轉到循環(huán)體內

D:do-while的循環(huán)體不能是復合語句

答案:B下面程序段執(zhí)行完后，x的值是(

)。intx=0;for(inti=0;i<90;i++)

if(i)x++;

A:89

B:0

C:90

D:30

答案:C以下關于do-while循環(huán)的不正確描述是（

）。

A:do-while的循環(huán)體可以是復合語句

B:在do-while循環(huán)體中，一定要有能使while后面表達式的值變?yōu)榱悖ā凹佟保?的操作

C:do-while的循環(huán)體至少執(zhí)行一次

D:do-while循環(huán)由do開始，至while結束，在while(表達式)后面不能寫分號

答案:D運行下面程序,程序運行結果是(

)。#includeusingnamespace

std;

intmain(){staticinta[4]={7,8,9},b[4]={4,5,6},c[4],i;

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

c[i]=a[i]+b[i];

cout<<c[i]<<“

”;

cout<<endl;

return0;}

（

A:0

B:1113

C:111315

D:15

答案:A以下程序的輸出是（

）。#include<stdio.h>

main()

{intx=1;

if(x=2)

cout<<“OK”;

elseif(x<2)cout<<x;

elsecout<<“Quit”;

}

A:OK

B:Quit

C:無輸出結果

D:1

答案:A若w,x,y,z,m均為int型變量，則執(zhí)行下面語句后的m值為（

）。

w=1;x=2;y=3;z=4;

m=(w<x)?w:x;

m=(m<y)?m:y;

m=(m<z)?m:z;

A:3

B:2

C:4

D:1

答案:D若u、w、x、y均是正整型變量，則以下正確的switch語句是（

）。

A:switchx{default:u=x+y;

case10:w=x-y;break;

case11:u=xy;break;}

B:switch(x+y){case10:u=x+y;break;

case11:w=x-y;break;}

C:switch(xx+y*y){case3:

case3:w=x+y;break;

case0:w=y-x;break;}

D:switch(pow(x,2)+pow(y,2)){case1:case3:w=x+y;break;

case0:case5:w=x-y;}

答案:B語句while(!E);中的表達式!E等價于（

）。A)E==0

B)E!=1

C)E!=0

D)E==1

A:E==0

B:E!=0

C:E!=1

D:E==1

答案:A以下程序段（

）。

x=-1;

do

{x=x*x;}

while(!x);

A:有語法錯誤

B:循環(huán)執(zhí)行二次

C:是死循環(huán)

D:循環(huán)執(zhí)行一次

答案:D第三章測試以下正確的說法是(

)。

A:系統(tǒng)根本不允許用戶重新定義標準庫函數

B:用戶若需要調用標準庫函數，調用前必須重新定義

C:用戶若需調用標準庫函數，調用前不必使用預編譯命令將該函數所在文件包括到用戶源文件中，系統(tǒng)自動去調

D:用戶可以重新定義標準庫函數，若如此，該函數將失去原有含義

答案:D以下正確的描述是(

)。

在C++語言中

A:函數的定義不可以嵌套，但函數的調用可以嵌套

B:函數的定義和函數的調用均可以嵌套

C:函數的定義可以嵌套，但函數的調用不可以嵌套

D:函數的定義和函數的調用均不可以嵌套

答案:A以下程序的正確運行結果是(

)。

voidmain()

{

inta=2,i;

for(i=0;i<3;i++)cout<<f(a);

}

f(inta)

{

intb=0;staticintc=3;

b++;c++;

return(a+b+c);

}

A:7

911

B:7

8

9

C:7

7

7

D:71013

答案:B以下程序的正確運行結果是(

)。

#include<stdio.h>

func(inta,intb)

{

staticintm=0,i=2;

i+=m+1;

m=i+a+b;

return(m);

}

voidmain()

{

intk=4,m=1,p;

p=func(k,m);cout<<p<<”,”;

p=func(k,m);cout<<p<<endl;

}

A:8,17

B:8,16

C:8,20

D:8,8

答案:AC++語言規(guī)定，函數返回值的類型是由(

)。

A:調用該函數時系統(tǒng)臨時決定

B:在定義該函數時所指定的函數類型所決定

C:return語句中的表達式類型所決定

D:調用該函數時的主調函數類型所決定

答案:B下面函數調用語句含有實參的個數為(

)。

func((exp1,exp2),(exp3,exp4,exp5));

A:1

B:5

C:2

D:4

答案:CC++語言中，以下不正確的說法是(

)。

A:實參可以是常量、變量和表達式

B:形參可以是常量、變量和表達式

C:實參可以為任意類型

D:形參應與其對應的實參類型一致

答案:B在計算機高級語言C++中，下面對函數不正確的描述是（

）。

A:允許函數遞歸調用

B:當用數組名作形參時，形參數組元素值的改變可以使實參數組元素的值相應改變

C:被調用函數必須位于主函數之前

D:函數形參的作用范圍只是局限于所定義的函數內

答案:C對下面程序段的描述正確的是(

)。#includeusingnamespacestd;intFun(intx,inty)

{

returnx+y;}

intmain()

{

inti=10;

cout<<Fun(i++,i)<<endl;

return0;}

A:程序輸出結果不能確定

B:程序輸出結果是20

C:程序輸出結果是21

D:程序輸出結果是22

答案:B下列有關形式參數和實際參數的說法正確的是（

）。

A:定義函數指定的形參，會一直占用內存中的存儲單元。

B:在定義函數時，必須在函數首部指定形參的類型。

C:一般情況下，在調用函數結束后，形參所占的內存單元不會被釋放

D:即便是在發(fā)生函數調用時，函數中的形參也不會分配內存單元。

答案:B若使用一維數組名作為函數實參，則以下正確的說法是（

）。

A:實參數組類型與形參數組類型可以不匹配

B:必須在主調函數中說明此數組的大小

C:在被調函數中，不需要考慮形參數組的大小

D:實參數組與形參數組名必須一致

答案:B以下正確的說法是（

）。

A:實參和與其對應的形參共占用一個存儲單元；

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

C:實參和與其對應的形參各占用獨立的存儲單元；

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

答案:C以下正確的說法是（

）。如果在一個函數的復合語句中定義了一個變量，則該變量（

）。

A:為非法變量

B:在該函數中有效

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

D:在本程序范圍內均有效

答案:C第四章測試下面關于C++字符數組的敘述中，錯誤的是（

）。

A:可以用關系運算符對字符數組比較大小

B:字符數組可以放字符串

C:可以在賦值語句中通過賦值運算符“=”對字符數組整體賦值

D:字符數組的字符可以整體輸入、輸出

答案:C若有數組名作為函數調用的實參，則傳遞給形式參數的是（

）。

A:數組元素的個數

B:數組的首地址

C:數組第1個元素的值

D:數組中全部元素的值

答案:B已定義一個數組int

x[10];則對此數組元素正確的引用是（

）。

A:cout<<x[3+7];

B:intb;b=x[1]+x;

C:cout<<x[10];

D:cout<<x[0];

答案:D假定a為一個整型數組名，則元素a[4]的地址可表示為（

）。

A:a+32

B:a+16

C:a+8

D:a+4

答案:D設有數組定義char

a[]=“China”;則數組a所占的空間字節(jié)數為（

）。

A:7個字節(jié)

B:5個字節(jié)

C:6個字節(jié)

D:4個字節(jié)

答案:C設有定義語句int

a[3][3]，則以下敘述錯誤的是（

）。

A:a數組可以看成是由a[0]、a[1]、a[2]3個元素組成的一維數組

B:a[0]代表一個地址常量

C:a[1]是由3個整型元素組成的一維數組

D:可以用a[2]=1;的形式給數組元素賦值

答案:D有如下聲明語句int

B[3][3]={{1，2，0},{3，2},{4，5，10}}；那么B[1][1]的值是（

）。

A:2

B:10

C:3

D:1

答案:A以下對一維數組a的正確定義是(

)。

A:intn;cin>>n;inta[n];

B:constintN=9;

inta[N];

C:inta(9);

D:intn=9,a[n];

答案:B運行下面程序，程序運行結果是(

)。#includeusingnamespace

std;intmain(){

staticinta[4]={7,8,9},b[4]={4,5,6},c[4],i;

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

c[i]=a[i]+b[i];cout<<c[i]<<“

”;

cout<<endl;

return0;}

A:0

B:11

13

C:15

D:11

13

15

答案:A若有初始化char

a[]=“BASIC”；則cout<<&a[3];的輸出結果是（

）。

A:“IC”

B:‘S’

C:輸出a[3]的地址

D:‘I’

答案:A在C++語言中，引用數組元素時，其數組下標的數據類型允許是（

）。

A:任何類型的表達式

B:整型常量

C:整型常量或整型表達式

D:整型表達式

答案:C在C++中一組同樣類型的數據在內容中占用連續(xù)存貯空間的數據類型是（

）。

A:數組

B:指向指針的指針

C:指針

D:引用

答案:A運行以下程序的輸出結果是（

）。int

f(int

b[],

int

n){

int

i,r=1;for(i=0;i<=n;i++）r=r*b[i];return

r;}int

main(){

int

x,a[]={2,3,4,5,6,7,8,9};x=f(a,3);cout<<x;return0;}

A:24

B:120

C:6

D:720

答案:B下列do-while循環(huán)的循環(huán)次數為（

）.已知：int

j=5;do{

cout<<j--<<endl;

j--;}while(j!=0);

A:無限

B:1

C:0

D:5

答案:A若有定義charstr1[10]={“China”},str2[10];要將str1中的字符串復制到str2中去，正確的方法是（

）.

A:strcpy(str1,str2);

B:str2=str1;

C:strcpy(str2,str1);

D:strcpy(“China”,str2);

答案:C第五章測試下面結構體的定義語句中錯誤的是（

）.

A:structst{intnum,charname[20];}sta;

B:struct{intnum,charname[20];}a;

C:structst{intnum,charname[20];}a;

D:structst{intnum,charname[20];};sta;

答案:Astruct

abc{intx;inty;}data1=(2,3),data2;則以下賦值語句中錯誤的是（

）。

A:data2(9,10);

B:data2=data1;

C:data2.x=data1.x;

D:data2.y=data1.y;

答案:Astruct

abc{intx;char

y[20];doublez;}data;則以下給結構體變量成員x賦值語句中正確的是（

）。

A:data.x=100;

B:data.x=100;

C:data->x=100;

D:data.(x)=100;

答案:Astructs{inta,b;}data[2]={10,100,20,200};intmain(){

sp=data[1];

cout<<p.a<<endl;

return0;}程序運行后的輸出結果是（

）。

A:21

B:20

C:10

D:11

答案:B運行程序，程序輸出結果是（

）。#includeusingnamespacestd;intmain(){

struct

stud

{

char

num[5];

int

s[4];

double

ave;

}a;

cout<<sizeof(stud)<<endl;

return0;}

A:32

B:29

C:31

D:30

答案:A有下列結構體聲明語句struct

student{intnum;charname[20];floatscore[3];};student

s[3]={123,“LiFang”,67,89,90};要對第1個學生的成績輸出總分，下列表達式正確的是（

）.

A:cout<<s[0].score[0]+s[0].score[1]+s[0].score[2];

B:cout<<score[0].s[1]+score[1].s[1]+score[2].s[1];

C:cout<<s.score[0]+s.score[1]+s.score[2];

D:cout<<s.score[1]+s.score[2]+s.score[3];

答案:A定義以下結構體類型，運行程序的輸出結果是（

）。#includeusingnamespacestd;intmain(){

structs{inta;doubleb;};

cout<<sizeof(s)<<endl;

return0;}

A:12

B:18

C:16

D:14

答案:C當定義一個結構體變量時，系統(tǒng)為它分配的內存空間是（

）.

A:結構中一個成員所需的內存容量

B:結構中各成員所需內存容量之和

C:結構體中占內存容量最大者所需的容量

D:結構中第一個成員所需的內存容量

答案:B運行程序，程序輸出結果為(

)#includeusingnamespacestd;intmain(){

structs{intx;}a[3];

cout<<sizeof(a);

return0;}

A:6

B:4

C:18

D:12

答案:D定義以下結構體數組，運行程序，程序輸出結果是（

）。#includeusingnamespacestd;intmain(){

structc

{intx;

inty;

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

cout<<s[0].x*s[1].x<<endl;

return0;}

A:21

B:6

C:2

D:14

答案:C運行程序，程序運行結果是（

）#includeusingnamespacestd;structKeyWord{

charKey[20];

intID;}kw[]={“void”,1,“char”,2,“int”,3,“float”,4,“double”,5};int

main(){

cout<<kw[3].Key[0]<<“,”<<kw[3].ID;

return0;}

A:i,3

B:f,4

C:n,3

D:l,4

答案:B#includeusingnamespacestd;structstudent{

charname[10];

intscore[50];

floataverage;}stud1;intmain(){

cout<<sizeof(student);

return0;}

A:216

B:128

C:64

D:256

答案:A運行程序，程序運行結果是（

）。#includeusingnamespacestd;int

main(){

structperson

{

charname[9];

intage;

};

persona[5]={“John”,17,“Paul”,19,“Mary”,18,“Adam”,16};

cout<<a[2].name;

return0;}

A:John

B:Adam

C:Paul

D:Mary

答案:D運行程序，程序運行結果是（

）#includeusingnamespacestd;int

main(){structdate

{

intyear;

intmonth;

intday;

};

structs

{

datebirthday;

charname[20];

}x[4]={{2008,10,1,“guangzhou”},{2009,12,25,“Tianjin”}};

cout<<x[0].name<<“,”<<x[1].birthday.year<<endl;

return0;}

A:guangzhou,2009

B:Tianjin,2009

C:guangzhou,2008

D:Tianjin,2008

答案:A運行程序，程序輸出結果是（

）。#includeusingnamespacestd;structcontry{

intnum;

charname[20];}x[5]={1,“China”,2,“USA”,3,“France”,4,“Englan”,5,“Spanish”};intmain(){

inti;

for(i=3;i<5;i++)

cout<<x[i].num<<“,”<<x[i].name[0]<<endl;

return0;}

A:4E5S

B:3F4E5S

C:F4E

D:c2U3F4E

答案:A第六章測試若有定義語句intc[5],*p=c;則以下對數組c第1個元素地址的正確引用是（

）。

A:&c[0]

B:&c+1

C:c++

D:p+5

答案:A運行程序，程序輸出結果是（

）。#includeusingnamespacestd;int

main(){

inta[3][3],*p=&a[0][0],i;

for(i=0;i<9;i++)

p[i]=i;

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

cout<<a[1][i];

return0;}

A:345

B:123

C:234

D:012

答案:A運行程序，程序輸出結果是（

）.#includeusingnamespacestd;int

main(){

intfun(chars);

chary[]=“abcd”;

cout<<fun(y)<<endl;

return0;}intfun(chars){

chart=s;

while(t)

t++;

return(t-s);}

A:6

B:4

C:5

D:0

答案:Binta[]={1,2,3,4},y,p=a;執(zhí)行語句y=(++p)--后，數組a中的元素的值變?yōu)椋?/p>

）.

A:0，1，3，4

B:1，1，3，4

C:1，2，2，4

D:1，2，3，3

答案:B運行程序，程序輸出結果是（

）。#includeusingnamespacestd;intmain(){

charstr[100]=“program”,*p=str;

cout<<(p+2)<<endl;

return

0;}

A:pro

B:rogram

C:p

D:ogram

答案:D運行程序，程序輸出結果是（

）。#includeusingnamespacestd;intmain(){

charstr[100]=“program”,p=str;

cout<<(p++)<<endl;

return

0;}

A:rogram

B:r

C:pro

D:p

答案:D運行程序，程序輸出結果是（

）.#includeusingnamespacestd;intmain(){

charstr[100]=“program”,*p=str;

str[3]=0;

cout<<p<<endl;

return

0;}

A:r

B:ogram

C:o

D:pro

答案:D若有變量定義語句int

a[10]={1,2,3,4,5,6,7,8,9,10},p=a;則數值為6的表達式是（

）.

A:p+5

B:p+6

C:(p+5)

D:p+=6

答案:C己知inta[10]={3,7,9,15},p=a;則不能表示a數組中元素的選項是(

).

A:a

B:*p

C:a[p-a]

D:a

答案:D己知inta[]={0,2,4,6,8,10},p=a+1;其值等于0的表達式是(

).

A:(–p)

B:(p–)

C:(++p)

D:*(p++)

答案:A運行程序，程序運行結果是（

)。#includeusingnamespace

std;intmain(){

staticinta[4]={7,8,9},b[4]={4,5,6},c[4],i;

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

c[i]=a[i]+b[i];cout<<c[i]<<“

”;

cout<<endl;

return0;}

A:0

B:11

13

15

C:11

13

D:15

答案:A運行程序，程序運行結果是(

).#includeusingnamespace

std;intmain(){

chara[3]={‘a’,‘b’,‘c’},*p=a+1;

cout<<p<<endl;

return0;}

A:不確定

B:bc

C:abc

D:b

答案:A運行程序，程序運行結果是(

)。#include#includeusingnamespace

std;intmain(){

stringa=“string”,*p=&a;

cout<<p<<endl;

return0;}

A:string

B:變量a的地址

C:變量p的地址

D:s

答案:B設voidf1(int

*m,long

&n);inta;

longb;則以下調用合法的是（

）。

A:f1(&a,b);

B:f1(a,&b);

C:f1(a,b);

D:f1(&a,&b);

答案:A運行程序，程序運行結果是（

）。#includeusingnamespacestd;voidf(charx){cout<<x<<endl;}intmain(){

chara[]=“abcd”;

for(inti=0;i<=2;i++);

f(a+i);

return0;}

A:abc

B:a

C:d

D:abcd

答案:C已知:intm=5；下列表示引用的方法中正確的是（

）.

A:int&t=5；

B:float&f=&m；

C:int&X=m；

D:int&Z；

答案:C運行程序，程序輸出結果是（

）.void

sub(int

s,

int

y){

static

int

t=3

;

*y=s[t]

;

t--;}intmain(){

int

a[]={1,2,3,4},i,x=0;for(i=0;i<4;i++）

{

sub(a,&x);cout<<x;}cout<<endl;return0

;}

A:4444

B:1234

C:0000

D:4321

答案:D已知有定義inta[5];a數組中最后一個元素的地址可表示為（

）.

A:a+5

B:a+4

C:&a[5]

D:&a+4

答案:B有定義inta[]={2,5,6,},p=a;則(p+1)所代表的數組元素是(

)。

A:a[0]

B:a[1]

C:a[2]

D:a[3]

答案:B已有定義inta[10],*p;則正確的賦值語句是（

）.

A:p=a[5];

B:p=a+2;

C:p=100;

D:p=a[2]+2;

答案:B第七章測試在下列關于類概念的各個描述中，（

）是錯誤的。

A:類是抽象的，對象是具體的

B:客觀世界中任何一個具體的物體都可以看成一個類

C:類是對象的模板，是用來定義對象的一種抽象類型

D:類是創(chuàng)建對象的樣板

答案:B在下列關于類和對象的描述中，（

）是錯誤的。

A:類是抽象的，對象是具體的，兩者都占有內存空間

B:把某些具有共同屬性和行為的對象抽象為一種類型被稱為類

C:客觀世界中任何一個具體的物體都可以看成一個對象

D:類是對象的模板，對象是類的實例

答案:A類的實例化是指（

）。

A:調用類

B:指明具體類

C:創(chuàng)建類的對象

D:定義類

答案:C下列說法中正確的是（

）。

A:類的成員函數既可以定義在類體中（類內），也可以定義在類體外（類外），但必須在類體中（類內）聲明

B:類的成員函數只能在類體中(類內)定義

C:在類體之外定義的成員函數不能操作該類的私有數據成員

D:類中的成員數據可以在類體中（類內）定義，也可以在類體之外（類外）定義

答案:A關于構造函數不正確的說法是(

)。

A:構造函數初始化時為對象開辟內存空間

B:一個類可以有多個構造函數

C:構造函數名與類名相同

D:構造函數可以有返回值

答案:D有如下定義和語句classcalc{public:

voidshow()

{

cout<<a<<“+”<<b<<“=”<<a+b<<endl;

}private:

inta;

intb;

voidset()

{

cin>>a>>b;

}};calct,pt=&t;在main()函數中下面不正確的語句是（

）。

A:(pt).show()

B:

t.show()

C:pt->show()

D:t.set()

答案:D有如下定義和語句：classStudent{public:

voiddisplay(){cout<<num<<”“<<name;};private:

intnum;

charname[30];};Studentt,p=&t;下面正確的語句是（）。

A:t->display();

B:p->num=10101;

C:p->display();

D:

(p)->display();

答案:C要讓一個類中的所有對象的同一數據有不同的值，請不要使用（）。

A:保護數據成員

B:靜態(tài)數據成員

C:公有數據成員

D:私有數據成員

答案:B下面選項中不屬于面向對象程序設計特征的是(

)。

A:繼承性

B:多元性

C:封裝性

D:抽象性

答案:B已知類A是類B的友元，類B是類C的友元，則（

）。

A:類C的成員函數可以訪問類B的對象的任何成員

B:類C一定是類A的友元

C:類A的成員函數可以訪問類B的對象的任何成員

D:類A一定是類C的友元

答案:C成員函數代碼量很多，或具有多個成員函數，采用類內定義的方式比較合適。

A:錯

B:對

答案:A成員函數是一個類的成員，出現在類體中，也就是只能被類內其他成員函數調用。

A:對

B:錯

答案:B通過對象無法訪問private和protected屬性的成員變量和成員函數，而僅可以訪問public屬性的成員變量和成員函數。

A:對

B:錯

答案:A在C++語言中，可以通過傳值方式作為函數的參數或函數返回值。

A:對

B:錯

答案:A構造函數可以有返回值也可以無返回值。

A:對

B:錯

答案:B構造函數可以有一個參數或多個參數，可以為參數設置一個默認值。

A:對

B:錯

答案:A任何一個對象只能屬于一個具體的類。

A:對

B:錯

答案:A聲明時加關鍵字static的類中所有的成員數據是屬于類的，任何一個對象都可以共享該成員數據。

A:錯

B:對

答案:B友元函數是成員函數，友元函數可以訪問類中的私有成員。

A:對

B:錯

答案:B無論什么方式的繼承，基類的私有成員都不能被派生類成員函數訪問（引用）。

A:錯

B:對

答案:B第八章測試下列對派生類的描述中，錯誤的是（

）。

A:一個派生類可以作為另一個派生類的基類

B:派生類中繼承的基類成員的訪問權限到派生類保持不變

C:派生類的成員除了它自己的成員之外，還包含了它的基類的成員

D:派生類至少有一個基類

答案:B下列有關繼承和派生的敘述中，不正確的是（

）。

A:派生類繼承了基類的所有數據成員和成員函數

B:一個基類只能派生出一個派生類

C:每一個派生類又可以作為基類再派生出新的派生類

D:派生類可以繼承到基類成員的基礎上增加新的成員

答案:B下列有關繼承和派生的敘述中，不正確的是（

）。

A:一個基類可以派生出多個派生類

B:一個派生類不能作為基類再派生出新的派生類

C:一個派生類不僅可以從一個基類派生，也可以從多個基類派生

D:派生類繼承了基類的所有數據成員和成員函數

答案:B下列對派生類的描述中，錯誤的是（

）。

A:派生類的缺省（默認）繼承方式是private

B:派生類至少有一個基類

C:一個派生類可以作為另一個派生類的基類

D:派生類只繼承了基類的公有成員和保護成員

答案:D下列有關繼承和派生的敘述中，不正確的是（

）。

A:基類的成員函數可以訪問基類成員

B:派生類的成員函數可以訪問派生類自己增加的成員

C:基類的成員函數可以訪問派生類的成員

D:派生類的新增公用成員可以被該類創(chuàng)建的對象引用

答案:C下列有關公共繼承的繼承和派生的關系描述中，不正確的是（

）。

A:派生類的公用成員可以被派生類創(chuàng)建的對象引用

B:基類的私有成員，基類的成員函數可以引用它

C:基類的公用成員和保護成員在派生類中仍然保持其公用成員和保護成員的屬性

D:基類的私有成員，因為是公用繼承，可以被派生類的新增成員函數引用

答案:D下列有關繼承和派生的敘述中，正確的是（

）。

A:基類的保護成員在派生類中仍然是保護成員

B:派生類成員函數不能訪問通過私有繼承的基類的保護成員

C:基類的公用成員在派生類中仍然是公用成員

D:私有繼承的派生類作為基類繼續(xù)派生，下一層的派生類無法訪問它的任何成員

答案:D下列有關保護繼承的繼承和派生的敘述中，正確的是（

）。

A:派生類成員函數不能訪問通過保護繼承的基類的保護成員

B:基類的私有成員在派生類中變?yōu)槭潜Ｗo成員

C:派生類成員函數不能訪問通過保護繼承的基類的私有成員

D:派生類成員函數不能訪問通過保護繼承的基類的公有成員

答案:C下列有關繼承和派生的敘述中，正確的是（

）。

A:派生類構造函數的總參數表列中的參數，應當包括基類構造函數和子對象的參數表列中的參數

B:在執(zhí)行派生類的構造函數時，調用基類的構造函數就可以對子對象初始化

C:派生類析構函數可以被繼承，派生類構造函數不能被繼承

D:派生類構造函數可以被繼承，派生類析構函數不能被繼承

答案:A下列有關繼承和派生的敘述中，正確的是（

）。

A:基類的指針變量，可以訪問派生類新增加的成員

B:基類的指針變量可以指向派生類對象

C:派生類的指針變量可以指向基類對象

D:派生類的指針變量，可以訪問基類的成員

答案:B一個派生類不僅可以從一個基類派生，也可以從多個基類派生。

A:錯

B:對

答案:B繼承方式包括:public(公用的),

private(私有的)和protected(受保護的)，應用中public(公用的)最常見。

A:錯

B:對

答案:B當不需要對派生類新增的成員進行任何初始化操作時，派生類構造函數的函數體可以為空，即構造函數是空函數。

A:錯

B:對

答案:B在派生時，派生類不能繼承基類的析構函數。

A:對

B:錯

答案:A派生類的指針變量也可以指向基類對象。

A:對

B:錯

答案:B派生類的繼承方式有兩種：公有繼承和私有繼承。

A:錯

B:對

答案:A在公有繼承中，派生類對象只能引用基類中的公有成員和派生類新增的公共成員。

A:錯

B:對

答案:B在私有繼承中，基類中只有公有成員可以被派生類成員函數引用。

A:錯

B:對

答案:A派生類是它的基類的組合。

A:對

B:錯

答案:B析構函數不能被繼承。

A:錯

B:對

答案:B第九章測試

下列描述中，(

)是抽象類的特性。

A:

可以進行構造函數重載

B:

可以聲明虛函數

C:

不能創(chuàng)建其對象

D:

可以定義友元函數

答案:C關于虛函數的描述中，（

）是正確的。

A:

虛函數是一個static類型的成員函數

B:

虛函數是一個非成員函數

C:派生類的虛函數與基類的虛函數具有不同的參數個數和類型

D:

基類中說明了虛函數后，派生類中將其對應的函數可不必說明為虛函數

答案:D實現運行時的多態(tài)性采用(

)。

A:析構函數

B:構造函數

C:重載函數

D:虛函數

答案:D以下基類中的成員函數表示純虛函數的是(

)。

A:virtualvoidtt(int){}

B:virtualvoidtt(int)

C:voidtt(int)=0

D:virtualvoidtt()=0

答案:D關于純虛函數和抽象類的描述中，(

)是錯誤的。

A:純虛函數是一種特殊的虛函數，它不能實例化對象

B:抽象類只能作為基類來使用，其純虛函數的實現由派生類給出

C:抽象類是指具有純虛函數的類

D:一個基類中聲明有純虛函數，該基類的派生類一定不再是抽象類

答案:D下列有關C++的面向對象方法的多態(tài)的概念的敘述中，不正確的是（

）。

A:存在基類類型的指針指向派生類對象，基類和派生類的同名虛函數的參數必須相同

B:存在基類類型的指針指向派生類對象，且通過該指針調用虛函數

C:C++的面向對象方法的多態(tài)，必須存在基類指針指向派生類對象

D:必須存在著聲明為虛函數的友元函數

答案:D執(zhí)行以下程序代碼后，將會輸出的結果是（）。#includeusingnamespacestd;classBase{public:

voiddisplay(){cout<<“I’mBaseclass!”;}};classDerived:publicBase{public:

voiddisplay(){cout<<“I’mDerivedclass!”;}};intmain(){

Base*p;

Derivedtest;

p=&test;

p->display();

return0;}

A:I’mDerivedclass!I’mBaseclass!

B:I’mBaseclass!I’mDerivedclass!

C:I’mDerivedclass!

D:I’mBaseclass!

答案:D下列有關C++的面向對象方法的多態(tài)和虛函數的敘述中，正確的是（

）。

A:構造函數和析構函數都不能聲明為虛函數

B:構造函數和析構函數都能聲明為虛函數

C:派生類的析構函數可以聲明為虛函數

D:基類析構函數可以聲明為虛函數

答案:D如果一個類至少有一個純虛函數，那么就稱該類為（

）。

A:抽象類

B:虛函數

C:派生類

D:都不對

答案:A下列有關C++的面向對象方法的多態(tài)和虛函數的敘述中，不正確的是（

）。

A:抽象基類不能實例化

B:包含純虛成員函數的類即為抽象基類

C:包含純虛成員函數的抽象基類的派生類，在派生類中可以重新定義純虛函數為非純虛成員函數

D:抽象基類的派生類，增加新的成員函數或成員數據后，可以用于創(chuàng)建對象

答案:D類的成員函數前面加virtual關鍵字，則這個成員函數稱為虛函數。

A:錯

B:對

答案:B虛函數是一個成員函數。

A:錯

B:對

答案:B要想形成多態(tài)必須具備必須存在繼承關系，繼承關系中必須有同名的虛函數，并且基類和派生類的同名虛函數的參數必須不同。

A:對

B:錯

答案:B將基類中的成員函數通過virtual關鍵字聲明為虛函數之后，即使在派生類中同名同參數函數聲明時未加上virtual關鍵字，但它在所有的派生類中都將自動成為虛函數。

A:對

B:錯

答案:A純虛函數是一個非成員函數。

A:錯

B:對

答案:A析構函數必須聲明為虛函數。

A:對

B:錯

答案:B含有純虛函數的類可以定義對象。

A:對

B:錯

答案:B純虛成員函數可以被派生類繼承，如果派生類不重新定義抽象基類中的所有純虛成員函數，則派生類同樣會成為抽象基類，因而也不能用于創(chuàng)建對象。

A:對

B:錯

答案:A如果派生類的成員函數的原型（函數的首部）與基類中被定義為虛函數的成員函數原型相同，那么，這個函數自動繼承基類中虛函數的特性。

A:對

B:錯

答案:A純虛函數是一個在基類中聲明的沒有具體內容的虛函數，為了實現多態(tài)（或接口功能），要求派生類定義自己的版本。

A:對

B:錯

答案:A第十章測試下列運算符中，（

）運算符在C++中不能重載。

A:::

B:+=

C:+

D:[]

答案:A利用成員函數重載運算符：obj1obj2被編譯器解釋為（）。

A:obj1.operator(obj2)

B:(obj1,obj2)

C:obj2.operator(obj1)

D:operator*(obj1,obj2)

答案:A如果對TA類對象使用邏輯運算符“==”重載，以下函數聲明正確的是（

）。

A:bool&TA：：operator==(constTA&a)；

B:boolTA：：operator==(constTA&a)；

C:TA&TA：：operator==(constTA&a)；

D:void&TA：：operator==(constTA&a)；

答案:B在重載一個運算符時，其參數表中沒有任何參數，這表明該運算符是（

）。

A:作為成員函數重載的雙目運算符

B:作為友元函數重載的單目運算符

C:作為成員函數重載的單目運算符

D:作為友元函數重載的雙目運算符

答案:C在語句intn;cin>>n;中，cin是（

）。

A:類名

B:變量名

C:函數名

D:對象名

答案:D關于運算符重載，下列表述中錯誤的是（

）。

A:C++已有的大部分運算符都可以重載

B:運算符函數的返回類型不能聲明為基本數據類型

C:不可以通過運算符重載來創(chuàng)建C++中原來沒有的運算符

D:C++中的運算符不能做多次重載定義

答案:BC++流中重載的運算符<<是一個（

）。

A:用于輸入操作的成員函數

B:用于輸入操作的非成員函數

C:用于輸出操作的成員函數

D:用于輸出操作的非成員函數

答案:D若要對BigData類中用成員函數方式重載取模運算符，下列聲明選項中正確的是（

）。

A:BigData%operator(constBigData);

B:BigData%(constBigData);

C:BigDataoperator%(constBigData);

D:operator%(BigData,BigData);

答案:C下列運算符中哪些是不能夠被重載的（

）。

A:=，++，delete，=

B:+=，new，/=，==

C:

–>,.*,sizeof,::,?:

D:[],%,<=,–

答案:C下面是重載為非成員函數的運算符的函數原型，其中錯誤的是（

）。

A:BigInt&operator=（BigInt&,BigInt）；

B:BigIntoperator+（BigInt,BigInt）；

C:BigInt&operator*（BigInt,BigInt）；

D:BigIntoperator-（BigInt，BigInt）；

答案:A如果表達式a>=b，中的“>=”是作為非成員函數重載的運算符，則可以等效地表示為（

）。

A:a.operator>=(b)

B:a.operator>=(b,a)

C:a.operator>=(a)

D:operator>=(a,b)

答案:D在名為BigNumber類的類體中對運算符函數double進行如下聲明：operatordouble(BigNumber);函數聲明中有一個明顯的錯誤，這個錯誤就是（

）。

A:缺少對函數返回類型的說明

B:參數表中不應該有任何參數

C:參數聲明中缺少參數變量

D:函數聲明中缺少函數體

答案:B下列關于運算符重載的描述中，正確的是（

）。

A:運算符重載成為成員函數時，若參數表中無參數，重載是一元運算符

B:二元運算符重載成為非成員函數時，參數表中有一個參數

C:C++中可以重載所有的運算符

D:一元運算符只能作為成員函數重載

答案:A下列關于運算符重載的描述中，（

）是正確的。

A:運算符重載可以改變操作數的個數

B:運算符重載不可以改變語法結構

C:運算符重載可以改變結合性

D:運算符重載可以改變優(yōu)先級

答案:B下列關于C++流的敘述中，下面說法正確的是（

）。

A:cin是C++預定義的標準輸入流類

B:以上答案都不對

C:cin是C++預定義的標準輸入流函數

D:cin是C++預定義的標準輸入流對象

答案:D若要在Vector類中將重載為一元運算符，下列重載函數聲明中肯定有錯的是（

）。

A:intoperator(Vector);

B:Vectoroperator(Vector);

C:Vectoroperator(Vector,Vector);

D:Vectoroperator*();

答案:C重載流插入運算符<<時，下列設計不合理的是（

）。

A:為運算符函數設置兩個參數

B:將運算符定義為類的成員函數

C:將運算符函數的返回值類型設為ostream&

D:將運算符函數的第一個參數設為ostream&

答案:B若為類MyNumber重載運算符“/”，下列聲明中，錯誤的是（

）。

A:friendMyNumberoperator/(MyNumber,MyNumber);

B:friendMyNumberoperator/(MyNumber,int);

C:friendMyNumberoperator/(int,float);

D:friendMyNumberoperator/(float,MyNumber);

答案:C運算符重載時以下性質不一定會保持的是（

）。

A:優(yōu)先級、結合性

B:操作數的個數、結合性

C:操作數的個數、優(yōu)先級

D:返回值類型、操作數類型

答案:D以下類中說明了“++”運算符重載函數的原型。classTA{

public:

......

friendTAoperator++(TA&);};編譯器把表達式”++d”解釋為：(

)。

A:d.operator++(d)

B:operator++(d)

C:d.operator++()

D:operator++()

答案:B第十一章測試C++程序進行文件的輸入，除了包含頭文件iostream外，還要包含頭文件（

）。

A:ostream

B:fstream

C:ifstream

D:cstdio

答案:CC++語言中，程序通過操縱符進行格式輸出處理時，必須包含的頭文件是（

）。

A:stdlib.h

B:iostream.h

C:iomanip.h