面向对象程序设计智慧树知到课后章节答案2023年下青岛理工大学

面向对象程序设计智慧树知到课后章节答案2023年下青岛理工大学青岛理工大学

第一章测试

程序应该必须包含的部分是（

）

A:注释B:高级语言C:数据结构和算法D:头文件

答案:数据结构和算法

C++对C语言作了许多改进，下列描述中（

）使C++语言成为面向对象的语言。

A:允许函数重载，并允许函数有默认参数B:引进了类和对象的概念C:增加了一些新的运算符D:规定函数说明必须用原型

答案:引进了类和对象的概念

对象之间的相互作用和通信是通过消息。下列哪项不是消息的组成部分（

）

A:接受消息的对象B:函数需要的参数C:要执行的函数的内部结构D:要执行的函数的名字

答案:要执行的函数的内部结构

最初的计算机编程语言是（

）

A:机器语言B:汇编语言C:低级语言D:高级语言

答案:机器语言

下列各种高级语言中，（

）不是面向对象的程序设计语言。

A:PASCALB:JavaC:C++D:Delphi

答案:PASCAL

结构化程序设计的基本结构不包含以下哪项（

）

A:跳转B:顺序C:循环D:选择

答案:跳转

C++比机器语言可读性强，但运行效率比机器语言程序低。

A:对B:错

答案:对

C++具有（

）特点。

A:支持数据封装和数据隐藏B:支持继承和重用C:支持多态性D:支持泛型编程

答案:支持数据封装和数据隐藏;支持继承和重用;支持多态性;支持泛型编程

（

）不是属于面向对象程序设计的特性。

A:继承性B:封装性C:多态性D:数据相关性

答案:数据相关性

编写C++程序一般需要经过的几个步骤依次是（

）

A:编译调试

编辑

连接B:编辑

编译

连接运行C:编译编辑连接运行D:编辑调试编译

连接

答案:编辑

编译

连接运行

第二章测试

对于动态分配内存空间描述正确的是（

）。

A:使用new运算符分配的内存空间的长度必须是常量B:delete运算符只能释放由

new分配的动态存储空间C:delete运算符可以释放动态的存储空间和静态的存储空间D:用malloc分配空间，将触发构造函数的调用

答案:delete运算符只能释放由

new分配的动态存储空间

下面的程序执行后的输出结果是（

）。

#include<iostream>usingnamespacestd;intmain(){intk=1,t=0;switch(k){

case1:t+=10;

case2:t+=20;break;

default:t+=3;}cout<<t;return0;}

A:23B:20C:10D:30

答案:30

string是STL库中封装的一个类。

A:对B:错

答案:对

设x和y均为int型变量,则执行以下的循环后,y值为（

)。for(y=1,x=1;y<=50;y++){if(x==10)

break;

if(x%2==1)

{

x+=5;

continue;}

x-=3;}

A:5B:6C:4

D:7

答案:6

以下程序代码的执行结果是（

）。intmain()

{

inti;

for(i='A';i<'I';i++,i++)

cout<<i+32;

cout<<"";

return0;

}

A:acegiB:acegC:编译不通过，无输出D:abcdefgh

答案:aceg

以下程序执行后的输出结果是（

）。intmain(){inti,s=0;

for(i=1;i<10;i+=2)s+=i+1;

cout<<s;

return0;}

A:自然数1～10的累加和

B:自然数1～9的累加和C:自然数1～10中的偶数之和D:自然数1～9中的奇数之和

答案:自然数1～10中的偶数之和

在C++语言中，下列属于构造类型的是(

)。

A:字符型B:实型C:数组类型D:整型

答案:数组类型

设d为字符变量，下列表达式不正确的是（

）

。

A:d=’g’B:d=97C:d=’a’D:d=”a”

答案:d=”a”

设有intx=11，则表达式(x++*1/3)的值是（

）。

A:0B:3C:4D:11

答案:3

#include"iostream"

usingnamespacestd;

intmain()

{inty=3,x=3,z=1;

cout<<(++x,y++)<<””<<z+2;

return0;}

A:33B:42C:34D:43

答案:33

第三章测试

对C++语言函数的有关描述中，正确的是（

