計算機編程知到智慧樹章節(jié)測試課后答案2024年秋上海財經(jīng)大學

計算機編程知到智慧樹章節(jié)測試課后答案2024年秋上海財經(jīng)大學第一章單元測試

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

)。

A:1.4B:2.0C:2D:1

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

）。

A:.cppB:.exeC:.objD:.c++

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

A:Ling@liB:IntC:moonD:%123

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

）。

A:230B:130C:150D:260

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

)。

A:1.4B:2.0C:1D:2

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

）。

A:answerB:toC:_ifD:signed

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

）。

A:deleteB:classC:_256D:5char

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

）。

A:#B://

C:;D:}

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

)。main()

{

inta,b,d=241;

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

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

A:2,1B:6,1C:6,0D:2,0

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

)

A:E==1B:E!=0C:E!=1D:E==0

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

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

A:2,1,0B:1,2,1C:

2,1,1D:1,2,0

答案:1,2,0設有程序段：

int

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

)。

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

B:運行程序段后輸出1C:運行程序段后輸出0

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

答案:運行程序段后輸出1以下程序的正確運行結果是(

)。

#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:5,25B:不確定C:1,12D:12,2

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

）。

A:float&f=&m；B:int&Z；C:int&X=m；D:int&t=5；

答案:int&X=m；C++語言源程序的基本單位是(

)。

A:函數(shù)

B:標識符C:過程D:子程序

答案:函數(shù)

下面程序段的輸出結果是（

)。

chara[7]=”abcdef”;

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

A:bB:eC:fD:\0

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

）。

charc[]=”\t\v\\\0will\n”;cout<<strlen(c);

A:6B:9C:14D:3

答案:3

第二章單元測試

結構化程序設計所規(guī)定的三種基本控制結構是：（

）

。

A:輸入、處理、輸出B:主程序、子程序、函數(shù)C:樹形、網(wǎng)形、環(huán)形D:順序、選擇、循環(huán)

答案:順序、選擇、循環(huán)下面程序的輸出結果是（

）。

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:W*B:SWC:W*AD:W

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

)。

A:

do-while的循環(huán)體至少無條件執(zhí)行一次B:while的循環(huán)控制條件比do-while的循環(huán)控制條件嚴格C:do-while的循環(huán)體不能是復合語句D:do-while允許從外部轉到循環(huán)體內

答案:

do-while的循環(huán)體至少無條件執(zhí)行一次下面程序段執(zhí)行完后，x的值是(

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

if(i)x++;

A:89B:30C:0D:90

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

）。

A:do-while的循環(huán)體至少執(zhí)行一次B:do-while的循環(huán)體可以是復合語句C:在do-while循環(huán)體中，一定要有能使while后面表達式的值變?yōu)榱悖ā凹佟保?的操作D:do-while循環(huán)由do開始，至while結束，在while(表達式)后面不能寫分號

答案:do-while循環(huán)由do開始，至while結束，在while(表達式)后面不能寫分號運行下面程序,程序運行結果是(

)。#include<iostream>usingnamespace

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:111315B:1113C:15D:0

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

）。#include<stdio.h>

main()

{intx=1;

if(x=2)

cout<<“OK”;

elseif(x<2)cout<<x;

elsecout<<“Quit”;

}

A:無輸出結果B:QuitC:OKD:1

答案:OK若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:1

B:2C:3D:4

答案:1

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

）。

A:switch(x*x+y*y){case3:

case3:w=x+y;break;

case0:w=y-x;break;}

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

case0:case5:w=x-y;}

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

case11:w=x-y;break;}

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

case10:w=x-y;break;

case11:u=x*y;break;}

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

case11:w=x-y;break;}

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

）。A)E==0

B)E!=1

C)E!=0

D)E==1

A:E!=0

B:E==1C:E==0D:E!=1

答案:E==0

以下程序段（

）。

x=-1;

do

{x=x*x;}

while(!x);

A:循環(huán)執(zhí)行二次B:循環(huán)執(zhí)行一次C:是死循環(huán)D:有語法錯誤

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

第三章單元測試

以下正確的說法是(

)。

A:用戶若需要調用標準庫函數(shù)，調用前必須重新定義B:用戶可以重新定義標準庫函數(shù)，若如此，該函數(shù)將失去原有含義C:用戶若需調用標準庫函數(shù)，調用前不必使用預編譯命令將該函數(shù)所在文件包括到用戶源文件中，系統(tǒng)自動去調D:系統(tǒng)根本不允許用戶重新定義標準庫函數(shù)

