计算机编程知到智慧树章节测试课后答案2024年秋上海财经大学

计算机编程知到智慧树章节测试课后答案2024年秋上海财经大学第一章单元测试

有定义inta=9,b=6,c;执行语句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;执行语句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:程序段执行无限次

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:函数

B:标识符C:过程D:子程序

答案:函数

下面程序段的输出结果是（

)。

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

第二章单元测试

结构化程序设计所规定的三种基本控制结构是：（

）

。

A:输入、处理、输出B:主程序、子程序、函数C:树形、网形、环形D:顺序、选择、循环

答案:顺序、选择、循环下面程序的输出结果是（

）。

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循环的主要区别是：(

)。

A:

do-while的循环体至少无条件执行一次B:while的循环控制条件比do-while的循环控制条件严格C:do-while的循环体不能是复合语句D:do-while允许从外部转到循环体内

答案:

do-while的循环体至少无条件执行一次下面程序段执行完后，x的值是(

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

if(i)x++;

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

答案:90以下关于do-while循环的不正确描述是（

）。

A:do-while的循环体至少执行一次B:do-while的循环体可以是复合语句C:在do-while循环体中，一定要有能使while后面表达式的值变为零（“假”）)的操作D:do-while循环由do开始，至while结束，在while(表达式)后面不能写分号

答案:do-while循环由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型变量，则执行下面语句后的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:循环执行二次B:循环执行一次C:是死循环D:有语法错误

答案:循环执行一次

第三章单元测试

以下正确的说法是(

)。

A:用户若需要调用标准库函数，调用前必须重新定义B:用户可以重新定义标准库函数，若如此，该函数将失去原有含义C:用户若需调用标准库函数，调用前不必使用预编译命令将该函数所在文件包括到用户源文件中，系统自动去调D:系统根本不允许用户重新定义标准库函数

答案:用户可以重新定义标准库函数，若如此，该函数将失去原有含义以下正确的描述是(

)。

在C++语言中

A:函数的定义和函数的调用均可以嵌套B:函数的定义可以嵌套，但函数的调用不可以嵌套C:函数的定义不可以嵌套，但函数的调用可以嵌套D:函数的定义和函数的调用均不可以嵌套

答案:函数的定义不可以嵌套，但函数的调用可以嵌套以下程序的正确运行结果是(

)。

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++语言规定，函数返回值的类型是由(

)。

A:return语句中的表达式类型所决定B:调用该函数时的主调函数类型所决定C:调用该函数时系统临时决定D:在定义该函数时所指定的函数类型所决定

答案:在定义该函数时所指定的函数类型所决定下面函数调用语句含有实参的个数为(

)。

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

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

答案:2C++语言中，以下不正确的说法是(

)。

A:形参应与其对应的实参类型一致B:实参可以为任意类型C:形参可以是常量、变量和表达式D:实参可以是常量、变量和表达式

答案:形参可以是常量、变量和表达式在计算机高级语言C++中，下面对函数不正确的描述是（

）。

A:允许函数递归调用B:当用数组名作形参时，形参数组元素值的改变可以使实参数组元素的值相应改变C:函数形参的作用范围只是局限于所定义的函数内D:被调用函数必须位于主函数之前

