面向对象的C++和Windows编程-武汉理工大学中国大学mooc课后章节答案期末考试题库2023年

面向对象的C++和Windows编程_武汉理工大学中国大学mooc课后章节答案期末考试题库2023年构造函数和析构函数都不能重载。

参考答案:

错误

C++语言中模板分为函数模板和类模板两种。

参考答案:

正确

对于如下的类：classAnimal{floatweight;intfeet;public:Animal(floatw,intf=4){weight=w;feet=f;}};定义其对象完全正确的一组语句是（）。

参考答案:

Animal

a1(3.6,8);Animal

a2(67.9);

下列描述中，（）不是构造函数的特征。

参考答案:

必须显式的为类定义一个构造函数

复数类及对象的定义如下：classComplex{doublereal,image;public:Complex(doubler=0,doublei=0){real=r;image=i;}Complex(Complex&c){real=c.real;image=c.image;}};Complexc1;//AComplexc2(3,5);//BComplexc3(c2);//Cc2=c1;//D下述说法中正确的是（）。

参考答案:

C行调用了复制构造函数

在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为（）指针。

参考答案:

this

复制构造函数的作用是（）。

参考答案:

用对象初始化对象

已知AA是一个类，则执行语句AAa;后（）。

参考答案:

自动调用无参构造函数

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

参考答案:

1个

假定AB为一个类，则执行“ABx;”语句时将自动调用该类的（）。

参考答案:

无参构造函数

假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为（）。

参考答案:

AB(intaa=0){a=aa;}

下面的哪一个构造函数头格式不正确（）。

参考答案:

AA(inta＝0,intb)

友元关系不能（）。

参考答案:

继承

静态成员函数没有（）。

参考答案:

this指针

若类X是类Y的友元类，则下列访问关系中（）是正确的。

参考答案:

类X的成员可以访问类Y的私有成员

关于静态成员的描述中，（）是错误的。

参考答案:

静态数据成员定义后必须在类体内进行初始化

友元函数访问对象中的成员可以不通过对象名。

参考答案:

错误

下面类的定义，有（）处错误。classMyClass{private:inti=0;public:voidMyClass();~MyClass(intValue);};

参考答案:

3

如果程序中未声明构造函数，则系统自动产生出一个默认形式的构造函数。

参考答案:

正确

使用函数模板可以实现代码的重用。

参考答案:

正确

模板分为函数模板、重载模板和类模板。

参考答案:

错误

已定义如下函数模板：templateTmax(Tx,Ty){......}则编译模板函数调用语句：cout<<max(3.5f,6.2f);将自动生成下列哪个函数定义代码？（）

参考答案:

floatmax(floatx,floaty)

{

......

}

关于友元，下列说法正确的是（）。

参考答案:

A类为B类的友元类，则A类中的所有函数就可以访问B类中的所有成员

下面对静态数据成员的描述中，正确的是（）。

参考答案:

静态数据成员是类的所有对象共享的数据

有如下程序：#includeclassToy{public:Toy(char*_n){strcpy(name,_n);count++;}~Toy(){count--;}char*GetName(){returnname;}staticintgetCount(){returncount;}private:charname[10];staticintcount;};intToy::count=0;intmain(){Toyt1("Snoopy"),t2("Mickey"),t3("Barbie");cout<

参考答案:

3

当将一个类S定义为另一个类A的友元类时，类S的所有成员函数都可以访问类A的所有成员。

参考答案:

正确

友元函数是在类声明中由关键字friend修饰说明的类的成员函数。

参考答案:

错误

类模板的实例化（）。

参考答案:

在编译时进行

包含一个消息的全部信息，是消息发送的格式的数据结构是（）。

参考答案:

MSG

有如下函数模板templateTsquare(Tx){returnx*x;}其中T是()

参考答案:

模板形参

析构函数说明为虚函数是没有意义的。

参考答案:

错误

静态联编和动态联编都是在编译时进行的，二者的区别仅是前者对非虚函数，后者对虚函数。

参考答案:

错误

要实现动态联编必须()。

参考答案:

通过对象指针或引用来调用虚函数

在派生类中重新定义虚函数时，必须在下列哪方面与基类保持一致？（）

参考答案:

参数类型

关于虚函数的描述中，（）是正确的。

参考答案:

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

在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值（）。

参考答案:

相同

下列关于析构函数的描述中，错误的是（）。

参考答案:

析构函数的函数体都为空

下列关于对象数组的描述中，（）是错误的。

参考答案:

对象数组只能赋初值，而不能被赋值

使用（）获取的设备上下文，在退出时必须调用ReleaseDC()释放设备上下文。

参考答案:

GetDC()

下列函数模板的定义中，合法的是（）。

参考答案:

templateTabs(Tx){returnx<0?-x:x;}

有如下类声明：classTestClass{inti;private:intj;protected:intk;public:intm,n;};其中，私有成员的数量为()。

参考答案:

2

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

参考答案:

私有成员

下列关于面向对象概念的描述中，错误的是（）。

参考答案:

面向对象方法替代了结构化程序设计方法

下列关于基类和派生类的描述中，错误的是（）。

参考答案:

基类中成员访问权限继承到派生类中不变

运算符重载函数的形参不允许有默认值。因为形参对应参加运算的的实际的运算量，运算时运算量是不能缺省的。

参考答案:

正确

重载运算符的实质是函数调用,如果重载了后置单目运算符“++”,执行C++,则相当于执行了哪个函数()。

参考答案:

operator++(c,0)

Complex::operatordouble(){returnReal;}上述代码的功能是（）。

参考答案:

将Complex类转换成double类

下列运算符中，不可以重载的是（）。

参考答案:

?:

基类中的protected成员，通过public派生，其在派生类中的可见性为（）。

参考答案:

protected

下列选项，与定时器有关的是（）。

参考答案:

以上全部

下列关于成员访问权限的描述中，不正确的是（）。

参考答案:

类的私有数据成员只能被公有成员函数以及该类的任何友元类或友元函数访问

在公有和保护继承方式下，派生类的对象可以对基类的保护成员进行访问。

参考答案:

错误

在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。

参考答案:

错误

有如下模板定义：templateTfun(Tx,Ty){returnx*x+y*y；}在下列对fun的调用中，错误的是（）。

参考答案:

fun(2.3,8)

下列对于WinMain函数的描述中，错误的是（）。

参考答案:

WinMain函数不能有参数