答案:用戶可以重新定義標準庫函數(shù)，若如此，該函數(shù)將失去原有含義以下正確的描述是(

)。

在C++語言中

A:函數(shù)的定義和函數(shù)的調用均可以嵌套B:函數(shù)的定義可以嵌套，但函數(shù)的調用不可以嵌套C:函數(shù)的定義不可以嵌套，但函數(shù)的調用可以嵌套D:函數(shù)的定義和函數(shù)的調用均不可以嵌套

答案:函數(shù)的定義不可以嵌套，但函數(shù)的調用可以嵌套以下程序的正確運行結果是(

)。

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

911B:7

7

7C:71013D:7

8

9

答案:7

8

9以下程序的正確運行結果是(

)。

#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,17B:8,20C:8,8D:8,16

答案:8,17C++語言規(guī)定，函數(shù)返回值的類型是由(

)。

A:return語句中的表達式類型所決定B:調用該函數(shù)時的主調函數(shù)類型所決定C:調用該函數(shù)時系統(tǒng)臨時決定D:在定義該函數(shù)時所指定的函數(shù)類型所決定

答案:在定義該函數(shù)時所指定的函數(shù)類型所決定下面函數(shù)調用語句含有實參的個數(shù)為(

)。

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

A:5B:2C:1D:4

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

)。

A:形參應與其對應的實參類型一致B:實參可以為任意類型C:形參可以是常量、變量和表達式D:實參可以是常量、變量和表達式

答案:形參可以是常量、變量和表達式在計算機高級語言C++中，下面對函數(shù)不正確的描述是（

）。

A:允許函數(shù)遞歸調用B:當用數(shù)組名作形參時，形參數(shù)組元素值的改變可以使實參數(shù)組元素的值相應改變C:函數(shù)形參的作用范圍只是局限于所定義的函數(shù)內D:被調用函數(shù)必須位于主函數(shù)之前

答案:被調用函數(shù)必須位于主函數(shù)之前對下面程序段的描述正確的是(

)。#include<iostream>usingnamespacestd;intFun(intx,inty)

{

returnx+y;}

intmain()

{

inti=10;

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

return0;}

A:程序輸出結果是21B:程序輸出結果是20C:程序輸出結果不能確定D:程序輸出結果是22

答案:程序輸出結果是20下列有關形式參數(shù)和實際參數(shù)的說法正確的是（

）。

A:即便是在發(fā)生函數(shù)調用時，函數(shù)中的形參也不會分配內存單元。B:一般情況下，在調用函數(shù)結束后，形參所占的內存單元不會被釋放C:在定義函數(shù)時，必須在函數(shù)首部指定形參的類型。D:定義函數(shù)指定的形參，會一直占用內存中的存儲單元。

答案:在定義函數(shù)時，必須在函數(shù)首部指定形參的類型。若使用一維數(shù)組名作為函數(shù)實參，則以下正確的說法是（

）。

A:必須在主調函數(shù)中說明此數(shù)組的大小B:在被調函數(shù)中，不需要考慮形參數(shù)組的大小C:實參數(shù)組與形參數(shù)組名必須一致D:實參數(shù)組類型與形參數(shù)組類型可以不匹配

答案:必須在主調函數(shù)中說明此數(shù)組的大小以下正確的說法是（

）。

A:只有當實參和與其對應的形參同名時才共同占用存儲單元；B:形參是虛擬的，不占用存儲單元。C:實參和與其對應的形參各占用獨立的存儲單元；D:實參和與其對應的形參共占用一個存儲單元；

答案:實參和與其對應的形參各占用獨立的存儲單元；以下正確的說法是（

）。

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

）。

A:只在該復合語句中有效B:為非法變量C:在該函數(shù)中有效D:在本程序范圍內均有效

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

第四章單元測試

下面關于C++字符數(shù)組的敘述中，錯誤的是（

）。

A:字符數(shù)組可以放字符串B:字符數(shù)組的字符可以整體輸入、輸出C:可以在賦值語句中通過賦值運算符“=”對字符數(shù)組整體賦值D:可以用關系運算符對字符數(shù)組比較大小

答案:可以在賦值語句中通過賦值運算符“=”對字符數(shù)組整體賦值若有數(shù)組名作為函數(shù)調用的實參，則傳遞給形式參數(shù)的是（

）。

A:數(shù)組的首地址B:數(shù)組第1個元素的值C:數(shù)組中全部元素的值D:數(shù)組元素的個數(shù)

答案:數(shù)組的首地址已定義一個數(shù)組int

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

）。

A:intb;b=x[1]+x;B:cout<<x[3+7];C:cout<<x[10];D:cout<<x[0];

