计算机编程智慧树知到课后章节答案2023年下上海财经大学

计算机编程智慧树知到课后章节答案2023年下上海财经大学上海财经大学

第一章测试

有定义inta=9,b=6,c;执行语句c=a/b+0.5;后,c的值为(

)。

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

答案:1

C++语言源代码文件扩展名为（

）。

A:.cppB:.c++C:.objD:.exe

答案:.cpp

以下用户标识符中，合法的是（）。

A:IntB:Ling@liC:moonD:%123

答案:moon

intx=10，y=5；则表达式x+=x*=y+8的值为（

）。

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

答案:260

5、有定义inta=9,b=6,c;执行语句c=a/b+0.5;后,c的值为(

)。

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

答案:1

以下标识符中，不能作为合法的C++用户定义标识符的是（

）。

A:signedB:answerC:_ifD:to

答案:signed

下列字符串中可以用作C++标识符的是（

）。

A:deleteB:5charC:classD:_256

答案:_256

下列C++标点符号中表示一条预处理命令开始的是（

）。

A:#B://

C:;D:}

答案:#

9、以下程序的运行结果是(

)。main()

{

inta,b,d=241;

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

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

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

答案:2,1

语句while(!E);中的表达式!E等价于(

)

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

答案:E==0

下面程序段的运行结果是：(

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

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

2,1,1

答案:1,2,0

设有程序段：

int

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

)。

A:运行程序段后输出1B:程序段执行无限次

C:程序段中的控制表达式是非法的D:运行程序段后输出0

答案:运行程序段后输出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:1,12B:5,25C:不确定D:12,2

答案:5,25

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

）。

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

答案:int&X=m；

C++语言源程序的基本单位是(

)。

A:子程序B:函数

C:标识符D:过程

答案:函数

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

)。

chara[7]=”abcdef”;

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

A:bB:eC:D:f

答案:f

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

）。

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

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

答案: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*AB:SWC:WD:W*

答案:W*

C++语言中，while和do-while循环的主要区别是：(

)。

A:do-while的循环体不能是复合语句B:

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

答案:

do-while的循环体至少无条件执行一次

下面程序段执行完后，x的值是(

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

if(i)x++;

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

答案:90

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

）。

A:do-while的循环体至少执行一次B:在do-while循环体中，一定要有能使while后面表达式的值变为零（“假”）)的操作C:do-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:0B:1113C:111315D:15

答案:0

以下程序的输出是（

）。#include<stdio.h>

main()

{intx=1;

if(x=2)

cout<<“OK”;

elseif(x<2)cout<<x;

elsecout<<“Quit”;

}

A:1B:QuitC:无输出结果D:OK

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

答案:1

若u、w、x、y均是正整型变量，则以下正确的switch语句是（

）。

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

case11:w=x-y;break;}

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

case10:w=x-y;break;

case11:u=x*y;break;}

C:switch(x*x+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;}

答案: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==0B:E!=1C:E==1D:E!=0

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

8

9B:71013C:7

911D:7

7

7

答案: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,8C:8,20D:8,16

答案:8,17

C++语言规定，函数返回值的类型是由(

)。

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

答案:在定义该函数时所指定的函数类型所决定

下面函数调用语句含有实参的个数为(

)。

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

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

答案:2

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

)。

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:程序输出结果是20B:程序输出结果是21C:程序输出结果是22D:程序输出结果不能确定

答案:程序输出结果是20

下列有关形式参数和实际参数的说法正确的是（

）。

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

答案:在定义函数时，必须在函数首部指定形参的类型。

若使用一维数组名作为函数实参，则以下正确的说法是（

）。

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

答案:必须在主调函数中说明此数组的大小

以下正确的说法是（

）。

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

答案:实参和与其对应的形参各占用独立的存储单元；

以下正确的说法是（

）。

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

）。

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

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

第四章测试

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

）。

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

答案:可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值

若有数组名作为函数调用的实参，则传递给形式参数的是（

）。

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

答案:数组的首地址

已定义一个数组int

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

）。

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

答案:cout<<x[0];

假定a为一个整型数组名，则元素a[4]的地址可表示为（

）。

A:a+8

B:a+32C:a+16D:a+4

答案:a+4

设有数组定义char

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

）。

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

答案:6个字节

设有定义语句int

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

）。

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

答案:可以用a[2]=1;的形式给数组元素赋值

有如下声明语句int

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

）。

A:10

B:3

C:2

D:1

答案:2

以下对一维数组a的正确定义是(

)。

A:inta(9);B:constintN=9;