以下哪个类用于文件的打开（）。

参考答案:

CFileDialog

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

参考答案:

正确

动态联编指的是在运行期间来选择不同类的虚函数。

参考答案:

正确

抽象类可以定义对象，不可以定义对象指针和对象引用。

参考答案:

错误

下列有关继承和派生的叙述中，正确的是（）。

参考答案:

派生类应当向基类的构造函数传递参数

有关运算符重载正确的是（）。

参考答案:

C++语言允许在重载运算符时改变运算符的原来的功能

不能重载的运算符是（）。

参考答案:

“？:”运算符

凡是能用以派生新类，却不能创建自己的对象的类称为（）。

参考答案:

抽象类

下列描述中，（）是抽象类的特征。

参考答案:

不能说明其对象

若一个类中含有纯虚函数，则该类称为（）。

参考答案:

抽象类

编译时的多态性通常使用（）获得。

参考答案:

重载函数

多重继承是（）。

参考答案:

派生类有多个直接基类

关于常成员的描述中，错误的是（）。

参考答案:

常数据成员必须是公有的

可以被对象之外访问的成员是（）。

参考答案:

公有成员函数

下列程序的执行结果是（）。#include#includeclassABC{char*str;intmax_len;public:ABC(inti,char*s);~ABC();};ABC::ABC(inti,char*s){max_len=i+1;str=newchar[max_len];strcpy(str,s);}ABC::~ABC(){cout<

参考答案:

Mainend.Hello,C++!

当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时，它最多能够存储（）个整数。

参考答案:

n

单继承情况下（一级继承）,派生类中对基类成员的访问也会出现二义性。

参考答案:

错误

多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生类构造函数中所定义的成员初始化列表的各项顺序无关。

参考答案:

正确

下列关于赋值兼容规则的描述中,()是错误的。

参考答案:

公有继承下,派生类对象不可给基类对象赋值

能被派生类继承的函数是()。

参考答案:

静态成员函数

MFC类库中的类按层次关系可知，CEdit的直接父类为（）。

参考答案:

CWnd

对类中引用成员的初始化是通过构造函数中给出的（）实现的。

参考答案:

初始化表

假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为()。

参考答案:

ABoperator+(AB&)

解决多继承情况下出现的二义性的方法之一是使用作用域运算符。

参考答案:

正确

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

参考答案:

X,Y；Y,X

有如下程序，执行后的输出结果应该是（）。#includeclassBASE{public:~BASE(){cout<<"BASE";}};classDERIVED:publicBASE{public:~DERIVED(){cout<<"DERIVED";}};voidmain(){DERIVEDx;}

参考答案:

DERIVEDBASE

下列关于运算符重载的描述中，（）是正确的。

参考答案:

运算符重载不可以改变语法结构

在C++中，一个函数为voidf(int,charch='a')，另一个函数voidf(int)，则它们（）。

参考答案:

可以在同一程序中定义并可重载

声明为指向基类对象的指针，当其指向派生类对象时，可以利用它来直接访问公有派生类的成员。

参考答案:

错误

对于下列程序段，没有二义性的表达式是（）。classA{public:intf();};classB{public:intg();intf();};classC:publicA,publicB{public:intg();h();};Cobj;

参考答案:

obj.B::f()

定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。

参考答案:

错误

使用new运算符创建数组时，可以为该数组指定初始值。

参考答案:

错误

在私有继承中，基类中所有成员对派生类都是不可见的。

参考答案:

错误

基类中被说明为protected和private的成员只能被其派生类的成员函数访问，不能被其它的函数访问。

参考答案:

错误

定义指向常对象的指针后，指针所指向的对象是可以改变的。

参考答案:

错误

若对象有动态分配的存储空间，就必须定义复制构造函数。

参考答案:

正确

类的公有成员函数是类与外界的接口。

参考答案:

正确

在用class定义一个类时,数椐成员和成员函数默认的访问权限是public。

参考答案:

错误

在派生关系中，（）。

参考答案:

构造函数和释放函数是不能继承的

在公有继承中，基类中的保护成员对派生类对象是可见的。

参考答案:

错误

派生类中继承的基类成员的访问权限到派生类保持不变。

参考答案:

错误

派生类至少有一个基类。

参考答案:

正确

单重继承是指派生类只有一个基类的情况。

参考答案:

正确

设有如下程序：#includeclassA{public:inti;display(){cout<<”classA\n”;}};classB{public:inti;display(){cout<<”classB\n”;}};classC:public:A,publicB{intj;public:inti;show(){j=i*i;display();}};voidmain(){Cdemo;demo.show();}主程序运行时将()。

参考答案:

因类定义的语法错而不能运行

下面关于继承的描述中错误的是（）。

参考答案:

派生类中继承的基类成员的访问权限到派生类保持不变

下面叙述正确的是()。

参考答案:

派生类可以有自己的构造函数

派生类由public方式继承基类成员，则（）。

参考答案:

基类中的公有成员可以被派生类的成员函数访问。

在保护继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（）。

参考答案:

受保护

建造新的派生类是（）的实质。

参考答案:

继承

使用delete[]删除对象数组时，描述正确的是（）。

参考答案:

数组中各元素都调用析构函数

若需要使类中的一个指针成员指向一块动态存储空间，则通常在（）函数中完成。

参考答案:

构造

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

参考答案:

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

下列关于类和对象的叙述中，错误的是（）。

参考答案:

一个类只能有一个对象

如果用户未显式定义赋值运算符重载函数，编译器会自动生成一个，完成数据成员的简单赋值。

参考答案:

正确

可以利用运算符重载实现用运算符直接对字符串对象进行加、减等操作。

参考答案:

正确

下面有关重载的说法中，错误的是()。

参考答案:

所有的运算符都可以重载

下面是重载双目运算符+的友元函数原型，其中最符合+原来含义的是（）。

参考答案:

Valueoperator+(Value,Value);

设置虚基类的目的是（）。

参考答案:

消除二义性

动态联编所支持的多态性称为（）。

参考答案:

运行时的多态性

下列是重载乘法运算符的函数原型声明，其中错误的是（）。

参考答案:

MyClassoperator*(double,double);

UI指的是（）。

参考答案:

用户接口

在Windows操作系统中预定义了几种光标，IDC-ARROW表示（）。

参考答案:

箭头光标

视图类OnDraw()成员函数的作用（）。

参考答案:

刷新视图界面

