C++程序设计知到智慧树章节测试课后答案2024年秋对外经济贸易大学

C++程序设计知到智慧树章节测试课后答案2024年秋对外经济贸易大学第一章单元测试

能作为C++程序的基本单位是（）。

A:函数B:语句C:源程序文件D:字符

答案:语句关于C++与C语言的关系的描述中，错误的是（）。

A:C++和C语言都是面向对象的B:C语言与C++是兼容的C:C语言是C++的一个子集D:C++对C语言进行了一些改进

答案:C++和C语言都是面向对象的C++中的注释用于什么目的（）。

A:解释代码的功能和目的B:定义变量C:用于调试代码D:控制程序的执行顺序

答案:解释代码的功能和目的2.下列描述中，不属于面向对象思想主要特征的是（）。

A:封装性B:继承性C:跨平台性D:多态性

答案:跨平台性在每个C++程序中必须有且仅有一个（）。

A:主函数B:语句C:预处理指令D:函数

答案:主函数

第二章单元测试

下列语句中，与语句“n=(a>b?(b>c?1:0):0);”的功能等价的是（）

A:if(a<b)n=0;B:if((a>b)%7c%7c(b>c))n=1;elsen=0;C:if(a>b)n=1;elseif(b<=c)n=l;elseif(b>c)n=1;elsen=0；D:if(a>b)if(b>c)n=l;elsen=0;elsen=0;

答案:if(a>b)if(b>c)n=l;elsen=0;elsen=0;在C++的switch语句中，用于处理没有任何case匹配且没有默认分支的情况时，会发生什么？（）。

A:程序会立即退出B:序会进入死循环C:程序会继续执行后面的代码D:程序会抛出异常

答案:程序会继续执行后面的代码在C++中，SWITCH语句可以用于整数、字符和枚举类型的条件判断。（）

A:错B:对

答案:对下列哪个语句用于实现单一条件判断？（）

A:while循环语句B:switch语句C:if-else语句D:for循环语句

答案:if-else语句执行下列语句：

#include<iostream>

usingnamespacestd;

intmain()

{

intx=3;

if(x=5)

cout<<x++<<endl;

else

cout<<x<<endl;

return0;

}

输出的程序是（）

A:6B:4C:5D:3

答案:5下列代码片段的运行结果是什么？（）

#include<iostream>

usingnamespacestd;

intmain()

{

intscore=85;

chargrade;

if(score>=90){

grade='A';

}elseif(score>=80){

grade='B';

}elseif(score>=70){

grade='C';

}else{

grade='D';

}

cout<<"Grade:"<<grade;

}

A:“Grade:A”B:“Grade:C”C:“Grade:B”D:“Grade:D”

答案:“Grade:B”若整型变量a、b、c、d中的值依次为：1、4、3、2。则条件表达式a＜b？a:c＜d？c:d的值是（）。

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

答案:1程序执行后的输出结果是（）

#include<iostream.h>

intmain（)

{

charflag='c';

switch(flag)

{

case'a':cout<<"1"<<endl;

case'b':cout<<"2"<<endl;break;

case'c':cout<<"3"<<endl;

default:cout<<"4"<<endl;break;

}

}

A:34B:12C:23D:45

答案:34

第三章单元测试

执行语句序列（B）。

inti=0；

while(i<25)i+=3；

cout<<i；

输出结果是（）

A:27B:24C:25D:28

答案:27执行下面程序输出的结果是（）

#include<iostream.h>

intmain()

{

inti=0;

while(++i)

{

if(i==10)break;

if(i%3!=1)continue;

cout<<i<<endl;

}

}

A:247B:731C:147D:432

答案:147执行下列语句段后，输出字符“*”的个数是（）。

for（inti=50；i>1；--i）cout<<’*’

A:48B:50C:54D:49

答案:49当执行以下程序段时，循环体将执行（）

intmain(){

inty=1;

do{y--;}while(--y);

}（）

A:一次B:无限次C:两次D:系统将提示有语法错误

答案:无限次do-while循环保证循环体至少会被执行一次（）

A:错B:对

答案:对下列for循环的循环体执行次数为（）

for(inti=0，J=10:i-4:i++.J--)

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