答案:被调用函数必须位于主函数之前对下面程序段的描述正确的是(

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

{

returnx+y;}

intmain()

{

inti=10;

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

return0;}

A:程序输出结果是21B:程序输出结果是20C:程序输出结果不能确定D:程序输出结果是22

答案:程序输出结果是20下列有关形式参数和实际参数的说法正确的是（

）。

A:即便是在发生函数调用时，函数中的形参也不会分配内存单元。B:一般情况下，在调用函数结束后，形参所占的内存单元不会被释放C:在定义函数时，必须在函数首部指定形参的类型。D:定义函数指定的形参，会一直占用内存中的存储单元。

答案:在定义函数时，必须在函数首部指定形参的类型。若使用一维数组名作为函数实参，则以下正确的说法是（

）。

A:必须在主调函数中说明此数组的大小B:在被调函数中，不需要考虑形参数组的大小C:实参数组与形参数组名必须一致D:实参数组类型与形参数组类型可以不匹配

答案:必须在主调函数中说明此数组的大小以下正确的说法是（

）。

A:只有当实参和与其对应的形参同名时才共同占用存储单元；B:形参是虚拟的，不占用存储单元。C:实参和与其对应的形参各占用独立的存储单元；D:实参和与其对应的形参共占用一个存储单元；

答案:实参和与其对应的形参各占用独立的存储单元；以下正确的说法是（

）。

如果在一个函数的复合语句中定义了一个变量，则该变量（

）。

A:只在该复合语句中有效B:为非法变量C:在该函数中有效D:在本程序范围内均有效

答案:只在该复合语句中有效

第四章单元测试

下面关于C++字符数组的叙述中，错误的是（

）。

A:字符数组可以放字符串B:字符数组的字符可以整体输入、输出C:可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值D:可以用关系运算符对字符数组比较大小

答案:可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值若有数组名作为函数调用的实参，则传递给形式参数的是（

）。

A:数组的首地址B:数组第1个元素的值C:数组中全部元素的值D:数组元素的个数

答案:数组的首地址已定义一个数组int

x[10];则对此数组元素正确的引用是（

）。

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

答案:cout<<x[0];假定a为一个整型数组名，则元素a[4]的地址可表示为（

）。

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

D:a+4

答案:a+4设有数组定义char

a[]="China";则数组a所占的空间字节数为（

）。

A:5个字节B:4个字节C:6个字节D:7个字节

答案:6个字节设有定义语句int

a[3][3]，则以下叙述错误的是（

）。

A:a数组可以看成是由a[0]、a[1]、a[2]3个元素组成的一维数组B:a[0]代表一个地址常量C:a[1]是由3个整型元素组成的一维数组D:可以用a[2]=1;的形式给数组元素赋值

答案:可以用a[2]=1;的形式给数组元素赋值有如下声明语句int

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

）。

A:10

B:2

C:3

D:1

答案:2

以下对一维数组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++语言中，引用数组元素时，其数组下标的数据类型允许是（

）。

A:任何类型的表达式B:整型常量或整型表达式C:整型常量D:整型表达式

答案:整型常量或整型表达式在C++中一组同样类型的数据在内容中占用连续存贮空间的数据类型是（

）。

A:指向指针的指针B:数组C:引用

D:指针

答案:数组运行以下程序的输出结果是（

）。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循环的循环次数为（

）.已知：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当定义一个结构体变量时，系统为它分配的内存空间是（

）.

A:结构中第一个成员所需的内存容量B:结构体中占内存容量最大者所需的容量C:结构中一个成员所需的内存容量D:结构中各成员所需内存容量之和

答案:结构中各成员所需内存容量之和运行程序，程序输出结果为(

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

structs{intx;}a[3];

cout<<sizeof(a);

return0;}

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

答案:12定义以下结构体数组，运行程序，程序输出结果是（

）。#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;则以下对数组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;执行语句y=(*++p)--后，数组a中的元素的值变为（

）.

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;则数值为6的表达式是（

）.

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

答案:*(p+5)己知inta[10]={3,7,9,15},*p=a;则不能表示a数组中元素的选项是(

).

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数组中最后一个元素的地址可表示为（

）.

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

答案:a+4有定义inta[]={2,5,6,},*p=a;则*(p+1)所代表的数组元素是(

)。

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:类是创建对象的样板

答案:客观世界中任何一个具体的物体都可以看成一个类在下列关于类和对象的描述中，（

）是错误的。

A:类是对象的模板，对象是类的实例B:客观世界中任何一个具体的物体都可以看成一个对象C:把某些具有共同属性和行为的对象抽象为一种类型被称为类D:类是抽象的，对象是具体的，两者都占有内存空间

答案:类是抽象的，对象是具体的，两者都占有内存空间类的实例化是指（

）。

A:调用类B:创建类的对象C:定义类D:指明具体类

答案:创建类的对象下列说法中正确的是（

）。

A:类中的成员数据可以在类体中（类内）定义，也可以在类体之外（类外）定义B:类的成员函数只能在类体中(类内)定义C:类的成员函数既可以定义在类体中（类内），也可以定义在类体外（类外），但必须在类体中（类内）声明D:在类体之外定义的成员函数不能操作该类的私有数据成员

答案:类的成员函数既可以定义在类体中（类内），也可以定义在类体外（类外），但必须在类体中（类内）声明关于构造函数不正确的说法是(

)。

A:构造函数初始化时为对象开辟内存空间B:一个类可以有多个构造函数C:构造函数名与类名相同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.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();要让一个类中的所有对象的同一数据有不同的值，请不要使用（）。

A:私有数据成员B:静态数据成员C:保护数据成员D:公有数据成员

答案:静态数据成员下面选项中不属于面向对象程序设计特征的是(

)。

A:封装性B:抽象性C:继承性D:多元性

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

）。

A:类A一定是类C的友元B:类C的成员函数可以访问类B的对象的任何成员C:类A的成员函数可以访问类B的对象的任何成员D:类C一定是类A的友元

答案:类A的成员函数可以访问类B的对象的任何成员成员函数代码量很多，或具有多个成员函数，采用类内定义的方式比较合适。

A:对B:错

答案:错成员函数是一个类的成员，出现在类体中，也就是只能被类内其他成员函数调用。

A:错B:对

答案:错通过对象无法访问private和protected属性的成员变量和成员函数，而仅可以访问public属性的成员变量和成员函数。

A:错B:对

答案:对在C++语言中，可以通过传值方式作为函数的参数或函数返回值。

A:对B:错

答案:对构造函数可以有返回值也可以无返回值。

A:对B:错

答案:错构造函数可以有一个参数或多个参数，可以为参数设置一个默认值。

A:对B:错

答案:对任何一个对象只能属于一个具体的类。

A:对B:错

答案:对声明时加关键字static的类中所有的成员数据是属于类的，任何一个对象都可以共享该成员数据。

A:错B:对

答案:对友元函数是成员函数，友元函数可以访问类中的私有成员。

A:对B:错

答案:错无论什么方式的继承，基类的私有成员都不能被派生类成员函数访问（引用）。

A:错B:对

答案:对

第八章单元测试

下列对派生类的描述中，错误的是（

）。

A:派生类的成员除了它自己的成员之外，还包含了它的基类的成员B:派生类至少有一个基类C:派生类中继承的基类成员的访问权限到派生类保持不变D:一个派生类可以作为另一个派生类的基类

答案:派生类中继承的基类成员的访问权限到派生类保持不变下列有关继承和派生的叙述中，不正确的是（

）。

A:一个基类只能派生出一个派生类B:每一个派生类又可以作为基类再派生出新的派生类C:派生类继承了基类的所有数据成员和成员函数D:派生类可以继承到基类成员的基础上增加新的成员

答案:一个基类只能派生出一个派生类下列有关继承和派生的叙述中，不正确的是（

）。

A:一个基类可以派生出多个派生类B:派生类继承了基类的所有数据成员和成员函数C:一个派生类不能作为基类再派生出新的派生类D:一个派生类不仅可以从一个基类派生，也可以从多个基类派生

答案:一个派生类不能作为基类再派生出新的派生类下列对派生类的描述中，错误的是（

）。

A:派生类的缺省（默认）继承方式是privateB:派生类至少有一个基类C:派生类只继承了基类的公有成员和保护成员D:一个派生类可以作为另一个派生类的基类

答案:派生类只继承了基类的公有成员和保护成员下列有关继承和派生的叙述中，不正确的是（

）。

A:基类的成员函数可以访问基类成员B:派生类的成员函数可以访问派生类自己增加的成员C:基类的成员函数可以访问派生类的成员D:派生类的新增公用成员可以被该类创建的对象引用

答案:基类的成员函数可以访问派生类的成员下列有关公共继承的继承和派生的关系描述中，不正确的是（

）。

A:基类的私有成员，因为是公用继承，可以被派生类的新增成员函数引用B:派生类的公用成员可以被派生类创建的对象引用C:基类的公用成员和保护成员在派生类中仍然保持其公用成员和保护成员的属性D:基类的私有成员，基类的成员函数可以引用它

答案:基类的私有成员，因为是公用继承，可以被派生类的新增成员函数引用下列有关继承和派生的叙述中，正确的是（

）。

A:派生类成员函数不能访问通过私有继承的基类的保护成员B:基类的公用成员在派生类中仍然是公用成员C:私有继承的派生类作为基类继续派生，下一层的派生类无法访问它的任何成员D:基类的保护成员在派生类中仍然是保护成员

答案:私有继承的派生类作为基类继续派生，下一层的派生类无法访问它的任何成员下列有关保护继承的继承和派生的叙述中，正确的是（

）。

A:派生类成员函数不能访问通过保护继承的基类的公有成员B:派生类成员函数不能访问通过保护继承的基类的私有成员C:派生类成员函数不能访问通过保护继承的基类的保护成员D:基类的私有成员在派生类中变为是保护成员

答案:派生类成员函数不能访问通过保护继承的基类的私有成员下列有关继承和派生的叙述中，正确的是（

）。

A:派生类析构函数可以被继承，派生类构造函数不能被继承B:派生类构造函数可以被继承，派生类析构函数不能被继承C:派生类构造函数的总参数表列中的参数，应当包括基类构造函数和子对象的参数表列中的参数D:在执行派生类的构造函数时，调用基类的构造函数就可以对子对象初始化

答案:派生类构造函数的总参数表列中的参数，应当包括基类构造函数和子对象的参数表列中的参数下列有关继承和派生的叙述中，正确的是（

）。

A:基类的指针变量可以指向派生类对象B:派生类的指针变量可以指向基类对象C:派生类的指针变量，可以访问基类的成员D:基类的指针变量，可以访问派生类新增加的成员

答案:基类的指针变量可以指向派生类对象一个派生类不仅可以从一个基类派生，也可以从多个基类派生。

A:错B:对

答案:对继承方式包括:public(公用的),

private(私有的)和protected(受保护的)，应用中public(公用的)最常见。

A:对B:错

答案:对当不需要对派生类新增的成员进行任何初始化操作时，派生类构造函数的函数体可以为空，即构造函数是空函数。

A:错B:对

答案:对在派生时，派生类不能继承基类的析构函数。

A:对B:错

答案:对派生类的指针变量也可以指向基类对象。

A:对B:错

答案:错派生类的继承方式有两种：公有继承和私有继承。

A:错B:对

答案:错在公有继承中，派生类对象只能引用基类中的公有成员和派生类新增的公共成员。

A:对B:错

答案:对在私有继承中，基类中只有公有成员可以被派生类成员函数引用。

A:对B:错

答案:错派生类是它的基类的组合。

A:对B:错

答案:错析构函数不能被继承。

A:对B:错

答案:对

第九章单元测试

下列描述中，(

)是抽象类的特性。

A:

可以定义友元函数B:

不能创建其对象C:

可以进行构造函数重载D:

可以声明虚函数

答案:

不能创建其对象关于虚函数的描述中，（

）是正确的。

A:派生类的虚函数与基类的虚函数具有不同的参数个数和类型B:

虚函数是一个非成员函数C:

虚函数是一个static类型的成员函数D:

基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数

答案:

基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数实现运行时的多态性采用(

)。

A:虚函数B:构造函数C:重载函数D:析构函数

答案:虚函数以下基类中的成员函数表示纯虚函数的是(

)。

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

答案:virtualvoidtt()=0关于纯虚函数和抽象类的描述中，(

)是错误的。

A:一个基类中声明有纯虚函数，该基类的派生类一定不再是抽象类B:抽象类是指具有纯虚函数的类C:纯虚函数是一种特殊的虚函数，它不能实例化对象

D:抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

答案:一个基类中声明有纯虚函数，该基类的派生类一定不再是抽象类下列有关C++的面向对象方法的多态的概念的叙述中，不正确的是（

）。

A:存在基类类型的指针指向派生类对象，且通过该指针调用虚函数B:C++的面向对象方法的多态，必须存在基类指针指向派生类对象C:存在基类类型的指针指向派生类对象，基类和派生类的同名虚函数的参数必须相同D:必须存在着声明为虚函数的友元函数

答案:必须存在着声明为虚函数的友元函数执行以下程序代码后，将会输出的结果是（）。#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++的面向对象方法的多态和虚函数的叙述中，正确的是（

）。

A:基类析构函数可以声明为虚函数B:构造函数和析构函数都能声明为虚函数C:构造函数和析构函数都不能声明为虚函数D:派生类的析构函数可以声明为虚函数

答案:基类析构函数可以声明为虚函数如果一个类至少有一个纯虚函数，那么就称该类为（

）。

A:派生类B:虚函数C:都不对D:抽象类

答案:抽象类下列有关C++的面向对象方法的多态和虚函数的叙述中，不正确的是（

）。

A:包含纯虚成员函数的类即为抽象基类B:抽象基类不能实例化C:抽象基类的派生类，增加新的成员函数或成员数据后，可以用于创建对象D:包含纯虚成员函数的抽象基类的派生类，在派生类中可以重新定义纯虚函数为非纯虚成员函数

答案:抽象基类的派生类，增加新的成员函数或成员数据后，可以用于创建对象类的成员函数前面加virtual关键字，则这个成员函数称为虚函数。

A:错B:对

答案:对虚函数是一个成员函数。

A:错B:对

答案:对要想形成多态必须具备必须存在继承关系，继承关系中必须有同名的虚函数，并且基类和派生类的同名虚函数的参数必须不同。

A:对B:错

答案:错将基类中的成员函数通过virtual关键字声明为虚函数之后，即使在派生类中同名同参数函数声明时未加上virtual关键字，但它在所有的派生类中都将自动成为虚函数。

A:对B:错

答案:对纯虚函数是一个非成员函数。

A:错B:对

答案:错析构函数必须声明为虚函数。

A:错B:对

答案:错含有纯虚函数的类可以定义对象。

A:错B:对

答案:错纯虚成员函数可以被派生类继承，如果派生类不重新定义抽象基类中的所有纯虚成员函数，则派生类同样会成为抽象基类，因而也不能用于创建对象。

A:错B:对

答案:对如果派生类的成员函数的原型（函数的首部）与基类中被定义为虚函数的成员函数原型相同，那么，这个函数自动继承基类中虚函数的特性。

A:错B:对

答案:对纯虚函数是一个在基类中声明的没有具体内容的虚函数，为了实现多态（或接口功能），要求派生类定义自己的版本。

A:对B:错

答案:对

第十章单元测试

下列运算符中，（

）运算符在C++中不能重载。

A:+

B:[]

C:::

D:+=

答案:::

利用成员函数重载运算符：obj1*obj2被编译器解释为（）。

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

答案:obj1.operator*(obj2)如果对TA类对象使用逻辑运算符“==”重载，以下函数声明正确的是（

）。

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)；在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（