下面对友元的错误描述是（）。

参考答案:

友元函数通过this指针访问对象成员

带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类构造函数，这样将对虚基类的子对象初始化（）。

参考答案:

一次

（）只能访问静态成员变量。

参考答案:

静态成员函数

对于+=（或=）运算符，重载函数的返回值为void类型或本类类型对象的区别是（）。

参考答案:

本类类型，则本类对象可以连续赋值.

友元类的声明可以放在类定义中的任何地方。

参考答案:

正确

C＋＋允许使用友元，但是友元会破坏封装性。

参考答案:

正确

下列关于运算符new的描述中，错误的是（）。

参考答案:

用它创建的对象可以不用delete运算符释放

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

参考答案:

delete运算符只能释放由new分配的动态存储空间

假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete[]px;”语句时共调用该类析构函数的次数为（）。

参考答案:

n

下面程序的输出结果是（）。#includeclassexample{inta;public:example(intb){a=b++;}voidprint(){a=a+1;cout<

参考答案:

42

有如下程序：执行后的输出结果应该是（）。#includeclasscla{staticintn;public:cla(){n++;}~cla(){n--;}staticintget_n(){returnn;}};intcla::n=0;intmain(){cla*p=newcla;deletep;cout<<"n="<

参考答案:

n=0

有如下程序：#include#includeclassXCF{inta;public:XCF(intaa=0):a(aa){cout<<"1";}XCF(XCF&x){a=x.a;cout<<"2";}~XCF(){cout<Geta();deletepd;}运行时的输出结果是（）。

参考答案:

1218855

对下列语句正确的描述是（）。constint*x；//①int*constx；//②

参考答案:

语句②的含义是指针变量x不能更改

关于new运算符的错误的描述是（）。

参考答案:

使用运算符new创建对象数组时必须定义初始值

有如下程序：#includeusingnamespacestd;classAA{intn;public:AA(intk):n(k){}intget(){returnn;}intget()const{returnn+1;}};intmain(){AAa(5);constAAb(6);cout<

参考答案:

57

有如下程序：#include#includeusingnamespacestd;classMyClass{public:MyClass(){cout<<'A';}MyClass(charc){cout<

参考答案:

AXBB

常对象需要引用常成员函数，而不能引用非常成员函数。

参考答案:

正确

使用new运算符创建的对象数组其元素都具有默认值。

参考答案:

错误

用new动态申请的内存空间，必须用delete来释放。

参考答案:

正确

成员函数定义返回的是对象的引用，最后可以返回函数内部的局部对象。

参考答案:

错误

返回对象的引用时，不能用局部对象做为返回值。

参考答案:

正确

有如下类声明，则类MyDERIVED中保护的数据成员和成员函数的个数是（）。classMyBASE{private:intk;protected:intx;public:voidset(intm,intn){k=m;x=n;}intget()const{returnk;}};classMyDERIVED:protectedMyBASE{protected:intj;public:voidset(intm,intn,intp){MyBASE::set(m,n);j=p;}intget()const{returnMyBASE::get()+j;}};

参考答案:

4

在C++中的类有两种方法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过()，派生出新的类。

参考答案:

继承

从一个基类派生出的各个类的对象之间（）。

参考答案:

不共享任何数据成员，但每个对象还包含基类的所有属性

下列对派生类的描述中错误的说法是（）。

参考答案:

派生类所继承的基类成员的访问权限保持不变

下列关于类的继承描述中，（）是错误的。

参考答案:

派生类可以访问基类的所有数据成员，也能调用基类的所有成员函数

对于多重继承，有（）。

参考答案:

一个派生类可有多个基类

下列描述中，错误的是（）。

参考答案:

基类public成员在protected派生类中仍是public成员

有以下定义的派生类：classA:publicB{...};则下面描述中正确的是（）。

参考答案:

A类中的成员函数可以访问B类中的public数据成员。

C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过（）_派生出新的类。

参考答案:

继承

有如下类声明：classMyBASE{intk;public:voidset(intn){k=n;}intget()const{returnk;}};classMyDERIVED:protectedMyBASE{protected:intj;public:voidset(intm,intn){MyBASE::set(m);j=n;}intget()const{returnMyBASE::get()+j;}};则类MyDERIVED中保护的数据成员和成员函数的个数是（）。

参考答案:

3

多重继承是指一个基类派生出多个派生类的情况。

参考答案:

错误

派生类还可以作基类派生出新的派生类。

参考答案:

正确

派生类中只包含直接基类的成员，不包含间接基类的成员。

参考答案:

错误

在私有继承中，派生类的对象不可直接访问基类中的任何成员。

参考答案:

正确

基类的成员在派生类中都是可以访问的。

参考答案:

错误

下列关于this指针的描述中，错误的是（）。

参考答案:

this指针只能隐含使用，不能显式使用

下列关于派生类的构造函数和析构函数中，错误的是（）。

参考答案:

在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

下列声明“A为虚基类，派生B类”，正确的是（）。

参考答案:

classB:virtual

publicA

下列程序段中具有相同值的是（）。classBase{intb;};classBase1:virtualpublicbase{intb1;};classBase2:virtualpublicbase{intb2;};classderived:publiicbase1,publicbase2{intb3;};derivedd;

参考答案:

d.b与d.base1::b

有如下程序：#includeusingnamespacestd;classC1{public:~C1(){cout<<1;}};classC2:publicC1{public:~C2(){cout<<2;}};intmain(){C2cb2;C1*cb1;return0;}运行时的输出结果是()。

参考答案:

21

下面有关基类和派生类的说法中，错误的是()。

参考答案:

派生类可以有选择性地继承基类中的某些成员，删除不需要的成员

下面叙述不正确的是()。

参考答案:

赋值兼容规则不适用于多重继承的组合

解决定义二义性问题的方法有（）。

参考答案:

使用作用域分辨运算符或虚基类

下面（）的叙述不符合赋值兼容规则。

参考答案:

基类的对象可以赋值给派生类的对象

有如下程序：#includeusingnamespacestd;classA{public:A(){cout<<"A";}};classB{public:B(){cout<<"B";}};classC:publicA{Bb;public:C(){cout<<"C";}};intmain(){Cobj;return0;}执行后的输出结果是（）。

参考答案:

ABC

C++中设置虚基类的目的是实现运行时的多态。

参考答案:

错误

多重继承情况下，派生类中对基类成员的访问不会出现二义性。