答案:cout<<x[0];假定a為一個整型數(shù)組名，則元素a[4]的地址可表示為（

）。

A:a+32B:a+16C:a+8

D:a+4

答案:a+4設有數(shù)組定義char

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

）。

A:5個字節(jié)B:4個字節(jié)C:6個字節(jié)D:7個字節(jié)

答案:6個字節(jié)設有定義語句int

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

）。

A:a數(shù)組可以看成是由a[0]、a[1]、a[2]3個元素組成的一維數(shù)組B:a[0]代表一個地址常量C:a[1]是由3個整型元素組成的一維數(shù)組D:可以用a[2]=1;的形式給數(shù)組元素賦值

答案:可以用a[2]=1;的形式給數(shù)組元素賦值有如下聲明語句int

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

）。

A:10

B:2

C:3

D:1

答案:2

以下對一維數(shù)組a的正確定義是(

)。

A:intn=9,a[n];B:intn;cin>>n;inta[n];C:inta(9);D:constintN=9;

inta[N];

答案:constintN=9;

inta[N];運行下面程序，程序運行結果是(

)。#include<iostream>usingnamespace

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:11

13

B:0C:15D:11

13

15

答案:0若有初始化char

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

）。

A:'S'B:輸出a[3]的地址C:'I'D:"IC"

答案:"IC"在C++語言中，引用數(shù)組元素時，其數(shù)組下標的數(shù)據(jù)類型允許是（

）。

A:任何類型的表達式B:整型常量或整型表達式C:整型常量D:整型表達式

答案:整型常量或整型表達式在C++中一組同樣類型的數(shù)據(jù)在內容中占用連續(xù)存貯空間的數(shù)據(jù)類型是（

）。

A:指向指針的指針B:數(shù)組C:引用

D:指針

答案:數(shù)組運行以下程序的輸出結果是（

）。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:720B:6C:120D:24

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

）.已知：int

j=5;do{

cout<<j--<<endl;

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

A:1B:無限C:5D:0

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

）.

A:strcpy(str1,str2);B:strcpy(str2,str1);C:str2=str1;D:strcpy("China",str2);

答案:strcpy(str2,str1);

第五章單元測試

下面結構體的定義語句中錯誤的是（

）.

A:structst{intnum,charname[20];}a;B:struct{intnum,charname[20];}a;C:structst{intnum,charname[20];}sta;D:structst{intnum,charname[20];};sta;

答案:structst{intnum,charname[20];}sta;struct

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

）。

A:data2.y=data1.y;B:data2(9,10);C:data2.x=data1.x;D:data2=data1;

答案:data2(9,10);struct

abc{intx;char

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

）。

A:data->x=100;B:*data.x=100;C:data.x=100;D:data.(*x)=100;

答案:data.x=100;structs{inta,b;}

data[2]={10,100,20,200};intmain(){

sp=data[1];

cout<<p.a<<endl;

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

）。

A:20B:21C:11D:10

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

）。#include<iostream>usingnamespacestd;intmain(){

struct

stud

{

char

num[5];

int

s[4];

double

ave;

}a;

cout<<sizeof(stud)<<endl;

return0;}

A:31

B:30

C:29D:32

答案:32

有下列結構體聲明語句struct

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

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

）.

A:cout<<s.score[1]+s.score[2]+s.score[3];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[0].score[0]+s[0].score[1]+s[0].score[2];

答案:cout<<s[0].score[0]+s[0].score[1]+s[0].score[2];定義以下結構體類型，運行程序的輸出結果是（

）。#include<iostream>usingnamespacestd;intmain(){

structs{inta;doubleb;};

cout<<sizeof(s)<<endl;

return0;}

A:18B:16C:14D:12

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

）.

A:結構中第一個成員所需的內存容量B:結構體中占內存容量最大者所需的容量C:結構中一個成員所需的內存容量D:結構中各成員所需內存容量之和

答案:結構中各成員所需內存容量之和運行程序，程序輸出結果為(

)#include<iostream>usingnamespacestd;intmain(){

structs{intx;}a[3];

cout<<sizeof(a);

return0;}

A:12B:6C:18D:4

答案:12定義以下結構體數(shù)組，運行程序，程序輸出結果是（

）。#include<iostream>usingnamespacestd;intmain(){

structc

{intx;

inty;

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

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

return0;}

A:2B:21C:14D:6

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

）#include<iostream>usingnamespacestd;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:n,3B:l,4C:f,4D:i,3

答案:f,4#include<iostream>usingnamespacestd;structstudent

{

charname[10];

intscore[50];

floataverage;

}stud1;