）。

A:函数必须有返回值，否则不能使用函数B:C语言程序中有调用关系的所有函数必须放在一个源文件中C:C语言函数既可以嵌套定义又可以嵌套调用D:在调用函数时，只能把实参的值传递给形参，形参的值不能传递给实参

答案:在调用函数时，只能把实参的值传递给形参，形参的值不能传递给实参

若有以下函数调用语句：fun(a+b,(x,y),fun(n+k,d,(a,b)));在此函数调用语句中实参的个数是（

）个：

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

答案:3;

在传值调用中，要求（

）。

A:形参和实参对应的类型一致，个数任意。B:形参和实参对应的类型一致，个数相等;C:形参和实参类型任意，个数相等;D:形参和实参类型都完全一致，个数相等;

答案:形参和实参对应的类型一致，个数相等;

在C++程序中,有关函数的叙述正确的有（

）。

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

答案:函数的定义不可以嵌套,但函数的调用可以嵌套

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

）。

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

答案:数组的首地址

以下程序的运行结果是（

）。

#include"iostream"

usingnamespacestd;

intfunc(inta,intb)

{return(a+b);}

intmain()

{intx=2,y=5,z=7,r;

r=func(func(x,y),z);

cout<<r;

return0;

}

A:12B:13C:14D:15

答案:14

有以下程序

#include

"iostream"

usingnamespacestd;

voidpoint(char*p){p+=3;}

intmain()

{charb[4]={'a','b','c','d'},*p=b;

point(p);

cout<<*p<<endl;

return0;

}

程序运行后的输出结果是（

）。

A:bB:cC:dD:a

答案:a

设有定义：intn1=0,n2,*p=&n2,*q=&n1;，以下赋值语句中与n2=n1;语句等价的是（

）。

A:*p=&n1;B:p=*q;C:*p=*q;D:p=q;

答案:*p=*q;

有以下程序

#include

<iostream>

usingnamespacestd;

intmain()

{inta=7,b=8,*p,*q,*r;

p=&a;q=&b;

r=p;p=q;q=r;

cout<<*p<<”,”<<*q<<endl;

return0;

}

程序运行后的输出结果是（）。

A:8,8B:8,7C:7,8D:7,7

答案:8,7

以下语句或语句组中,能正确进行字符串赋值的是（

）。

A:char*sp='right!';B:chars[10];*s='right!';C:char*sp;*sp='right!';D:chars[10];s='right!';

答案:char*sp='right!';

以下程序段中，不能正确赋字符串（编译时系统会提示错误）的是（

）。

A:chart[]='abcdefg',*s=t;B:chars[10];s='abcdefg';C:chars[10]='abcdefg';D:chars[10];strcpy(s,'abcdefg');

答案:chars[10];s='abcdefg';

设有定义语句

intx[6]={2,4,6,8,5,7},*p=x,i;

要求依次输出x数组6个元素中的值，不能完成此操作的语句是（

）。

A:for(i=0;i<6;i++)

cout<<(*p)++;B:for(i=0;i<6;i++)

cout<<*(p++);C:for(i=0;i<6;i++)

cout<<*(p+i);D:for(i=0;i<6;i++)

cout<<*p++;

答案:for(i=0;i<6;i++)

cout<<(*p)++;

以下程序段执行后，变量b的值是（

）。