参考答案:

错误

多重继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。

参考答案:

正确

多继承情况下，派生类的构造函数的执行顺序取决于成员初始化列表中的顺序。

参考答案:

错误

可以用一个声明指向基类对象的指针指向它的公有派生的对象。

参考答案:

正确

假定VOLUME为一个类,在类体中包含如下函数原型:VOLUMEoperator-(VOLUMEc2)const；关于这个函数的叙述中，错误的是（）。

参考答案:

这个函数所重载的运算符是一个一元运算符

关于运算符重载，下列说法正确的是（）。

参考答案:

重载时，运算符的功能可以改变。

在C++的类中以成员函数方式重载双目运算符时，只能指定（）。

参考答案:

一个参数

实现编译时的多态性要使用（）。

参考答案:

重载函数

下列关于运算符重载的叙述中，正确的是（）。

参考答案:

有的运算符只能作为成员函数重载

关于运算符重载，下列表述中正确的是（）。

参考答案:

编译系统对重载运算符的选择，遵循函数重载的选择原则

所谓多态性是指（）。

参考答案:

不同的对象调用相同名称的函数

下列属于动态多态的是()。

参考答案:

虚函数

::operator++(int){...}，则（）。

参考答案:

int用于区分后置++运算符

已知在一个类体中包含如下函数原型:VOLUMEoperator-(VOLUME)const;，下列关于这个函数的叙述中，错误的是（）。

参考答案:

这个函数所重载的运算符是一个一元运算符

运算符重载后，优先级、结合性和操作数都是不变的。

参考答案:

正确

重载运算符的函数也可以设置默认参数。

参考答案:

错误

运算符重载后，原运算符的优先级和结合特性会改变。

参考答案:

错误

重载运算符保持原运算符的优先级和结合性不变。

参考答案:

正确

运算符的重载可以改变原来的含义，可臆造新的运算符。

参考答案:

错误

若析构函数是虚函数，则delete对析构函数的调用采用（）。

参考答案:

动态联编

以下（）成员函数表示纯虚函数。

参考答案:

virtualvoidfun()=0

下列有关继承和派生的叙述中，正确的是（）。

参考答案:

派生类应当向带参的基类的构造函数传递参数