）。

A:作为友元函数重载的单目运算符B:作为成员函数重载的单目运算符C:作为友元函数重载的双目运算符D:作为成员函数重载的双目运算符

答案:作为成员函数重载的单目运算符在语句intn;cin>>n;中，cin是（

）。

A:类名B:对象名C:函数名D:变量名

答案:对象名关于运算符重载，下列表述中错误的是（

）。

A:不可以通过运算符重载来创建C++中原来没有的运算符B:运算符函数的返回类型不能声明为基本数据类型C:C++中的运算符不能做多次重载定义D:C++已有的大部分运算符都可以重载

答案:运算符函数的返回类型不能声明为基本数据类型C++流中重载的运算符<<是一个（

）。

A:用于输入操作的非成员函数B:用于输入操作的成员函数C:用于输出操作的非成员函数D:用于输出操作的成员函数

答案:用于输出操作的非成员函数若要对BigData类中用成员函数方式重载取模运算符，下列声明选项中正确的是（

）。

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

答案:BigDataoperator%(constBigData);下列运算符中哪些是不能够被重载的（

）。

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

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

答案:

–>*,.*,sizeof,::,?:下面是重载为非成员函数的运算符的函数原型，其中错误的是（

）。

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

答案:BigInt&operator=（BigInt&,BigInt）；如果表达式a>=b，中的“>=”是作为非成员函数重载的运算符，则可以等效地表示为（