intmain(){

cout<<sizeof(student);

return0;}

A:128B:256C:216D:64

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

）。#include<iostream>usingnamespacestd;int

main(){

structperson

{

charname[9];

intage;

};

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

cout<<a[2].name;

return0;}

A:AdamB:MaryC:JohnD:Paul

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

）#include<iostream>usingnamespacestd;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:Tianjin,2008B:Tianjin,2009C:guangzhou,2008D:guangzhou,2009

答案:guangzhou,2009運行程序，程序輸出結果是（

）。#include<iostream>usingnamespacestd;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:F4EB:3F4E5SC:c2U3F4ED:4E5S

答案:4E5S

第六章單元測試

若有定義語句intc[5],*p=c;則以下對數(shù)組c第1個元素地址的正確引用是（

）。

A:p+5B:c++C:&c[0]D:&c+1

答案:&c[0]運行程序，程序輸出結果是（

）。#include<iostream>usingnamespacestd;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:012B:234

C:123

D:345

答案:345

運行程序，程序輸出結果是（

）.#include<iostream>usingnamespacestd;int

main(){

intfun(char*s);

chary[]="abcd";

cout<<fun(y)<<endl;

return0;}intfun(char*s){

char*t=s;

while(*t)

t++;

return(t-s);}

A:4

B:0C:5D:6

答案:4

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

）.

A:1，1，3，4B:1，2，2，4C:0，1，3，4D:1，2，3，3

答案:1，1，3，4運行程序，程序輸出結果是（

）。#include<iostream>usingnamespacestd;intmain(){

charstr[100]="program",*p=str;

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

return

0;}

A:ogramB:proC:rogramD:p

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

）。#include<iostream>usingnamespacestd;intmain(){

charstr[100]="program",*p=str;

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

return

0;}

A:p

B:pro

C:rogram

D:r

答案:p

運行程序，程序輸出結果是（

）.#include<iostream>usingnamespacestd;intmain(){

charstr[100]="program",*p=str;

str[3]=0;

cout<<p<<endl;

return

0;}

A:pro

B:ogramC:r

D:o

答案:pro

若有變量定義語句int

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

）.

A:*p+=6B:p+5C:*p+6D:*(p+5)

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

).

A:aB:a[p-a]C:*p

D:*a

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

).

A:*(--p)B:*(p--)C:*(++p)D:*(p++)

答案:*(--p)運行程序，程序運行結果是（

)。#include<iostream>usingnamespace

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:11

13

B:0C:11

13

15

D:15

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

).#include<iostream>usingnamespace

std;intmain(){

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

cout<<p<<endl;

return0;}

A:abcB:bC:bcD:不確定

答案:不確定

運行程序，程序運行結果是(

)。#include<iostream>#include<string>usingnamespace

std;intmain(){

stringa="string",*p=&a;

cout<<p<<endl;

return0;}

A:sB:stringC:變量a的地址

D:變量p的地址

答案:變量a的地址

設voidf1(int

*m,long

&n);inta;

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

）。

A:f1(&a,b);B:f1(a,&b);C:f1(a,b);D:f1(&a,&b);

答案:f1(&a,b);運行程序，程序運行結果是（

）。#include<iostream>usingnamespacestd;voidf(char*x){cout<<*x<<endl;}intmain(){

chara[]="abcd";

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

f(a+i);

return0;}

A:d

B:abcC:aD:abcd

答案:d

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

）.

A:int&Z；B:int&X=m；C:int&t=5；D:float&f=&m；

答案:int&X=m；運行程序，程序輸出結果是（

）.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:4321B:0000C:4444D:1234

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

）.

A:&a+4B:&a[5]C:a+4D:a+5

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

)。

A:a[0]B:a[3]C:a[1]D:a[2]

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

）.

A:p=a[5];B:p=a[2]+2;C:p=100;D:p=a+2;

答案:p=a+2;

第七章單元測試

在下列關于類概念的各個描述中，（

）是錯誤的。

A:客觀世界中任何一個具體的物體都可以看成一個類B:類是抽象的，對象是具體的C:類是對象的模板，是用來定義對象的一種抽象類型D:類是創(chuàng)建對象的樣板

答案:客觀世界中任何一個具體的物體都可以看成一個類在下列關于類和對象的描述中，（

）是錯誤的。

A:類是對象的模板，對象是類的實例B:客觀世界中任何一個具體的物體都可以看成一個對象C:把某些具有共同屬性和行為的對象抽象為一種類型被稱為類D:類是抽象的，對象是具體的，兩者都占有內存空間

