《C++程序设计》期末复习题要点文档格式.docx
《《C++程序设计》期末复习题要点文档格式.docx》由会员分享，可在线阅读，更多相关《《C++程序设计》期末复习题要点文档格式.docx（81页珍藏版）》请在冰点文库上搜索。
a;
C．void（A:
*pa）（int）;
Ｄ.A**p;
（7）下列关于对象数组的描述中，（C）是错的。
Ａ．对象数组的数组名是一个地址常量;
Ｂ．对象数组的下标是从０开始的;
Ｃ．对象数组只能赋初值，不能被赋值;
Ｄ．对象数组的数组元素是同一个类的对象．
（8）下列定义中，（B）是定义指向类A的对象数组的指针。
A．A*p[5];
Ｂ．A（*p）[5];
Ｃ．（A*）p[5];
Ｄ．A*p[];
（9）说明语句constchar*ptr;
中，ptr是（A）。
A．指向字符常量的指针；
Ｂ．指向字符的常量指针；
Ｃ．指向字符串常量的指针；
Ｄ．指向字符串的常量指针。
（10）关于new运算符的下列描述中，（B）是错的.
Ａ．使用它创建对象时要调用构造函数；
Ｂ．使用它创建对象数组时必须指定初始值；
Ｃ．它可以用来动态创建对象和对象数组；
Ｄ．使用它创建的对象或对象数组可以使用运算符delete删除。
（1）派生类的对象对它的基类成员中（C）是可以访问的．
Ａ．公有继承的保护成员；
Ｂ．公有继承的私有成员；
Ｃ．公有继承的公有成员；
Ｄ．私有继承的公有成员．
（2）下面关于派生类的描述中，（D）是错的。
Ａ．一个派生类可以作为另一个派生类的基类；
Ｂ．派生类至少有一个基类；
Ｃ．派生类的成员除了它自己的成员外，还包含了它的基类的成员．
Ｄ．派生类中继承的基类成员的访问权限到派生类保持不变。
（3）派生类的构造函数的成员初始化列表中，不能包含（C）
Ａ．基类的构造函数调用；
Ｂ．派生类对象成员的初始化；
Ｃ．基类对象成员的初始化；
Ｄ．派生类中一般数据成员的初始化．
（4）设置虚基类的目的是（B）
Ａ．减少目标代码；
Ｂ．消除二义性；
Ｃ．提高运行效率；
Ｄ．简化程序。
（5）带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数，这样将对虚基类的子对象初始化（ A）
Ａ．一次；
Ｂ．二次；
Ｃ．多次；
Ｄ．与虚基类下面的派生类个数有关．
（1）以下保留字（A）不能出现在说明虚函数原型的语句中。
A．staticB.operatorC.voidD.const.
（2）以下关于虚函数和纯虚函数的说法中，（D）是不正确的
A．在派生类中虚函数可以不用关键字virtual说明。
B.虚函数在派生类中可以不重定义。
C.不能为虚函数定义缺省操作。
D.纯虚函数在派生类中可以不重定义。
（3）以下关于动态绑定的说法中，正确的是（C）
A．虚基类是动态绑定的。
B.指针是动态绑定的。
C.所有的虚函数和纯虚函数都是动态绑定的。
D.动态绑定与编译系统无关。
（4）以下关于抽象类的说法中，（C）是不正确的
A．不可创建抽象类的实例。
B.可以声明抽象类的引用。
C.抽象类的派生类也是抽象类。
D.抽象类的派生类也可以是抽象类。
（5）以下关于抽象类的说法中，只有（B）是正确的
A．定义抽象类的目的是软件重用。
B.定义抽象类是为了提高访问效率。
C.定义抽象类是使指针的使用更灵活。
D.抽象类提供了对类进行分类的机制。
（6）以下关于多态性的说法中，（D）是不正确的
A．每个多态类的对象有一个虚表指针。
B.虚函数调用与this指针无关。
C.每个多态类的基类都有一个虚函数表。
D.多态类的每一个派生类都有一个虚函数表。
（1）下列不是C++流对象的是（D）
A.coutB.cinC.cerrD.ostream
（2）已知:
intw=-3,x=10,z=7执行下面的语句的输出结果为（A）
cout<
<
x>
（10?
x+100:
x-10）
<
（w++||z++）
（!
w<
z）
（w&
&
A.0111B.1111C.0101D.0100
（3）voidmain（）{cout<
setfill（'
*'
）<
setw（10）<
10<
endl;
}的输出结果为（C）
A.$1010B.**********10C.********10D.*1010
（4）C++所有输入和输出流的基类是（D）
A.stream.hB.iostream.hC.cin和coutD.ios
（5）文件的输入与输出流是（B）
A.iostream.h
B.ifstream和ofstream
C.istream_withassign，ostream_withassign
D.istream和ostream
（6）语句cout<
oct<
12;
的输出结果是C
A.12B.1100C.14D.C
（7）对<
进行重载的语句istream&
operator<
（istream&
is,date&
dt），其中对is的说法正确的是（B）
A.是一个istream对象
B.是istream的一个对象的引用
C.起返回操作结果作用
D.仅作为参数传递的作用
（8）以流方式打开一个文件的输入文件的语句正确的是（B）
A.ofstreamafile（）;
afile.open（"
test1.dat"
，ios:
in|ios:
binary）
B.ifstreamafile（）;
binary）
C.ifstreamafile（）;
out|ios:
D.ofstreamafile（）;
afile.open（"
94.关于消息，下列说法中不正确的是（B）。
A.发送消息的对象请求服务，接受消息的对象提供服务
B.消息的发送者必须了解消息的接收者如何相应消息
C.在C++中，消息的发送具体体现为对接收消息的对象的某个函数的调用
D.每个对象只能接收某些特定格式的消息
95.关于封装，下列说法中不正确的是（D）。
A.通过封装，对象的全部属性和操作结合在一起，形成一个整体
B.通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
C.通过封装，每个对象都成为相对独立的实体
D.通过封装，对象的属性都是不可见的
96.面向对象方法的多态性是指（C）。
A.一个类可以派生出多个特殊类
B.一个对象在不同的运行环境中可以有不同的变体
C.针对一消息，不同的对象可以以适合自身的方式加以响应
D.一个对象可以是由多个其他对象组合而成的
104.在一个类的定义中，包含有（）成员的定义。
A.数据B.函数C.数据和函数D.数据或函数
105.在类作用域中能够通过直接使用该类的（）成员名进行访问。
A.私有B.公用C.保护D.任何
106.在关键字public后面定义的成员为类的（）成员。
107.在关键字private后面定义的成员为类的（）成员。
108.假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（）。
A.x（a）B.x[a]C.x->
aD.x.a
109.假定AA为一个类，a（）为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a（）的格式为（）。
A.x.aB.x.a（）C.x->
aD.x->
a（）
110.假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（）。
A.px（a）B.px[a]C.px->
aD.px.a
111.假定AA为一个类，a为该类私有的数据成员，GetValue（）为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（）。
GetValue（）D.x.GetValue（）
112.假定AA为一个类，inta（）为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。
A.intAA:
a（）B.intAA:
a（）
C.AA:
a（）D.AA:
inta（）
113.假定AA为一个类，a为该类公有的数据成员，若要在该类的一个成员函数中访问它，则书写格式为（）。
A.aB.AA:
aC.a（）D.AA:
114.若需要把一个类外定义的成员函数指明为内联函数，则必须把关键字（）放在函数原型或函数头的前面。
A.inB.inlineC.inLineD.InLiner
115.在多文件结构的程序中，通常把类的定义单独存放于（）中。
A.主文件B.实现文件C.库文件D.头文件
116.在多文件结构的程序中，通常把类中所有非内联函数的定义单独存放于（）中。
117.在多文件结构的程序中，通常把含有main（）函数的文件称为（）。
A.主文件B.实现文件C.程序文件D.头文件
118.一个C++程序文件的扩展名为（）。
A..hB..cC..cppD..cp
119.在C++程序中使用的cin标识符是系统类库中定义的（）类中的一个对象。
A.istreamB.ostreamC.iostreamD.fstream
120.在C++程序中使用的cout标识符是系统类库中定义的（）类中的一个对象。
121.假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数的类型为（）。
A.intB.charC.AAD.AA*
122.假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数为（）。
A.abcB.*thisC.thisD.this&
123.假定AA是一个类，“AA&
abc（）;
”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc（）调用该成员函数后，x的值（）。
A.已经被改变B.可能被改变
C.不变D.不受函数调用的影响
124.假定AA是一个类，“AA*abc（）const;
”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc（）调用该成员函数后，x的值（）。
C.不变D.受到函数调用的影响
125.类中定义的成员默认为（）访问属性。
A.publicB.privateC.protectedD.friend
126.结构中定义的成员默认为（）访问属性。
127.当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为（）。
A.nB.n+1C.n-1D.n-2
128.在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队尾（即最后一个）元素的位置为（）。
A.length+1B.first+length
C.（first+length-1）%MSD.（first+length）%MS
129.在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队尾的后一个位置为（）。
130.在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队首的后一个位置为（）。
A.first+1B.（first+1）%MS
C.（first-1）%MSD.（first+length）%MS
131.在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队非空，则进行插入时必须把新结点的地址赋给（）。
A.elemHeadB.elemTail
C.elemHead->
next和elemHeadD.elemTail->
next和elemTail
132.在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队为空，则进行插入时必须把新结点的地址赋给（）。
C.elemHead和elemTailD.elemHead或elemTail
133.队列具有（）的操作特性。
A.先进先出B.先进后出C.进出无序D.进出任意
134.栈具有（）的操作特性。
135.对于一个类的构造函数，其函数名与类名（）。
A.完全相同B.基本相同C.不相同D.无关系
136.对于一个类的析构函数，其函数名与类名（）。
A.完全相同B.完全不同C.只相差一个字符D.无关系
137.类的构造函数是在定义该类的一个（）时被自动调用执行的。
A.成员函数B.数据成员C.对象D.友元函数
138.类的析构函数是一个对象被（）时自动调用的。
A.建立B.撤消C.赋值D.引用
139.一个类的构造函数通常被定义为该类的（）成员。
A.公用B.保护C.私有D.友元
140.一个类的析构函数通常被定义为该类的（）成员。
A.私有B.保护C.公用D.友元
141.假定AB为一个类，则执行“ABx;
”语句时将自动调用该类的（）。
A.带参构造函数B.无参构造函数C.拷贝构造函数D.赋值重载函数
142.假定AB为一个类，则执行“ABx（a,5）;
143.假定AB为一个类，则执行“AB*s=newAB（a,5）;
”语句时得到的一个动态对象为_______。
A.sB.s->
aC.s.aD.*s
144.假定AB为一个类，则执行“ABr1=r2;
A.无参构造函数B.带参构造函数C.赋值重载函数D.拷贝构造函数
145.若需要使类中的一个指针成员指向一块动态存储空间，则通常在（）函数中完成。
A.析构B.构造C.任一成员D.友元
146.当类中的一个整型指针成员指向一块具有n*sizeof（int）大小的存储空间时，它最多能够存储（）个整数。
A.nB.n+1C.n-1D.1
147.假定一个类的构造函数为“A（intaa,intbb）{a=aa;
b=aa*bb;
}”，则执行“Ax（4,5）;
”语句后，x.a和x.b的值分别为（）。
A.4和5B.5和4C.4和20D.20和5
148.假定一个类的构造函数为“A（intaa=1,intbb=0）{a=aa;
b=bb;
}”，则执行“Ax（4）;
A.1和0B.1和4C.4和1D.4和0
149.假定AB为一个类，则（）为该类的拷贝构造函数的原型说明。
A.AB（ABx）;
B.AB（AB&
x）;
C.voidAB（AB&
D.AB（intx）;
150.假定一个类的构造函数为“B（intax,intbx）:
a（ax）,b（bx）{}”，执行“Bx（1,2）,y（3,4）;
x=y;
”语句序列后x.a的值为（）。
A.1B.2C.3D.4
151.假定一个类AB只含有一个整型数据成员a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为（）。
A.AB（）{a=0;
}B.AB（intaa=0）:
a（aa）{}
C.AB（intaa）:
a（aa）{}D.AB（）{}
152.假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为（）。
A.AB（）{}B.AB（）:
a（0）{}
C.AB（intaa=0）{a=aa;
}D.AB（intaa）{}
153.对于任一个类，用户所能定义的构造函数的个数至多为（）。
A.0B.1C.2D.任意个
154.对于任一个类，用户所能定义的析构函数的个数至多为（）。
155.假定AB为一个类，则执行“AB*px=newAB[n];
”语句时将（）。
A.动态分配一个数组B.动态分配一个对象
C.静态分配一个数组D.静态分配一个对象
156.设px是指向一个类对象的指针变量，则执行“deletepx;
”语句时，将自动调用该类的（）。
A.无参构造函数B.带参构造函数C.析构函数D.拷贝构造函数
157.当一个类对象离开它的作用域时，系统自动调用该类的（）。
A.无参构造函数B.带参构造函数C.拷贝构造函数D.析构函数
158.假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为（）。
A.0B.1C.nD.n-1
159.假定AB为一个类，则执行“ABa[10];
”语句时调用该类无参构造函数的次数为（）。
A.0B.1C.9D.10
160.假定AB为一个类，则执行“AB*px=newAB[n];
A.nB.n-1C.1D.0
161.假定AB为一个类，则执行“ABa,b（3）,*p;
”语句时共调用该类构造函数的次数为（）。
A.2B.3C.4D.5
162.假定AB为一个类，则执行“ABa
（2）,b[3],*p[4];
A.3B.4C.5D.9
163.假定AB为一个类，则执行“ABa,b
（2）,c[3],*p=&
”语句时共调用该类无参构造函数的次数为（）。
A.5B.6C.3D.4
164.假定AB为一个类，则执行“AB*p=newAB（1,2）;
A.0B.1C.2D.3
165.假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete[]px;
”语句时共调用该类析构函数的次数为（）。
A.0B.1C.nD.n+1
166.对类对象成员的初始化是通过构造函数中给出的（）实现的。
A.函数体B.初始化表C.参数表D.初始化表或函数体
167.对类中常量成员的初始化是通过构造函数中给出的（）实现的。
A.函数体B.参数表C.初始化表D.初始化表或函数体
168.对类中引用成员的初始化是通过构造函数中给出的（）实现的。
169.类的构造函数可以带有（）个参数。
A.0B.1C.2D.任意
170.类的析构函数可以带有（）个参数。
171.一个类的静态数据成员所表示属性（）。
A.是类的或对象的属性B.只是对象的属性
C.只是类的属性D.类和友元的属性
172.类的静态成员的访问控制（）。
A.只允许被定义为private
B.只允许被定义为private或protected
C.只允许被定义为public
D.可允许被定义为private、protected或public
173.静态成员函数对类的数据成员访问（）。
A.是不允许的B.只允许是静态数据成员
C.只允许是非静态数据成员D.可允许是静态数据成员或非静态数据成员
174.被非静态成员函数访问的类的数据成员（）。
A.可以是非静态数据成员或静态数据成员B.不可能是类的静态数据成员
C.只能是类的非静态数据成员D.只能是类的静态数据成员
175.静态数据成员的初始化是在（）中进行的。
A
升级会员 