inta[N];C:intn;cin>>n;inta[n];D:intn=9,a[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:11

13

15

C:0D:15

答案:0

若有初始化char

a[]="BASIC"；则cout<<&a[3];的输出结果是（

）。

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

答案:"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:24B:6C:720D:120

答案:120

下列do-while循环的循环次数为（

）.已知：int

j=5;do{

cout<<j--<<endl;

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

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

答案:无限

若有定义charstr1[10]={"China"},str2[10];要将str1中的字符串复制到str2中去，正确的方法是（

）.

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

答案:strcpy(str2,str1);

第五章测试

下面结构体的定义语句中错误的是（

）.

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

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

struct

abc{intx;inty;}data1=(2,3),data2;则以下赋值语句中错误的是（

）。

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

答案: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:10C:21D:11

答案:20

运行程序，程序输出结果是（

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

struct

stud

{

char

num[5];

int

s[4];

double

ave;

}a;

cout<<sizeof(stud)<<endl;

return0;}

A:29B:30

C:32

D:31

答案:32

有下列结构体声明语句struct

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

s[3]={123,"LiFang",67,89,90};要对第1个学生的成绩输出总分，下列表达式正确的是（

）.

A:cout<<score[0].s[1]+score[1].s[1]+score[2].s[1];B:cout<<s.score[0]+s.score[1]+s.score[2];C:cout<<s.score[1]+s.score[2]+s.score[3];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:16B:18C:12D:14

答案:16

当定义一个结构体变量时，系统为它分配的内存空间是（

）.

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

答案:结构中各成员所需内存容量之和

运行程序，程序输出结果为(

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

structs{intx;}a[3];

cout<<sizeof(a);

return0;}

A:6B:4

C:18D:12

答案:12

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

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

structc

{intx;

inty;

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

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

return0;}

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

答案: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:f,4B:l,4C:n,3D:i,3

答案:f,4

#include<iostream>usingnamespacestd;structstudent

{

charname[10];

intscore[50];

floataverage;

}stud1;

intmain(){

cout<<sizeof(student);

return0;}

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

答案: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:guangzhou,2009B:Tianjin,2008C:Tianjin,2009D:guangzhou,2008

答案: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:4E5SB:c2U3F4EC:F4ED:3F4E5S

答案:4E5S

第六章测试

若有定义语句intc[5],*p=c;则以下对数组c第1个元素地址的正确引用是（

）。

A:c++B:p+5C:&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:123

C:345

D:234

答案: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:6B:4

C:0D:5

答案:4

inta[]={1,2,3,4},y,*p=a;执行语句y=(*++p)--后，数组a中的元素的值变为（

）.

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

答案:1，1，3，4

运行程序，程序输出结果是（

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

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

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

return

0;}

A:pB:rogramC:ogramD:pro

答案:ogram

运行程序，程序输出结果是（

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

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

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

return

0;}

A:r

B:p

C:rogram

D:pro

答案:p

运行程序，程序输出结果是（

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

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

str[3]=0;

cout<<p<<endl;

return

0;}

A:ogramB:oC:pro

D:r

答案:pro

若有变量定义语句int

a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则数值为6的表达式是（

）.

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

答案:*(p+5)

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

).

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

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

B:11

13

C:11

13

15

D:0

答案: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:变量p的地址C:stringD:变量a的地址

答案:变量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:abcB:d

C:abcdD:a

答案:d

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

）.

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

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

答案:4321

已知有定义inta[5];a数组中最后一个元素的地址可表示为（

）.

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

答案:a+4

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

)。

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

答案:a[1]

已有定义inta[10],*p;则正确的赋值语句是（

）.

A:p=a[2]+2;B:p=100;C:p=a[5];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:

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

答案:t.set()

有如下定义和语句：classStudent{public:

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

intnum;

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

A:

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

答案:p->display();

要让一个类中的所有对象的同一数据有不同的值，请不要使用（）。

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

答案:静态数据成员

下面选项中不属于面向对象程序设计特征的是(

)。

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

答案:多元性

已知类A是类B的友元，类B是类C的友元，则（

）。

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

答案:类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:派生类至少有一个基类B:派生类的缺省（默认）继承方式是privateC:派生类只继承了基类的公有成员和保护成员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:voidtt(int)=0B:virtualvoidtt()=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!C:I'mDerivedclass!D:I'mBaseclass!I'mDerivedclass!

答案: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:obj2.operator*(obj1)B:*(obj1,obj2)C:operator*(obj1,obj2)D:obj1.operator*(obj2)

答案:obj1.operator*(obj2)

如果对TA类对象使用逻辑运算符“==”重载，以下函数声明正确的是（

）。

A:boolTA：：operator==(constTA&a)；B:TA&TA：：operator==(constTA&a)；C:void&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:operator%(BigData,BigData);B:BigData%(constBigData);C:BigDataoperator%(constBigData);D:BigData%operator(constBigData);

答案:BigDataoperator%(constBigData);

下列运算符中哪些是不能够被重载的（

）。

A:*=，++，delete，=B:

–>*,.*,sizeof,::,?:C:[],%,<=,--D:+=，new，/=，==

答案:

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

下面是重载为非成员函数的运算符的函数原型，其中错误的是（

）。

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

答案:BigInt&operator=（BigInt&,BigInt）；

如果表达式a>=b，中的“>=”是作为非成员函数重载的运算符，则可以等效地表示为（

）。

A:operator>=(a,b)B:a.operator>=(b,a)C:a.operator>=(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:以上答案都不对D:cin是C++预定义的标准输入流对象

答案:cin是C++预定义的标准输入流对象

若要在Vector类中将*重载为一元运算符，下列重载函数声明中肯定有错的是（

）。

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

答案:Vectoroperator*(Vector,Vector);

重载流插入运算符<<时，下列设计不合理的是（

）。

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

答案:将运算符定义为类的成员函数

若为类MyNumber重载运算符“/”，下列声明中，错误的是（

）。

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

答案:friendMyNumberoperator/(int,float);

运算符重载时以下性质不一定会保持的是（

）。

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

答案:返回值类型、操作数类型

以下类中说明了“++”运算符重载函数的原型。

classTA

{

public:

......

friendTAoperator++(TA&);

};

编译器把表达式”++d”解释为：(

)。

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

答案:operator++(d)

第十一章测试

C++程序进行文件的输入，除了包含头文件iostream外，还要包含头文件（

）。

A:ostreamB:ifstreamC:cstdioD:fstream

答案:ifstream

C++语言中，程序通过操纵符进行格式输出处理时，必须包含的头文件是（

）。

A:stdlib.hB:iostream.h

C:iomanip.hD:fstream.h

答案:iomanip.h

下列输出语句中，不正确的是（

）。

A:cout<<0x20;

B:cout<<’A’;C:cout.put('O');D:cout<<’’;

答案:cout<<’\t\n’;

在ios中提供控制格式的标志位中，转换为十六进制形式的标志位是（

）。

A:hexB:decC:oct

D:left