答案:无限循环控制语句break的功能是什么？（）

A:结束整个程序的执行B:终止当前循环的执行C:清除循环计数器的值D:跳过本次循环的剩余代码，直接进行下一次循环

答案:终止当前循环的执行下列哪个循环语句先判断循环条件，再执行循环体（）

A:while循环B:do-while循环C:都不是D:for循环

答案:do-while循环如下程序运行时的输出结果是（）。

#include<iostream>

usingnamespacestd;

intmain(){

intsum;

for(inti=0;i<6;i+=3){

sum=i;

for(intj=i;j<6;j++)sum+=j;}

cout<<sum<<endl;

return0;

A:15B:12C:3D:10

答案:15

第四章单元测试

在下列double型常量表示中，错误的是（）。

A:35B:E15C:3E5D:3E-5

答案:E15静态局部变量具有什么样的作用域？（）

A:只在文件内部可见B:只在特定的代码块内部可见C:只在类内部可见D:只在函数内部可见

答案:只在文件内部可见指针可以为空（NULL），而引用不能为空。（）

A:对B:错

答案:对字面常量42、4.2、42L的数据类型分别是（）。

A:int,float,longB:long,float,intC:int,double,longD:long,double,int

答案:int,double,long下列有关指针的用法中，错误的是（）

A:int*p；p=0；B:inti=5；int*p；p=&i；C:inti；int*p=&i；D:inti；int*p；i=*p；

答案:inti；int*p；i=*p；

第五章单元测试

以下程序的输出的结果是（）。

#include<iostream

intmain(){

inta,b,c;

c=2;

c+=10;

a=b=10;

a=2;

b/=2;

c%2;

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

A:20，5，1B:20，7，0C:20，5，0D:5，20，0

答案:20，5，0若有定义“intx=4，y=5；”，则表达式“y>x++?x--:y++”的值为（）。

A:5B:4C:6D:3

答案:5下面程序的运行结果是（）

intmain(){

intx=5;

if(x++==5)cout<<"五"<<endl;

elseif(++x==6);

cout<<"六"<<endl;

return0;

}

A:这些都不是B:五六C:五D:六

答案:五下面程序的运行结果是（）

intmain(){

inti=0,x=0;

do{

if(i%5==0){cout<<x;x++;}

++i;

}while(i<10);

cout<<x;

return0;

}

A:01B:0C:012D:0123

答案:01210.设intx;，则与计算︱x︱等价的表达式是（）。

A:x<0?x:-xB:x>0?x:-xC:x>0?-x:xD:x<0?-x:-x

答案:x>0?x:-x设inta,x=2;执行语句a=x>0?3*x:x=10；后，变量x的值是（）。

A:10B:1C:6D:2

答案:6若有定义语句“inti=2，j=3；”，则表达式i/j的结果是（）。

A:0.7B:0C:0.66667D:0.66666667

答案:0已知i=5，j=0，下列各式中运算结果为j=5的表达式是（）。

A:j=++i+jB:j=j+i++C:j=i+(++j)D:j=j+++i

答案:j=j+i++将以下程序写成三目运算表达式是（）。

if（x＜y）min=x：

elsemin=y；

A:min=（x＞y）？x:yB:min=（x＜y）x:yC:min=（x＜y）？x:yD:min=（x＜y）？x,y

答案:min=（x＜y）？x:y

第六章单元测试

若已定义

inta[]=0,1,2,3,4,5,6,7,8,9,*p=a,i；

其中0≤i≤9,则对a数组元素不正确的引用是（）。

A:a[10]B:a[p-a]C:p[i]D:*(&a[i])

答案:a[10]若有说明:inta[][4]={0,0};则下面不正确的叙述是（）.

A:元素a[0][0]和a[0][1]可得到初值0,其余元素均得不到初值0B:因为二维数组a中第二维大小的值除初值个数的商为1,故数组a的行数为1C:数组a的每个元素都可得到初值0D:二维数组a的第一维大小为1

答案:元素a[0][0]和a[0][1]可得到初值0,其余元素均得不到初值0下列定义中,（）是定义指向数组的指针p。

A:int＊p［］B:int*p[5］C:(int*)p[5］D:int（*p)[5］

答案:int*p[5］下列程序的输出结果是（）。

#include<iostream.h>

intmain()

{intn[][3]={10,20,30,40,50,60}

int(*p)［3］;

p=n;

cout<<p［0］［0］<<","<<*(p［0］+1)<<","<<(*p)［2］<<endl;}

A:10，30，50B:20，40，60C:10，20，30D:10，30，60

答案:10，20，30下列有关一维数组a的定义中，语法正确的是（）。

A:inta（10）；B:intn=7，a[n]；C:constintsize=10；inta[size]D:intn；cin>>n；inta[n]；

答案:constintsize=10；inta[size]有如下说明inta[10]=1，2，3，4，5，6，7，8，9，10，*p=a；则数值为9的表达式是（）。

A:*（p+8）B:*p+=9C:p+8D:*p+9

答案:*（p+8）对于int*pa[5]；的描述，正确的是（）。

A:pa[5]表示某个数组的第5个元素的值B:pa是一个指向某个数组中第5个元素的指针，该元素是int型变量C:pa是一个具有5个元素的指针数组，每个元素是一个int型指针D:pa是一个指向数组的指针，所指向的数组是5个int型元素

答案:pa是一个具有5个元素的指针数组，每个元素是一个int型指针下列程序的输出结果是（）。

#include<iostream.h>

intmain()

{intn[][3]={10,20,30,40,50,60};

int(*p)[3];

p=n;

cout<<p[0][0]<<","<<∗(p[0]+1)<<","<<(*p)[2]<<endl;}

A:20，40，60B:10，20，30C:10，30，60D:10，30，50

答案:10，20，30

第七章单元测试

若有以下定义和语句：charstrl[]="string",str2[5];则用以复制字符串的正确方法（）

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

答案:strcpy(str2,"Hello");在C++中，以下哪个字符串函数用于将两个字符串连接起来？（）

A:strcat()B:strncpy()C:strcpy()D:strncat()

答案:strcat()已知有数组定义chara[3][4]；下列表达式中错误的是（）。

A:a[2][3]=′W′B:a[0][1]=a[0][1]C:a[2]=“WIN”D:strcpy（a[2]，“WIN”）

答案:a[2]=“WIN”有如下语句序列：charstr[10]；cin>>str；当从键盘输入“Ilovethisgame”时，str中的字符串是（）。

A:“I”B:“Ilove”C:“Ilovethi”D:“Ilovethisgame”

答案:“I”下列描述中不正确的是（）。

A:字符型数组中可以存放字符串B:可以对实型数组进行整体输入、输出C:不能在赋值语句中通过赋值运算符“=”对字符型数组进行整体赋值D:可以对字符型数组进行整体输入、输出

答案:可以对实型数组进行整体输入、输出下面程序的输出结果为（）

#include<iostream.h>

#include"string.h"

intmain()

{chara[]="HelloTest",b[]="Test";strcpy(a,b);

cout<<a<<endl;}

A:TestB:HelloTestHelloTestC:HelloTestD:Hello

答案:Test

第八章单元测试

若下列关于C++函数的说明中，正确的是（）。

A:标准C++要求在调用一个函数之前，必须先声明其原型B:内联函数就是定义在另一个函数体内部的函数C:编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式D:函数体的最后一条语句必须是return语句

答案:标准C++要求在调用一个函数之前，必须先声明其原型若有下面的函数调用:fun（a+b，3，max（n-1，b））则fun的实参个数是（）。

A:5B:6C:3D:4

答案:3若一个函数的原型为“int*funl（intx，int&y，charz）；”，则该函数的返回值类型为（）。

A:int*B:int&C:charD:int

答案:int*有如下程序：

#include<iostream>

usingnamespacestd;

longfun(intn)

{

if(n>2)

return(fun(n-1)+fun(n-2));

else

return2;

}

intmain()

{cout<<fun(3)<<endl;

return0;}

则该程序的输出结果应该是（）。

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

答案:4有如下函数定义：voidfunc（inta，int&b）a++；b++；

若执行代码段：intx=0；y=1；func（x，y）；

则变量x和y的值分别是（）。

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

答案:0和2以下哪个声明和定义是正确的？（）

A:声明：voidprint{std::cout<<"Hello!";}定义：voidprint();B:声明：voidprint();定义：voidprint(){std::cout<<"Hello!";}C:声明：voidprint(){std::cout<<"Hello!";}定义：print();D:声明：print();定义：voidprint(){std::cout<<"Hello!";}

答案:声明：voidprint();定义：voidprint(){std::cout<<"Hello!";}已知递归函数fun的定义如下：

intfun(intn)

{

if(n<=1)return1;//递归结束情况

elsereturnn*fun(n-2);//递归

}

则函数调用语句fun(5)的返回值是（）。

A:30B:12C:15D:5

答案:15计算斐波那契数列第n项的函数定义如下：

intfib(intn){

if(n==0)return1;

elseif(n==1)return2;

elsereturnfib(n-1)+fib(n-2);

}若执行函数调用表达式fib（2）、函数fib被调用的次数是（）。

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

答案:3以下程序的输出结果是()

voidfun(inta,intb,intc)

{c=a*b;

}

intmain(){

inta;

fun(2,3,a)

cout<<a<<endl;

}（）

A:无定值B:6C:出错D:0

答案:无定值

第九章单元测试

下列关于类定义的说法中，正确的是（）。

A:类成员的缺省访问权限是保护的B:成员函数只能在类体外进行定义C:类定义中包括数据成员和函数成员的声明D:数据成员必须被声明为私有的

答案:类定义中包括数据成员和函数成员的声明下列关于类和对象的叙述中，错误的是（）。

A:一个类只能有一个对象B:类和对象的关系是一种数据类型与变量的关系C:类是对某一类对象的抽象D:对象是类的具体实例

答案:一个类只能有一个对象动态分配的内存在什么时候应该被释放？（）

A:当不再需要使用该内存时B:当程序执行完毕时C:当重新分配内存时D:当显式调用release函数时

答案:当不再需要使用该内存时不是属于面向对象程序设计的特性（）

A:抽象性B:数据相关性C:继承性D:多态性

答案:数据相关性在C++中，私有成员和受保护成员的访问权限是？（）

A:可以在类的外部和派生类中访问。B:只能在类内部访问。C:只能在派生类中访问。D:可以在类的外部访问。

答案:只能在类内部访问。下面关于构造函数和析构函数的描述中，错误的是（）。

A:析构函数可以声明为虚函数B:一个类的虚函数仅对派生类中重定义的函数起作用，对其他函数没有影响C:构造函数可以声明为虚函数D:对虚析构函数的调用可以采用动态联编

答案:构造函数可以声明为虚函数38.在C++中，对象指针可以作为函数的参数传递吗？（）

A:不可以，对象指针只能用于成员函数B:可以，但必须通过值传递C:不可以，对象指针无法作为函数参数传递D:可以，但必须通过引用传递

答案:可以，但必须通过引用传递对象数组的元素可以是不同的类型吗？（）

A:可以，C++允许将不同类型的对象存储在同一个数组中B:可以，但需要通过特殊的语法来实现C:不可以，数组的元素必须是基本数据类型而不是对象类型D:不可以，对象数组的元素必须是相同类型的对象

答案:不可以，对象数组的元素必须是相同类型的对象

第十章单元测试

下面叙述错误的是（）。

A:基类的private成员在public派生类中不可访问B:对基类成员的访问能力在private派生类中和public派生类中是不同的C:基类中的public成员在protected派生类中仍然是public的D:基类中的public成员在protected派生类中是protected的

答案:基类中的public成员在protected派生类中仍然是public的建立一个有成员对象的派生类对象时，各构造函数体的执行次序为（）。

A:派生类、成员对象类、基类B:基类、成员对象类、派生类C:基类、派生类、成员对象类D:成员对象类、基类、派生类

答案:基类、成员对象类、派生类下列描述中，错误的是（）

A:保护继承时基类中的公有成员在派生类中仍是公有成员B:公有继承时基类中的保护成员在派生类中仍是保护成员C:公有继承时基类中的公有成员在派生类中仍是公有成员D:保护继承时基类中的保护成员在派生类中仍是保护成员

答案:保护继承时基类中的公有成员在派生类中仍是公有成员下列有关抽象类和纯虚函数的叙述中，错误的是（）。

A:抽象类的派生类若不实现纯虚函数，它也是抽象类B:拥有纯虚函数的类是抽象类，不能用来定义对象C:纯虚函数的声明以“=0；”结束D:纯虚函数都不能有函数体

答案:纯虚函数都不能有函数体如下程序的输出结果为（）。

#include<iostream>

usingnamespacestd;

classTest{

public:

Test(){n+=2}

~Test(){n-=3;}

staticintgetNum(){returnn;}

private:

staticintn;

};

intTest::n=1;

intmain()

{Test*p=newTest;

deletep;

cout<<"n="<<Test::getNum()<<endl;

return0;

}

A:n=1B:n=0C:n=2D:n=3

答案:n=0派生类继承基类的哪些成员？（）

A:公有成员和保护成员B:私有成员和保护成员C:私有成员和公有成员D:所有成员

答案:公有成员和保护成员关于虚函数，以下说法正确的是（）。

A:虚函数不能是static的B:若在重定义虚函数时使用了virtual，则该重定义函数还是虚函数C:虚函数不能声明为友元D:子类必须重定义父类的虚函数

答案:虚函数不能是static的下列关于纯虚函数与抽象类的描述中，错误的是（）。

A:抽象类是指具有纯虚函数的类B:纯虚函数是一种特殊的虚函数，它没有具体的实现C:一个基类中说明具有纯虚函数，该基类的派生类一定不再是抽象类D:抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

答案:一个基类中说明具有纯虚函数，该基类的派生类一定不再是抽象类为什么需要虚析构函数？（）

A:虚析构函数可以在派生类对象被销毁时正确释放派生类的内存B:虚析构函数可以在派生类对象被销毁时正确调用派生类的析构函数C:虚析构函数可以在派生类对象被销毁时正确调用派生类和基类的析构函数D:虚析构函数可以在派生类对象被销毁时正确释放派生类和基类的内存

答案:虚析构函数可以在派生类对象被销毁时正确调用派生类和基类的析构函数

第十一章单元测试

在语句cin>>data；中，cin是（）。

A:函数名B:对象名C:C++的关键字D:类名

答案:对象名下列有关C++流的叙述中，错误的是（）。

A:进行输入操作时，eof()函数用于检测是否到达文件尾B:C++操作符setw设置的输出宽度永久有效C:处理文件I/O时，要包含头文件fstreamD:C++操作符endl可以实现输出的回车换行

答案:C++操作符setw设置的输出宽度永久有效如果利用C++流进行输入输出，下面的叙述中正确的是（）。

A:只能借助于流对象进行输入输出B:只能借助于cin和cout进行输入输出C:只能使用运算符>>和<<进行输入输出D:只能进行格式化输入输出

答案:只能借助于流对象进行输入输出如果利用C++流进行输入输出，下面的叙述中正确的是（）

A:只能进行格式化输入输出B:只能借助于cin和cout进行输入输出C:只能使用运算符>>和<<进行输入输D:只能借助于流对象进行输入输出

答案:只能借助于流对象进行输入输出有如下程序：

#include<iostream>

usingnamespacestd;

intmain()

{

cout.fll(*);

cout.width(6);

cout.flI(#);

cout<<123<<endl;

return0;

}

执行这个程序的输出结果是（）。

A:123*OK**B:123*OKC:*123OKD:123**OK

答案:123*OK下列关于输入输出流的叙述中，正确的是（）。

A:宽度设置的效果永久有效B:cin是专门从键盘输入数据的输入流类C:流运算符<<用来从输入流中读取数据D:一个文件流可以与一个数据文件相联系

答案:一个文件流可以与一个数据文件相联系在C++中既可以用于文件输入又可以用于文件输出的流类是（）。

A:ifstreamB:iostreamC:ofstreamD:fstream

答案:fstream下列关于文件流的描述中，正确的是（）。

A:建立一个文件流对象时，必须同时打开一个文件B:文件流只能完成针对磁盘文件