）。

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

答案:operator>=(a,b)在名为BigNumber类的类体中对运算符函数double进行如下声明：operatordouble(BigNumber);函数声明中有一个明显的错误，这个错误就是（

）。

A:缺少对函数返回类型的说明B:参数表中不应该有任何参数C:函数声明中缺少函数体D:参数声明中缺少参数变量

答案:参数表中不应该有任何参数下列关于运算符重载的描述中，正确的是（

）。

A:一元运算符只能作为成员函数重载B:二元运算符重载成为非成员函数时，参数表中有一个参数C:运算符重载成为成员函数时，若参数表中无参数，重载是一元运算符D:C++中可以重载所有的运算符

答案:运算符重载成为成员函数时，若参数表中无参数，重载是一元运算符下列关于运算符重载的描述中，（

）是正确的。

A:运算符重载可以改变操作数的个数B:运算符重载可以改变结合性C:运算符重载不可以改变语法结构D:运算符重载可以改变优先级

答案:运算符重载不可以改变语法结构下列关于C++流的叙述中，下面说法正确的是（

）。

A:cin是C++预定义的标准输入流函数B:cin是C++预定义的标准输入流对象C:cin是C++预定义的标准输入流类D:以上答案都不对

答案:cin是C++预定义的标准输入流对象若要在Vector类中将*重载为一元运算符，下列重载函数声明中肯定有错的是（

）。

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

答案:Vectoroperator*(Vector,Vector);重载流插入运算符<<时，下列设计不合理的是（

）。

A:将运算符函数的返回值类型设为ostream&B:为运算符函数设置两个参数C:将运算符定义为类的成员函数D:将运算符函数的第一个参数设为ostream&

答案:将运算符定义为类的成员函数若为类MyNumber重载运算符“/”，下列声明中，错误的是（

）。

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

答案:friendMyNumberoperator/(int,float);运算符重载时以下性质不一定会保持的是（

）。

A:操作数的个数、结合性B:优先级、结合性C:操作数的个数、优先级D:返回值类型、操作数类型

答案:返回值类型、操作数类型以下类中说明了“++”运算符重载函数的原型。

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在执