答案:類是抽象的，對象是具體的，兩者都占有內存空間類的實例化是指（

）。

A:調用類B:創(chuàng)建類的對象C:定義類D:指明具體類

答案:創(chuàng)建類的對象下列說法中正確的是（

）。

A:類中的成員數(shù)據(jù)可以在類體中（類內）定義，也可以在類體之外（類外）定義B:類的成員函數(shù)只能在類體中(類內)定義C:類的成員函數(shù)既可以定義在類體中（類內），也可以定義在類體外（類外），但必須在類體中（類內）聲明D:在類體之外定義的成員函數(shù)不能操作該類的私有數(shù)據(jù)成員

答案:類的成員函數(shù)既可以定義在類體中（類內），也可以定義在類體外（類外），但必須在類體中（類內）聲明關于構造函數(shù)不正確的說法是(

)。

A:構造函數(shù)初始化時為對象開辟內存空間B:一個類可以有多個構造函數(shù)C:構造函數(shù)名與類名相同D:構造函數(shù)可以有返回值

答案:構造函數(shù)可以有返回值有如下定義和語句classcalc{public:

voidshow()

{

cout<<a<<"+"<<b<<"="<<a+b<<endl;

}private:

inta;

intb;

voidset()

{

cin>>a>>b;

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

）。

A:pt->show()B:t.set()C:(*pt).show()D:

t.show()

答案:t.set()有如下定義和語句：classStudent{public:

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

intnum;

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

A:

(*p)->display();B:t->display();C:p->display();D:p->num=10101;

答案:p->display();要讓一個類中的所有對象的同一數(shù)據(jù)有不同的值，請不要使用（）。

A:私有數(shù)據(jù)成員B:靜態(tài)數(shù)據(jù)成員C:保護數(shù)據(jù)成員D:公有數(shù)據(jù)成員

答案:靜態(tài)數(shù)據(jù)成員下面選項中不屬于面向對象程序設計特征的是(

)。

A:封裝性B:抽象性C:繼承性D:多元性

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

）。

A:類A一定是類C的友元B:類C的成員函數(shù)可以訪問類B的對象的任何成員C:類A的成員函數(shù)可以訪問類B的對象的任何成員D:類C一定是類A的友元

答案:類A的成員函數(shù)可以訪問類B的對象的任何成員成員函數(shù)代碼量很多，或具有多個成員函數(shù)，采用類內定義的方式比較合適。

A:對B:錯

答案:錯成員函數(shù)是一個類的成員，出現(xiàn)在類體中，也就是只能被類內其他成員函數(shù)調用。

A:錯B:對

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

A:錯B:對

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

A:對B:錯

答案:對構造函數(shù)可以有返回值也可以無返回值。

A:對B:錯

答案:錯構造函數(shù)可以有一個參數(shù)或多個參數(shù)，可以為參數(shù)設置一個默認值。

A:對B:錯

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

A:對B:錯

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

A:錯B:對

答案:對友元函數(shù)是成員函數(shù)，友元函數(shù)可以訪問類中的私有成員。

A:對B:錯

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

A:錯B:對

答案:對

第八章單元測試

下列對派生類的描述中，錯誤的是（

）。

A:派生類的成員除了它自己的成員之外，還包含了它的基類的成員B:派生類至少有一個基類C:派生類中繼承的基類成員的訪問權限到派生類保持不變D:一個派生類可以作為另一個派生類的基類

答案:派生類中繼承的基類成員的訪問權限到派生類保持不變下列有關繼承和派生的敘述中，不正確的是（

）。

A:一個基類只能派生出一個派生類B:每一個派生類又可以作為基類再派生出新的派生類C:派生類繼承了基類的所有數(shù)據(jù)成員和成員函數(shù)D:派生類可以繼承到基類成員的基礎上增加新的成員

答案:一個基類只能派生出一個派生類下列有關繼承和派生的敘述中，不正確的是（

）。

A:一個基類可以派生出多個派生類B:派生類繼承了基類的所有數(shù)據(jù)成員和成員函數(shù)C:一個派生類不能作為基類再派生出新的派生類D:一個派生類不僅可以從一個基類派生，也可以從多個基類派生

答案:一個派生類不能作為基類再派生出新的派生類下列對派生類的描述中，錯誤的是（

）。

A:派生類的缺?。J）繼承方式是privateB:派生類至少有一個基類C:派生類只繼承了基類的公有成員和保護成員D:一個派生類可以作為另一個派生類的基類

答案:派生類只繼承了基類的公有成員和保護成員下列有關繼承和派生的敘述中，不正確的是（

）。

A:基類的成員函數(shù)可以訪問基類成員B:派生類的成員函數(shù)可以訪問派生類自己增加的成員C:基類的成員函數(shù)可以訪問派生類的成員D:派生類的新增公用成員可以被該類創(chuàng)建的對象引用

答案:基類的成員函數(shù)可以訪問派生類的成員下列有關公共繼承的繼承和派生的關系描述中，不正確的是（

）。

A:基類的私有成員，因為是公用繼承，可以被派生類的新增成員函數(shù)引用B:派生類的公用成員可以被派生類創(chuàng)建的對象引用C:基類的公用成員和保護成員在派生類中仍然保持其公用成員和保護成員的屬性D:基類的私有成員，基類的成員函數(shù)可以引用它

答案:基類的私有成員，因為是公用繼承，可以被派生類的新增成員函數(shù)引用下列有關繼承和派生的敘述中，正確的是（

）。

A:派生類成員函數(shù)不能訪問通過私有繼承的基類的保護成員B:基類的公用成員在派生類中仍然是公用成員C:私有繼承的派生類作為基類繼續(xù)派生，下一層的派生類無法訪問它的任何成員D:基類的保護成員在派生類中仍然是保護成員

答案:私有繼承的派生類作為基類繼續(xù)派生，下一層的派生類無法訪問它的任何成員下列有關保護繼承的繼承和派生的敘述中，正確的是（

）。

A:派生類成員函數(shù)不能訪問通過保護繼承的基類的公有成員B:派生類成員函數(shù)不能訪問通過保護繼承的基類的私有成員C:派生類成員函數(shù)不能訪問通過保護繼承的基類的保護成員D:基類的私有成員在派生類中變?yōu)槭潜Ｗo成員

答案:派生類成員函數(shù)不能訪問通過保護繼承的基類的私有成員下列有關繼承和派生的敘述中，正確的是（

）。

A:派生類析構函數(shù)可以被繼承，派生類構造函數(shù)不能被繼承B:派生類構造函數(shù)可以被繼承，派生類析構函數(shù)不能被繼承C:派生類構造函數(shù)的總參數(shù)表列中的參數(shù)，應當包括基類構造函數(shù)和子對象的參數(shù)表列中的參數(shù)D:在執(zhí)行派生類的構造函數(shù)時，調用基類的構造函數(shù)就可以對子對象初始化

答案:派生類構造函數(shù)的總參數(shù)表列中的參數(shù)，應當包括基類構造函數(shù)和子對象的參數(shù)表列中的參數(shù)下列有關繼承和派生的敘述中，正確的是（

）。

A:基類的指針變量可以指向派生類對象B:派生類的指針變量可以指向基類對象C:派生類的指針變量，可以訪問基類的成員D:基類的指針變量，可以訪問派生類新增加的成員

答案:基類的指針變量可以指向派生類對象一個派生類不僅可以從一個基類派生，也可以從多個基類派生。

A:錯B:對

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

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

A:對B:錯

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

A:錯B:對

答案:對在派生時，派生類不能繼承基類的析構函數(shù)。

A:對B:錯

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

A:對B:錯

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

A:錯B:對

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

A:對B:錯

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

A:對B:錯

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

A:對B:錯

答案:錯析構函數(shù)不能被繼承。

A:對B:錯

答案:對

第九章單元測試

下列描述中，(

)是抽象類的特性。

A:

可以定義友元函數(shù)B:

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

可以進行構造函數(shù)重載D:

可以聲明虛函數(shù)

答案:

不能創(chuàng)建其對象關于虛函數(shù)的描述中，（

）是正確的。

A:派生類的虛函數(shù)與基類的虛函數(shù)具有不同的參數(shù)個數(shù)和類型B:

虛函數(shù)是一個非成員函數(shù)C:

虛函數(shù)是一個static類型的成員函數(shù)D:

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

答案:

基類中說明了虛函數(shù)后，派生類中將其對應的函數(shù)可不必說明為虛函數(shù)實現(xiàn)運行時的多態(tài)性采用(

)。

A:虛函數(shù)B:構造函數(shù)C:重載函數(shù)D:析構函數(shù)

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

)。

A:virtualvoidtt()=0B:voidtt(int)=0C:virtualvoidtt(int){}D:virtualvoidtt(int)

答案:virtualvoidtt()=0關于純虛函數(shù)和抽象類的描述中，(

)是錯誤的。

A:一個基類中聲明有純虛函數(shù)，該基類的派生類一定不再是抽象類B:抽象類是指具有純虛函數(shù)的類C:純虛函數(shù)是一種特殊的虛函數(shù)，它不能實例化對象

D:抽象類只能作為基類來使用，其純虛函數(shù)的實現(xiàn)由派生類給出

答案:一個基類中聲明有純虛函數(shù)，該基類的派生類一定不再是抽象類下列有關C++的面向對象方法的多態(tài)的概念的敘述中，不正確的是（

）。

A:存在基類類型的指針指向派生類對象，且通過該指針調用虛函數(shù)B:C++的面向對象方法的多態(tài)，必須存在基類指針指向派生類對象C:存在基類類型的指針指向派生類對象，基類和派生類的同名虛函數(shù)的參數(shù)必須相同D:必須存在著聲明為虛函數(shù)的友元函數(shù)

答案:必須存在著聲明為虛函數(shù)的友元函數(shù)執(zhí)行以下程序代碼后，將會輸出的結果是（）。#include<iostream>usingnamespacestd;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!

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

）。

A:基類析構函數(shù)可以聲明為虛函數(shù)B:構造函數(shù)和析構函數(shù)都能聲明為虛函數(shù)C:構造函數(shù)和析構函數(shù)都不能聲明為虛函數(shù)D:派生類的析構函數(shù)可以聲明為虛函數(shù)

答案:基類析構函數(shù)可以聲明為虛函數(shù)如果一個類至少有一個純虛函數(shù)，那么就稱該類為（

）。

A:派生類B:虛函數(shù)C:都不對D:抽象類

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

）。

A:包含純虛成員函數(shù)的類即為抽象基類B:抽象基類不能實例化C:抽象基類的派生類，增加新的成員函數(shù)或成員數(shù)據(jù)后，可以用于創(chuàng)建對象D:包含純虛成員函數(shù)的抽象基類的派生類，在派生類中可以重新定義純虛函數(shù)為非純虛成員函數(shù)

答案:抽象基類的派生類，增加新的成員函數(shù)或成員數(shù)據(jù)后，可以用于創(chuàng)建對象類的成員函數(shù)前面加virtual關鍵字，則這個成員函數(shù)稱為虛函數(shù)。

A:錯B:對

答案:對虛函數(shù)是一個成員函數(shù)。

A:錯B:對

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

A:對B:錯

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

A:對B:錯

答案:對純虛函數(shù)是一個非成員函數(shù)。

A:錯B:對

答案:錯析構函數(shù)必須聲明為虛函數(shù)。

A:錯B:對

答案:錯含有純虛函數(shù)的類可以定義對象。

A:錯B:對

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

A:錯B:對

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

A:錯B:對

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

A:對B:錯

答案:對

第十章單元測試

下列運算符中，（

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

A:+

B:[]

C:::

D:+=

答案:::

利用成員函數(shù)重載運算符：obj1*obj2被編譯器解釋為（）。

A:*(obj1,obj2)B:obj2.operator*(obj1)C:obj1.operator*(obj2)D:operator*(obj1,obj2)

答案:obj1.operator*(obj2)如果對TA類對象使用邏輯運算符“==”重載，以下函數(shù)聲明正確的是（

）。

A:boolTA：：operator==(constTA&a)；B:void&TA：：operator==(constTA&a)；C:TA&TA：：operator==(constTA&a)；D:bool&TA：：operator==(constTA&a)；

答案:boolTA：：operator==(constTA&a)；在重載一個運算符時，其參數(shù)表中沒有任何參數(shù)，這表明該運算符是（

）。

A:作為友元函數(shù)重載的單目運算符B:作為成員函數(shù)重載的單目運算符C:作為友元函數(shù)重載的雙目運算符D:作為成員函數(shù)重載的雙目運算符

答案:作為成員函數(shù)重載的單目運算符在語句intn;cin>>n;中，cin是（

）。

A:類名B:對象名C:函數(shù)名D:變量名

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

）。

A:不可以通過運算符重載來創(chuàng)建C++中原來沒有的運算符B:運算符函數(shù)的返回類型不能聲明為基本數(shù)據(jù)類型C:C++中的運算符不能做多次重載定義D:C++已有的大部分運算符都可以重載

答案:運算符函數(shù)的返回類型不能聲明為基本數(shù)據(jù)類型C++流中重載的運算符<<是一個（

）。

A:用于輸入操作的非成員函數(shù)B:用于輸入操作的成員函數(shù)C:用于輸出操作的非成員函數(shù)D:用于輸出操作的成員函數(shù)

答案:用于輸出操作的非成員函數(shù)若要對BigData類中用成員函數(shù)方式重載取模運算符，下列聲明選項中正確的是（

）。

A:BigData%operator(constBigData);B:BigDataoperator%(constBigData);C:operator%(BigData,BigData);D:BigData%(constBigData);

答案:BigDataoperator%(constBigData);下列運算符中哪些是不能夠被重載的（

）。

A:+=，new，/=，==B:*=，++，delete，=C:[],%,<=,--D:

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

答案:

–>*,.*,sizeof,::,?:下面是重載為非成員函數(shù)的運算符的函數(shù)原型，其中錯誤的是（

）。

A:BigIntoperator-（BigInt，BigInt）；B:BigInt&operator=（BigInt&,BigInt）；C:BigInt&operator*（BigInt,BigInt）；D:BigIntoperator+（BigInt,BigInt）；

答案:BigInt&operator=（BigInt&,BigInt）；如果表達式a>=b，中的“>=”是作為非成員函數(shù)重載的運算符，則可以等效地表示為（

）。

A:a.operator>=(a)B:operator>=(a,b)C:a.operator>=(b,a)D:a.operator>=(b)

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

）。

A:缺少對函數(shù)返回類型的說明B:參數(shù)表中不應該有任何參數(shù)C:函數(shù)聲明中缺少函數(shù)體D:參數(shù)聲明中缺少參數(shù)變量

答案:參數(shù)表中不應該有任何參數(shù)下列關于運算符重載的描述中，正確的是（

）。

A:一元運算符只能作為成員函數(shù)重載B:二元運算符重載成為非成員函數(shù)時，參數(shù)表中有一個參數(shù)C:運算符重載成為成員函數(shù)時，若參數(shù)表中無參數(shù)，重載是一元運算符D:C++中可以重載所有的運算符

答案:運算符重載成為成員函數(shù)時，若參數(shù)表中無參數(shù)，重載是一元運算符下列關于運算符重載的描述中，（

）是正確的。

A:運算符重載可以改變操作數(shù)的個數(shù)B:運算符重載可以改變結合性C:運算符重載不可以改變語法結構D:運算符重載可以改變優(yōu)先級

答案:運算符重載不可以改變語法結構下列關于C++流的敘述中，下面說法正確的是（

）。

A:cin是C++預定義的標準輸入流函數(shù)B:cin是C++預定義的標準輸入流對象C:cin是C++預定義的標準輸入流類D:以上答案都不對

答案:cin是C++預定義的標準輸入流對象若要在Vector類中將*重載為一元運算符，下列重載函數(shù)聲明中肯定有錯的是（

）。

A:intoperator*(Vector);B:Vectoroperator*(Vector,Vector);C:Vectoroperator*(Vector);D:Vectoroperator*();

答案:Vectoroperator*(Vector,Vector);重載流插入運算符<<時，下列設計不合理的是（

）。

A:將運算符函數(shù)的返回值類型設為ostream&B:為運算符函數(shù)設置兩個參數(shù)C:將運算符定義為類的成員函數(shù)D:將運算符函數(shù)的第一個參數(shù)設為ostream&

答案:將運算符定義為類的成員函數(shù)若為類MyNumber重載運算符“/”，下列聲明中，錯誤的是（

）。

A:friendMyNumberoperator/(int,float);B:friendMyNumberoperator/(float,MyNumber);C:friendMyNumberoperator/(MyNumber,MyNumber);D:friendMyNumberoperator/(MyNumber,int);

答案:friendMyNumberoperator/(int,float);運算符重載時以下性質不一定會保持的是（

）。

A:操作數(shù)的個數(shù)、結合性B:優(yōu)先級、結合性C:操作數(shù)的個數(shù)、優(yōu)先級D:返回值類型、操作數(shù)類型

答案:返回值類型、操作數(shù)類型以下類中說明了“++”運算符重載函數(shù)的原型。

classTA

{

public:

......

friendTAoperator++(TA&);

};

編譯器把表達式”++d”解釋為：(

)。

A:operator++(d)B:operator++()C:d.operator++(d)D:d.operator++()

答案:operator++(d)

第十一章單元測試

C++程序進行文件的輸入，除了包含頭文件iostream外，還要包含頭文件（

）。

A:ifstreamB:cstdioC:fstreamD:ostream

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

）。

A:iomanip.hB:stdlib.hC:fstream.hD:iostream.h

答案:iomanip.h下列輸出語句中，不正確的是（

）。

A:cout.put('O');B:cout<<’\t\n’;C:cout<<’A’;D:cout<<0x20;

答案:cout<<’\t\n’;在ios中提供控制格式的標志位中，轉換為十六進制形式的標志位是（

）。

A:leftB:hexC:oct

D:dec

答案:hex在執(zhí)