对于类定义classA{public:virtualvoidfuncl(){}voidfunc2(){}};classB:publicA{public:voidfunc1(){cout<<”classBfunc1”<

参考答案:

B::func1()是虚函数，A::func2()不是虚函数

关于纯虚函数，下列表述正确的是（）。

参考答案:

纯虚函数的声明总是“=0”结束

下面是类Shape的定义：classShape{public:virtualvoidDraw()=0;};下列关于Shape类的描述中，正确的是()。

参考答案:

类Shape是抽象类

下列关于动态联编的描述中，错误的是（）。

参考答案:

函数重载和运算符重载都属于动态联编

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

参考答案:

虚函数不得是静态成员函数。

下面正确的说法是()。

参考答案:

关键字virtual能用来声明虚基类

分析下面的程序，正确的输出结果是（）。#include#includeusingnamespacestd;classbase{public:virtualchar*fun(void)const=0;};char*base::fun(void)const{return"base";}classderived1:virtualpublicbase{public:char*fun(void)const{return"derived1";}};classderived2:virtualpublicbase{public:char*fun(void)const{return"derived2";}};classsubderived:publicderived1,publicderived2{public:char*fun(void)const{char*pch;pch=newchar[strlen(derived1::fun())+strlen(derived2::fun())+1];strcpy(pch,derived1::fun());strcat(pch,derived2::fun());returnpch;}};voidmain(void){base*pb;pb=newderived1;cout<fun()<fun()<fun()<

参考答案:

derived1derived2derived1derived2

抽象类可以用来直接创建对象。

参考答案:

错误

虚函数可以被类的对象调用，也可以被类的对象指针和对象引用调用。

参考答案:

正确

虚函数是实现动态联编的必要条件。

参考答案:

正确

纯虚函数与函数体为空的虚函数等价。

参考答案:

错误

纯虚函数是一种特殊的成员函数,它是一种没有具体实现的虚函数。

参考答案:

正确

实现两个相同类型数加法的函数模板的声明是（）。

参考答案:

Tadd(Tx,Ty)

设有函数模板templateQSum(Qx,Qy){return(x)+(y);}则下列语句中对该函数模板错误的使用是（）。

参考答案:

Sum(“AB”,”CD”);

类模板的模板参数可用做（）。

参考答案:

其他三者皆可

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

参考答案:

模板类->对象

下列关于模板的描述中，错误的是()。

参考答案:

定义类模板时只允许有一个模板参数

对于模板定义关键字class和typename说法不正确的是（）。

参考答案:

程序class和typename都可互相替换

下列有关模板的描述错误的是()。

参考答案:

类模板与模板类是同一个概念。

下列对模板的声明，正确的是（）。

参考答案:

template

下列关于函数模板的描述中，错误的是（）。

参考答案:

函数模板不能提高函数代码的可重用性

类模板可以生成若干个模板类，每个模板类又可定义若干个对象。

参考答案:

正确

函数模板在编译时不生成可执行代码。

参考答案:

正确

函数模板是不说明某些参数的数据类型的函数。

参考答案:

正确

在创建类模板的对象实例时，通过指定参数所代表的实际数据类型，实现将通用类实例化。

参考答案:

正确

类模板的成员函数必须是函数模板。

参考答案:

正确

POPUP语句定义的是（）。

参考答案:

弹出式菜单

按键消息的变量lParam是（）变量。

参考答案:

32位

所有的控件都是（）类的派生类，都可以作为一个特殊的窗口来处理。

参考答案:

CWnd

图标资源的文件扩展名为（）。

参考答案:

ico

下列类中不属于MFC框架基本类的是（）。

参考答案:

CObject

运行MFC程序时，程序执行的顺序是（）。

参考答案:

theApp->CwinApp->CtestApp->Winmain

关于MFC的描述中,有错误的是（）。

参考答案:

命名不区分大小写

下面哪个类，代表视图类（）。

参考答案:

CView

使用BeginPaint()获取的设备上下文，在退出时必须调用()释放设备上下文。

参考答案:

EndPaint()

设有以下类的定义：#includeclassA{protected:inta;public:A(inti=0){a=i;}intGeta(){returna;}};classB:publicA{Aa1;public:_______________________//B类构造函数的定义voidShow(){cout<

参考答案:

B(inti=0,intj=0):A(i),a(j){}

下列哪个不是面向对象的特征（）。

参考答案:

结构性

在类定义的外部，可以被访问的成员有（）。

参考答案:

public的类成员

关于封装，下列说法中不正确的是（）。

参考答案:

通过封装，对象的属性都是不可见的

类的实例化是指（）。

参考答案:

创建类对象

设有以下类和对象的定义:classA{public:intk;};Ax1,x2,*p1,*p2;则下面针对成员变量k的引用，正确的是（）。

参考答案:

x2.k=2;

设有以下类的定义：classEx{intx;public:voidsetx(intt=0);};若在类外定义成员函数setx(),以下定义形式中正确的是（）。

参考答案:

voidEx::setx(intt){…}

C++语言支持封装性和继承性，不支持多态性。

参考答案:

错误

已知：类A中一个成员函数说明如下：voidSet(A&a)；其中A&a的含意是将a的地址给变量Set。

参考答案:

错误

对象引用作为函数参数比用对象指针更方便些。

参考答案:

正确

类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。

参考答案:

错误

一个类中一个无参数构造函数和一个全部都是默认参数的构造函数共存是否存在二义性（）。

参考答案:

存在

假定AB为一个类，则执行“ABx(a,5);”语句时将自动调用该类的（）。

参考答案:

带参构造函数

假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为（）。

参考答案:

n

关于下面程度段说法正确的是().classX{private:intn;punblic:X(X&);}X::X(X&x){n=x.n}Xobj1,obj2;obj2(obj1);

参考答案:

语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2

缺省析构函数的函数体是（）。

参考答案:

空的

有如下程序：#includeusingnamespacestd;className{charname[20];public:Name(){strcpy(name,"");cout<<'?';}Name(char*fname){strcpy(name,fname);cout<<'?';}};intmain(){Namenames[3]={Name("张三"),Name("李四")};return0;}运行此程序输出符号?的个数是（）。

参考答案:

3

类的构造函数被自动调用执行的情况是在定义该类的（）。

参考答案:

对象时

有如下程序：#includeusingnamespacestd;classtest{private:inta;public:test(){cout<<"constructor"<

参考答案:

3destructor

创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。

参考答案:

正确

对象引用可以用一个同类对象的地址值对它赋值。

参考答案:

错误

构造函数和析构函数都是系统自动调用的成员函数。

参考答案:

正确

析构函数可以有形参。

参考答案:

错误

在程序中可以显式调用构造函数。

参考答案:

正确

下列关于静态成员的描述中，错误的是（）。

参考答案:

静态成员只可以用类名加作用域运算符来引用，不可用对象引用

下面对静态数据成员的描述中，正确的是（）。

参考答案:

静态数据成员可以直接用类名调用

一个类的所有对象共享的是（）。

参考答案:

静态数据成员

被非静态成员函数访问的类的数据成员（）。

参考答案:

可以是非静态数据成员或静态数据成员

下列静态数据成员的特性中（）是错误的。

参考答案:

静态数据成员不是所有对象所共用的

若要把函数voidf()定义为类aClass的友元函数，则应该在类aClass定义中加入的语句是（）。

参考答案:

friendvoidf()

下面程序的结果为()。#includeintc;classA{private:inta;staticintb;public:A(){a=0;c=0;}voidseta(){a++;}voidsetb(){b++;}voidsetc(){c++;}voiddisplay(){cout<

参考答案:

122

友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。

参考答案:

正确

在一个类的对象空间里不包含静态成员的空间。

参考答案:

正确

静态数据成员必须在类外初始化。

参考答案:

正确

对使用关键字new所开辟的动态存储空间，释放时必须使用（）。

参考答案:

delete

关于new运算符的下列描述中，（）是错误的。

参考答案:

使用它创建对象数组时必须指定初始值

用new运算符创建一个含10个元素的一维整型数组的正确语句是（）。

参考答案:

int*p=newint[10];

类MyClass的定义如下：classMyClass{public：MyClass(){}MyClass(inti){value=newint(i);}int*value；}；若要对value赋值，则下面语句正确的是（）。

参考答案:

MyClassmy(10)；

对类中常量成员的初始化是通过构造函数中给出的()实现的。

参考答案:

初始化表

已知类MyClass声明如下：classMyClass{intn;public:MyClass(intk):n(k){}intgetValue()const{returnn;}};在下列数组定义中正确的是（）。

参考答案:

MyClass*x[2];

有如下程序：#includeusingnamespacestd;classTest{public:Test(){n+=2;}~Test(){n-=3;}staticintgetNum(){returnn;}private:staticintn;};intTest::n=1;intmain(){Test*p=newTest;deletep;cout<<"n="<

参考答案:

n=0

下面表述中不正确的是（）。

参考答案:

如果#if后的常量表达值为真，则不编译这部分，否则就编译该部分

常对象可以调用任意成员函数。

参考答案:

错误

常对象只能调用常成员函数。

参考答案:

正确

只有常成员函数才可以操作常对象。

参考答案:

正确

this指针存在的目的是（）。

参考答案:

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

应在下列程序划线处填入的正确语句是（）。classBase{public:voidfun(){cout<<"Base::fun"<

参考答案:

Base::fun();

当一个派生类仅私有继承一个基类时，基类中的所有公有成员成为派生类的（）。

参考答案:

private成员

假定类A已经定义，对于以A为基类的单一继承类B，以下定义中正确的是（）。

参考答案:

classB:publicA{//...};

在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（）。

参考答案:

保持不变

假设已经定义好了类student，现在要定义类derived，它是从student私有派生的，则定义类derived的正确写法是（）。

参考答案:

classderived:student{

//………….}

下面关于继承的描述中，错误的是()。

参考答案:

静态成员不可以被继承

设有基类定义：classbase{private:inta;protected:intb;public:intc;};派生类采用何种继承方式可以使成员变量c能被派生类的对象直接访问()。

参考答案:

公有继承

有如下程序：#includeusingnamespacestd;classA{public:A(inti){x=i;}voiddispa(){cout<

参考答案:

12,2

私有继承中，基类中所有成员对派生类的对象来说都是不可直接访问的。

参考答案:

正确

无论是私有继承还是保护继承中，基类中所有成员对派生类对象都是不可见的。

参考答案:

正确

若类Y是类X的私有派生类，类Z是类Y的公有派生类，则类Z不能访向类X的公有成员和保护成员。

参考答案:

正确

建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为（）的构造函数。

参考答案:

基类、对象成员所属类、自己所属类

下列关于多继承二义性的描述中，错误的是（）。

参考答案:

基类和派生类中同时出现同名成员时，会产生二义性

下面程序的运行结果是（）。#includeclassbase{protected:inta;public:base(){cout<<"0";}};classbase1:virtualbase{public:base1(){cout<<"1";}};classbase2:virtualbase{public:base2(){cout<<"2";}};classderived:publicbase1,publicbase2{public:derived(){cout<<"3";}};voidmain(){derivedobj;}

参考答案:

0123

关于多继承二义性的描述中，（）是错的。

参考答案:

基类和派生类中同时出现的同名函数，也存在二义性问题

下面关于多重继承的叙述，正确的是（）。

参考答案:

多重继承中可以通过虚基类防止二义性问题

多重继承的派生类构造函数中执行基类构造函数的顺序取决于该派生类构造函数的成员初始化列表中出现基类初始化项的顺序。

参考答案:

错误

多重继承派生类构造函数的成员初始化列表中应包含所有直接基类的构造函数。

参考答案:

错误

在派生类的构造函数的初始化表中不能对包含基类的子对象初始化。

参考答案:

正确

派生类的构造函数的成员初始化列表中，可以包含基类的子对象初始化。

参考答案:

错误

解决多继承情况下出现的二义性的方法之一是使用成员名限定法（即类名和作用域运算符）。

参考答案:

正确

在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。

参考答案:

作为成员函数重载的1元运算符

如果表达式a++中的“++”是作为友元函数重载的运算符，若采用运算符函数调用格式，则可表示为（）。

参考答案:

operator++(a,1)

在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。则operator+有（）个参数，operator*有（）参数。

参考答案:

1、2

在C++中不能被重载的一组运算符是（）。

参考答案:

::

?:

.

sizeof

下列关于运算符函数的描述中，错误的是()。

参考答案:

运算符函数只能定义为类的成员函数

运算符重载时不需要保持的性质是（）。

参考答案:

操作数类型

下列函数中，能重载运算符的函数是()。

参考答案:

友元函数

所有的运算符都可以重载。

参考答案:

错误

运算符重载后，原运算符的优先级和结合特性不会改变。

参考答案:

正确

函数重载是一种多态现象，它属于动态联编。

参考答案:

错误

函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。

参考答案:

正确

编译时的多态性可以通过使用（）获得。

参考答案:

虚函数和对象

虚函数的定义是在基类中进行的，定义时需要冠以关键字（）。

参考答案:

virtual

在下面程序中，编译时出现的错误是()。classA//file:(1){public://file:(2)A(){func();//file:(3)}virtualvoidfunc()=0;//file:(4)};

参考答案:

（3）

通过一个对象调用虚函数时，C++系统对该调用采用（）。

参考答案:

静态联编

多态调用是指（）。

参考答案:

借助于指向对象的基类指针或引用调用一个虚函数

关于函数的描述中，()是正确的。

参考答案:

虚函数是一个成员函数

类定义如下：classA{public:virtualvoidfunc1(){}voidfun2(){}};classB:publicA{public:voidfunc1(){cout<<”classBfunc1”<

参考答案:

B::func1()是虚函数，而A::func2()不是虚函数

有如下程序：#include#includeusingnamespacestd;classPublication{//出版物类charname[30];public:Publication(char*name="未知名称"){strcpy(this->name,name);}constchar*getName()const{returnname;}virtualconstchar*getType()const{return"未知类型";}};classBook:publicPublication{//书类public:Book(char*name):Publication(name){}virtualconstchar*getType()const{return"书";}};voidshowPublication(Publication&p){cout<

参考答案:

书：精彩人生

一个抽象类中可以包含有多个纯虚函数，一个派生类中也可以包含多个虚函数。

参考答案:

正确

C++的虚函数必须是类的一个成员，而不允许是类的友元。

参考答案:

正确

对于从基类继承的虚函数，派生类也可以不进行重定义。

参考答案:

正确

通常情况下，函数模板中的类型参数个数不能是（）。

参考答案:

0个

（）是以一种完全通用的方法来设计函数或类而不必预先说明将被使用的每个对象的类型。

参考答案:

模板

（）使一个函数可以定义成对许多不同数据类型完成同一个任务。

参考答案:

函数模板

类模板的使用实际上是将类模板实例化成一个具体的（）。

参考答案:

类

有关函数模板说法错误的是（  ）。

参考答案:

函数模板不能含有常规形参

若同时定义了下列四个选项格式的函数和模板，fun(8,3.1)调用的是（ ）。

参考答案:

template

类模板的使用实际上是将类模板实例化成一个（）。

参考答案:

类

下列哪项可作为函数模板和类模板的共同特点？()

参考答案:

数据类型作参数

函数模板中模板参数只能有一个。

参考答案:

错误

函数模板在执行过程中，需要经过一次编译。

参考答案:

错误

在定义多个重载函数时，可以考虑将它们合并成一个函数模板，减少程序员的编码工作量。

参考答案:

正确

根据对话框的行为性质，对话框可以分为两类：（）。

参考答案:

模态对话框和非模态对话框

虚拟码是一种与设备无关的键盘编码，它的值存放在键盘消息的（）参数中。

参考答案:

wParam

以下控件中，（）没有Caption属性。

参考答案:

编辑控件

资源描述文件中ACCELERATORS定义的是（）。

参考答案:

加速键资源

以下是关于鼠标的消息类型，表示按下鼠标左键的是（）。

参考答案:

WM_LBUTTONDOWN

运用SetTimer函数实现的计时器功能中时间间隔以（）为单位。

参考答案:

毫秒

WindowsAPI中定义位图的数据结构是（）。

参考答案:

HBITMAP

要创建红色，应使用下面哪个（）。

参考答案:

RGB(255,0,0)

为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（）。

参考答案:

public

下列程序中说明的公有成员是()。classLocation{intX;public:voidinit(int,initX,intinitY);private:intY;public:intGetX();intGetY();};

参考答案:

init(intinitX,intinitY),GetX(),GetY()都是

下列关于对象的描述中，错误的是（）。

参考答案:

一个类所能创建对象的个数是有限制的

下列关于引用概念的描述中，错误的是（）。

参考答案:

引用是变量，它具有值和地址值

下列设置函数参数默认值的说明语句中，错误的是（）。其中，a和b是已定义过具有有效值的变量。

参考答案:

intfun(intx=5,inty);

voidSet(&a);是类中一个成员函数的说明，其中&a的含义是（）。

参考答案:

类A的对象引用a作该函数的参数

下列选择重载函数的不同实现的判断条件中，错误的是（）。

参考答案:

函数返回值不同

在函数的引用调用中，函数的实参和形参分别应是（）。

参考答案:

变量名和引用

在类外定义类的成员函数时，应当使用（）来标识该函数为特定类的成员。

参考答案:

：：

已知类A中的一个成员函数的说明如下:voidSet(A&a);则该函数的参数"A&a"的含义是（）。

参考答案:

类A对象引用a用作函数的形参

成员函数与一般函数一样可以重载、内联和设置参数的默认值。

参考答案:

正确

定义对象引用时，可以对其引用进行初始化，也可以不进行初始化。

参考答案:

错误

类中的数据成员不能为指针类型。

参考答案:

错误

在C++中，定义函数时应该给出函数的返回类型。

参考答案:

正确

自身类对象的引用不可以作为该类的成员。

参考答案:

错误

下面（）项是对构造函数和析构函数的正确定义。

参考答案:

X::X(参数),

X::~X()

一个类拥有多个构造函数，则这些构造函数之间为（）。

参考答案:

重载关系

执行下列说明语句，其调用构造函数的次数为（）。Aa[5]，*p[2];其中，A是一个类名

参考答案:

5

下列对类的构造函数和析构函数的叙述，正确的是（）。

参考答案:

构造函数可以重载，析构函数不能重载

假定AB为一个类，则()为该类的复制构造函数的原型说明。

参考答案:

AB(AB&x);

假定AB为一个类，则执行“ABr1=r2;”语句时将自动调用该类的（）。

参考答案:

复制构造函数

如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（）。

参考答案:

编译器总是自动创建一个不带参数的构造函数

有如下两个类定义：classAA{};classBB{AAv1,*v2;BBv3;int*v4;};其中有一个成员变量的定义是错误的，这个变量是()。

参考答案:

v3

对于复制构造函数，正确的描述是（）。

参考答案:

在C++语言中，如果不自定义类的复制构造函数，则每个类都有默认的复制构造函数

下列有关析构函数的描述中，正确的是（）。

参考答案:

析构函数在撤消对象时，系统自动调用

对象指针可用同类对象的地址值给它赋值。

参考答案:

正确

构造函数没有函数返回类型。

参考答案:

正确

假定AB为一个类，则执行“ABa[10];”语句时，系统自动调用该类的构造函数的次数为1次。

参考答案:

错误

类的析构函数的作用是对象的初始化。

参考答案:

错误

类中的成员数据可以是另一个类的对象。

参考答案:

正确

下面关于静态成员函数的叙述中错误的是（）。

参考答案:

this指针可以指向静态成员函数

由于数据隐藏的需要，静态数据成员通常被说明为（）。

参考答案:

私有的

对于友元描述正确的是（）。

参考答案:

友元不是本类的成员函数

静态数据成员的初始化是在（）中进行的。

参考答案:

全局区

一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（）。

参考答案:

需加上类域的限定

类A是类B的友元,类B是类C的友元,则()是正确的。

参考答案:

以上都不对

如果类B被说明成类A的友元，则（）。

参考答案:

类B的成员函数可以访问类A的成员

下面关于友元的描述中，错误的是（）。

参考答案:

友元关系不能被继承，是双向可交换的。

有如下程序：#includeusingnamespacestd;classSample{friendintfun(Samples);public:Sample(inta){x=a;}private:intx;};intfun(Samples){if(s.x<2)return1;returns.x*fun(Sample(s.x-1));}intmain(){intsum=0;for(inti=0;i<6;i++)sum+=fun(Sample(i));cout<

参考答案:

154

静态成员变量是整个类的所有对象共用的。

参考答案:

正确

可以把一个一般函数说明为某类的友元函数，也可以将某类的成员函数说明为另类的友元函数。

参考答案:

正确

友元类中的所有成员函数都是友元函数。

参考答案:

正确

构造函数的功能是对对象进行初始化。

参考答案:

正确

构造函数和析构函数都可以重载。

参考答案:

错误

下列的模板说明中,正确的是（) 。

参考答案:

template

抽象类只能作基类，不能定义抽象类的对象。

参考答案:

正确

含有纯虚函数的类称为抽象类，与抽象类相对应的是具体类。

参考答案:

正确

下列关于多态性的描述，错误的是（）。

参考答案:

运行时的多态性可通过模板和虚函数实现

类B是类A的公有派生类，类A和类B中都定义了虚函数func(),p是一个指向类A对象的指针，则p->A::func()将（）。

参考答案:

调用类A中的函数func()

对虚函数不正确描述是（）。

参考答案:

不可以声明虚析构函数

（）是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。

参考答案:

纯虚函数

对每个可重载的运算符来说,只能重载为友元函数。

参考答案:

错误

不同的对象可以调用相同名称的函数，并可导致完全不同的行为的现象称为（）。

参考答案:

多态性

Windows应用程序常用消息，产生单击鼠标左键的消息是（）。

参考答案:

WM_LBUTTONDOWN

下面有关静态成员函数的描述中，正确的是（）。

参考答案:

在建立对象前，就可以为静态数据成员赋值

静态成员函数中引用静态数据成员和非静态数据成员的方式是相同的。

参考答案:

错误

静态成员函数可以引用属于该类的任何函数成员。

参考答案:

错误

消息映射宏提供了（）。

参考答案:

响应消息的入口

可以利用控件的（）属性和Tab键顺序来为控件分组。

参考答案:

Group组

虚基类是用来解决多继承中公共基类在派生类中只产生一个基类子对象的问题。

参考答案:

正确

设置编辑控件的文本内容，可使用函数（）。

参考答案:

SetWindowText()

在下列程序中，C类的数据成员中有一个A类对象和一个B类对象。#includeclassA{inta;public:A(intx=10){a=x;}intGetA(){returna;}};classB{intb;public:B(intx){b=x;}intGetB(){returnb;}};classC{intc;Aaobj;Bbobj;public:C(intx,inty,intz):aobj(y),bobj(z)//E{c=x;}voidprint(){cout<

参考答案:

C(intx,inty,intz):aobj(y)

下面四个MFC类中哪一个是管理MFC应用程序的类?（）

参考答案:

CWinApp

有如下程序：#includeusingnamespacestd;classA{public:A(){cout<<"A";}~A(){cout<<"~A";}};classB:publicA{A*p;public:B(){cout<<"B";p=newA();}~B(){cout<<"~B";deletep;}};intmain(){Bobj;return0;}执行这个程序的输出结果是()

参考答案:

ABA~B~A~A

当派生类从基类公有继承时，以下哪种说法是错误的（）。

参考答案:

可以用基类对象为派生类对象赋值。

下列关于虚基类的描述中，错误的是()。

参考答案:

声明classB:virtualpublicA说明类B为虚基类

在公有继承中，基类中只有公有成员对派生类的对象是可见的。

参考答案:

正确

基类中成员在派生类中都是可以访问的。

参考答案:

错误

使用派生类的主要原因是（）。

参考答案:

提高代码的可重用性

利用Create函数创建非模态对话框时，还需要调用什么函数将这个对话框显示出来？（）

参考答案:

ShowWindow

下面哪个类的第一个参数为FALSE时，显示一个另存为文件对话框（）。

参考答案:

CFileDialog

不能将一个声明为指向派生类对象的指针指向其基类的对象。

参考答案:

正确

在一个派生类对象结束其生命周期时（）。

参考答案:

先调用派生类的析构函数后调用基类的析构函数

下列虚基类的声明中正确的是（）。

参考答案:

classB:virtualpublicA

（）可以解决二义性问题。

参考答案:

使用作用域分辨操作符或虚基类

对于公有继承，基类的公有和保护成员在派生类中将（）成员。

参考答案:

仍然相应保持为公有和保护

要使语句“p=newint[10][20];”能够正常执行，p应被事先定义为（）。

参考答案:

int(*p)[20];

执行如下程序后的输出结果是（）。#includeclasstest{staticintcount;public:test(){count++;}~test(){count--;}staticintgetCount(){returncount;}}；inttest::count=0;intmain(){test*p=newtest;test*q=newtest;deletep;cout<<"count="<

参考答案:

count=1

关于成员函数特征的描述中，不正确的是（）。

参考答案:

成员函数不可以是静态的，只有数据成员可以是静态的

运算符delete删除一个动态对象时（）。

参考答案:

首先为该动态对象调用析构函数,在释放其占用的内存

关于const关键字说法错误的是（）。

参考答案:

const可以用于说明类

类MyClass的定义如下：classMyClass{public:MyClass(){value=0;}SetVariable(inti){value=i;}private:intvalue;};则对下列语句序列正确的描述是（）。MyClass*p，my；p=&my；

参考答案:

语句p->SetVariable(5)与语句my.SetVariable(5)等价

常类型指针有两种，一种是指针的地址值是常量，另一种是指针所指向的变量或对象是常量。

参考答案:

正确

在C++中，动态分配内存是通过new来实现的。

参考答案:

正确

一个函数模板只生成一个模板函数。

参考答案:

错误

关于抽象类，下列表述正确的是（）。

参考答案:

抽象类不能用于定义对象

已定义类A：classA{public:intx;staticinty;};intA::y=0;下列语句中错误的是（）。

参考答案:

A.x=1;

A.y=1;

控件ID标识符表示（）。

参考答案:

控件在代码中的符号化表示

对于公有继承，基类中的私有成员在派生类中将（）。

参考答案:

仍然是基类的私有成员

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

参考答案:

错误

对于消息队列的描述正确的是（）。

参考答案:

其他都正确

要创建绿色，应使用下面哪个？（）。

参考答案:

RGB(0,255,0)

MFC可以创建哪种类型的应用程序（）。

参考答案:

其他全部

以下有关继承的叙述正确的是（）。

参考答案:

派生类对象能访问自己的公有成员，不能访问基类的私有和保护成员

继承与派生可以给软件开发带来很多好处，下述中不正确的是（）。

参考答案:

软件的执行效率大大提高

对于下述程序，如果将第①句中的“protected:”去掉，则编译时（）。#includeclassBase｛protected://①intBase_pro;public:voidset(inti)｛Base_pro=i;｝｝;classDerived:publicBase//②｛intDrv_pri;public:voidDrvSet(inti,intj)｛Drv_pri=i;set(j);//③｝voiddisplay()｛cout<<""\nDrv_pri=""<

参考答案:

第③句对，第④句出错

私有继承中基类的私有成员在派生类中还是私有的。

参考答案:

错误

在main函数中可以用p.a的形式访问派生类对象p的基类成员a，其中a是（）。

参考答案:

公有继承的公有成员

设W是U的公有派生类，U中的保护性数据成员a,被继承到W中后其访问属性是()。

参考答案:

保护的

下列描述错误的是（）。

参考答案:

在创建对象前,静态成员不存在

一个类中只能定义一个析构函数。

参考答案:

正确

类的静态数据成员需要在定义每个类的对象时进行初始化。

参考答案:

错误

多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数定义实现的。

参考答案:

正确

在以下new和delete运算符使用中，错误的是()。

参考答案:

char*p=newint[10];deletep;

假定指针变量p定义为“int*p=newint(100);”，要释放p所指向的动态内存，应使用语句（）。

参考答案:

deletep;

运算符重载是通过函数来实现的，定义运算符重载函数时，函数名中要使用关键字operator

参考答案:

正确

类的公有静态成员既可以用类的对象访问，也可以用作用域运算符通过类名访问。

参考答案:

正确

可以在类的构造函数中对静态数据成员进行初始化。

参考答案:

错误

关于友元的描述中，（）是错误的。

参考答案:

友元函数是成员函数，它被说明在类体内

对静态成员的不正确描述是（）。

参考答案:

调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针

构造函数是一个其名与类名相同的特殊的成员函数。

参考答案:

正确

如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是()。

参考答案:

重载错误

有如下类声明：classXA{private:intx;public:XA(intn){x=n;}};classXB:publicXA{private:inty;public:XB(inta,intb);};在构造函数XB的下列定义中，正确的是（）。

参考答案:

XB::XB(inta,intb):XA(a),y(b){}

对于下面程序段，表达式正确的是（）。classBase{public:intb;};classBase1:publicbase{};classBase2:publicbase{};classDerived:publicbase1,