inta[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;

b=p[5];

A:5B:9C:8D:6

答案:9

有以下程序：

#include

<iostream>

usingnamespacestd;

voidsum(int*a)

{a[0]=a[1];}

intmain()

{

intaa[10]={1,2,3,4,5,6,7,8,9,10},i;

for(i=2;i>=0;i--)sum(&aa[i]);

cout<<aa[0];

return0;

}

执行后的输出结果是（

）。

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

答案:4

不同命名空间中的标识符可以同名而不会发生冲突。

A:对B:错

答案:对

第四章测试

所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是（

）。

A:对象B:数据块C:函数体D:类

答案:类

一个函数功能不太复杂，但要求被频繁调用，则应把它定义为（）。

A:内联函数B:嵌套函数C:重载函数D:递归函数

答案:内联函数

适宜采用inline定义函数情况是（）。

A:函数体含有递归语句B:函数体含有循环语句C:函数代码多、不常调用D:函数代码少、频繁调用

答案:函数代码少、频繁调用

类MyA的拷贝构造函数的原型是（

）

A:MyA()

B:MyA(MyA*)C:MyA(MyA&)D:MyA(MyA)

答案:MyA(MyA&)

在类中说明的成员可以使用关键字的是（

）。

A:externB:publicC:cpuD:register

答案:public

下列不能作为类的成员的是（

）。

A:自身类对象的引用B:自身类对象C:另一个类的对象D:自身类对象的指针

答案:自身类对象

假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（）。

A:（*x）.a()B:x->aC:x.aD:x.a()

答案:x.a()

静态成员函数没有（）。

A:this指针B:指针参数C:返回值D:返回类型

答案:this指针

下面程序输出结果是（

）。#include<iostream>

usingnamespacestd;

classexample{

inta;

public:

example(intb=5){

a=b++;

}

voidprint(){

a=a+1;

cout<<a<<"";

}

voidprint()const{

cout<<a<<endl;

}

};

voidmain(){

examplex;

constexampley(2);

x.print();

y.print();

}

A:

61B:

51C:

52D:

62

答案:

62

一个类可包含析构函数的个数是（

）。

A:

0个B:

1个C:

0个或多个D:

至少1个

答案:

1个

下列关于析构函数描述正确的是(

)。

A:可以重载B:返回类型必须是void类型C:不能指定返回类型D:函数体中必须有delete语句

答案:不能指定返回类型

拷贝构造函数创建对象时，使用已经存在的同类对象来进行初始化，由编译器自动调用。

A:错B:对

答案:对

this指针存在于类的成员函数中,指向被调用函数所在的类实例的地址。

A:对B:错

答案:对

如果一个对象被声明为常对象，则不能调用该对象的非const型的成员函数（除了由系统自动调用的隐式构造函数和析构函数）。

A:错B:对

答案:对

拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。

A:错B:对

答案:对

第五章测试

如果从原有类定义新类可以实现的是（）。

A:继承机制B:数据抽象C:信息隐藏D:数据封装

答案:继承机制

下面叙述不正确的是（）。

A:基类的公有成员在派生类中仍然是公有的B:派生类一般都用公有派生C:赋值兼容规则也适用于多重继承的组合D:对基类成员的访问必须是无二义性的

答案:基类的公有成员在派生类中仍然是公有的

在公有派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（）。

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

答案:私有成员

在私有继承的情况下，基类的公有成员在派生类对象中的访问权限（

）。

A:保持不变B:受限制C:受保护D:不受保护

答案:受限制

对基类和派生类的关系描述中，错误的是（）。

A:派生类是基类的特殊化B:派生类是基类定义的延续C:派生类是基类的具体化D:基类继承了派生类的属性

答案:基类继承了派生类的属性

关于this指针使用说法正确的是（）。

A:保证每个对象拥有自己的数据成员，但共享处理这些数据的代码B:保证基类保护成员在子类中可以被访问。C:保证基类公有成员在子类中可以被访问。D:保证基类私有成员在子类中可以被访问。

答案:保证每个对象拥有自己的数据成员，但共享处理这些数据的代码

假设ClassY:publicX，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为（）。

A:Y,X；Y,XB:X,Y；X,YC:X,Y；Y,XD:Y,X；X,Y

答案:X,Y；Y,X

以下基类中的成员函数表示纯虚函数的是（）。

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

答案:virtualvoidtt()=0

关于类的静态成员函数描述错误的是(

)。

A:不能直接访问非静态函数B:在创建对象前不存在C:不能说明为虚函数D:不是对象的成员

答案:在创建对象前不存在

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

A:错B:对

答案:对

第六章测试

重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。（

）

A:对B:错

答案:对

重载之后的运算符可以改变运算符的优先级和结合性，也能改变运算符操作数的个数及语法结构。（

）

A:对B:错

答案:错

运算符重载为类的成员函数和重载为友元函数不同的是，重载为成员函数时声明和定义中省略了第一个参数，因为成员函数总是与对象捆绑使用的，被捆绑的对象就是被操作的第一参数。（

）

A:错B:对

答案:对

双目运算符重载为友元函数时有两个参数即运算符的两个操作数，而重载为成员函数时只有一个参数，即运算符的第二个操作数（

）。

A:对B:错

答案:对

operator运算符就是运算符重载函数的函数名,比如：operator+就是函数名。（

）

A:对B:错

答案:对

基类中定义的虚函数为整个类族提供了一个通用的框架，说明了一般类所应该具有的行为，派生类根据自己的情况给出自己的定义，即对基类中定义的虚函数进行重定义。（

）

A:对B:错

答案:对

C++中的虚函数的作用主要是实现了多态机制，即父类类别的指针（或者引用）指向其子类的实例，然后通过父类的指针（或者引用）调用实际子类的成员函数。多态机制可以简单地概括为“一个接口，多种方法”。（

）

A:错B:对

答案:对

当编译器在编译程序的过程中看到某个类中有虚函数的标志时，就会为这个类的实际对象创建一个指针即虚函数表指针vtbl，以指向类中的虚函数表。虚函数表里包含了所有的虚函数代码的地址，以NULL结束。虚函数如果在派生类被重写，就由派生类重写的虚函数地址来代替。（

）

A:错B:对

答案:对

有虚函数的类，其对象的空间比没有虚函数的类多了一个指针的空间，这个指针就是指向虚函数表的指针。（

）

A:对B:错

答案:对

构造函数可以定义为虚函数，析构函数不可以定义为虚函数。（

）

A:错B:对

答案:错

析构函数的作用是在对象撤销之前做必要的“清理现场”的工作。（

）

A:错B:对

答案:对

当派生类的对象从内存中撤销时一般先调用派生类的析构函数，然后再调用基类的析构函数。（

）

A:错B:对

答案:对

当一个类有子类时，该类的析构函数必须是虚函数，否则子类的析构函数不会被调用，使得子类对象被撤销之前动态申请的资源没有被释放，造成内存泄漏。（

）

A:错B:对

答案:对

下列属于动态多态的是（

）。

A:虚函数B:构造函数重载C:函数重载D:运算符重载

答案:虚函数

下面的说法错误的是（

）。

A:C++支持两种多态性，静态联编所支持的多态性被称为静态多态性，动态联编所支持的多态性被称为动态多态性。B:函数重载在编译时表现出的多态性是静态多态性，而虚函数则在运行时表现出的多态性是动态多态性。C:函数模板和类模板的实例化的过程是通过动态联编实现的。D:C++的两种联编方式为：静态联编和动态联编。

答案:函数模板和类模板的实例化的过程是通过动态联编实现的。

第七章测试

关于函数模板，描述错误的是（

）。

A:函数模板不是函数，它需要以具体的类型为实参才能生成函数B:函数模板的实例化由编译器实现C:用关键字template引出对类型参数名的声明D:函数模板必须由程序员实例化为可执行的模板函数

答案:函数模板必须由程序员实例化为可执行的模板函数

假设有函数模板定义如下：

template

intMin(T*a,intsize)

{

Ttemp=a[0];

intj=0;

for(inti=1;iif(a[i]temp=a[i];

j=i;

}

returnj+1;

}

假设ArrayX已定义为float型的数组，则求该数组前10个元素中最小元素的位置的语句为（）。

A:Min(ArrayX);B:Min(ArrayX,size);C:Min(ArrayX,int);D:Min(ArrayX,10);

答案:Min(ArrayX,10);

假设有模板定义如下：

template

TMin(Tm1,Tm2){

return(m1}

下面哪个模板的不是上面模板的重载？（）

A:template

floatMin(Tm1,Tm2){

return(m1}B:template

TMin(Tm1,Tm2,Tm3){

Ttemp=Min(m1,m2);

returnMin(temp,m3);

}C:template

T1Min(T1m1,T2m2){

return(m1}D:template

T1Min(T1a[],T2n){

T1minnum=a[0];

for(inti=0;iif(minnum>a[i])minnum=a[i];

returnminnum;

}

答案:template

floatMin(Tm1,Tm2){

return(m1}

建立类模板对象的实例化过程为（

）。

A:模板类—模板函数B:类模板—模板类—对象C:类模板—对象D:基类—派生类

答案:类模板—模板类—对象

类模板Array的模板参数定义如下：template<typenameT,intn>则下面哪个对象的定义是错误的？（

）

A:Array<double,10>a;B:Array<int,10>a;

C:Arraya;

D:Array<char,10>a(10);

答案:Arraya;

下面定义类模板模板参数的定义语句错误的是（

）。

A:template<classT1,classT2=double,classT3,intN=100>

B:template<classT1,classT2,classT3,intN>C:template<classT1,classT2,classT3=double,intN=100>

D:template<classT1,classT2=double,classT3=float,intN=100>

答案:template<classT1,classT2=double,classT3,intN=100>

以下类模板、模板类、普通类之间的派生方式正确的是（

）

A:从模板类派生出普通类B:从模板类派生出类模板C:从普通类派生出类模板D:从类模板派生出新的类模板

答案:从模板类派生出普通类;从模板类派生出类模板;从普通类派生出类模板;从类模板派生出新的类模板

类模板templateclassX{

}，其中，函数模板f定义为该类模板实例化的每个模板类的友元，则其说明应为（

）。

A:template<classT>

friendvoidX::f(x&)

B:friendvoid

X::f()；C:template<classT>

friendvoidf(X&)；

D:friendvoidf()；

答案:template<classT>

friendvoidf(X&)；

下面vector容器的定义不正确的是（

）

A:vector<int>v(10);

B:vector<double>v;

C:vector<char>v;D:vectorv;

答案:vectorv;

顺序容器(vector,list,deque)中，能通过pop_front()删除最前面的元素的是（

）。

A:vector,dequeB:list,

dequeC:vector,listD:vector,list,deque

答案:vector,deque

函数模板实例化时，没有普通传值参数的类型转换机制。（

）

A:对B:错

答案:对

把通过函数模板按实际类型生成的函数称为模板函数，这个过程称为实例化。编译程序实例化后的模板函数自动生成目标代码。（

）

A:错B:对

答案:对

函数模板中可以有不止一个类型参数，每一个类型参数前面都要加typename或class来说明。（

）

A:对B:错

答案:对

下面是类模板的定义语句template<classT1=char,classT2=double,classT3=float,intN=100>classClassX{

};x,y,z分别是char、double、float类型的变量，则下面定义对象的语句哪一个是错误的？（）

A:ClassX<x,y>obj;

B:ClassX<x,y,z,10>obj;C:ClassXobj;

D:ClassX<>obj;

答案:ClassXobj;

编译器会选择实参经过自动类型转换后能够匹配的模板函数进行匹配。（

）

A:错B:对

答案:错

第八章测试

下面关于C++输入输出的说法正确的是（

）

A:C++通过一种称为流的机制提供了输入和输出方法；B:C++有专门的输入输出命令；C:C++流是指信息向外部设备（如键盘和磁盘）输入输出的过程。D:流是一种灵活且面向对象的I/O方法；

答案:C++通过一种称为流的机制提供了输入和输出方法；;流是一种灵活且面向对象的I/O方法；

cout是（

）的一个对象，处理标准输出。

A:cerrB:ostreamC:clogD:isteam

答案:ostream

下列程序的输出结果是（

）。#include<iostream>

usingnamespacestd;

intmain(){

inti=1;

cout<<++i<<i++<<i<<i++<<++i<<endl;

return0;

}

A:53525B:22335C:54535D:23345

答案:23345

设己定义浮点型变量data,按data在内存中的表示原样输出到显示器上,正确的语句是（

）。

A:cout.write((double*)&data,sizeof(double));B:cout.write((char*)&data,data);C:cout.write((double*)&data,data);D:cout.write((char*)&data,sizeof(double));

答案:cout.write((char*)&data,sizeof(double));

若定义cin>>str;当输入ObjectWindowsProgramming!，所得的结果是（

）

A:str=ObjectWindowsProgramming!B:str=ObjectWindowsProgrammingC:str=ObjectD:str=ObjectWindows

答案:str=Object