《c++》复习题集及答案

目录

一、单选题 ....................................................................................................................................... 1 二、判断题 ..................................................................................................................................... 12 三、填空题 ..................................................................................................................................... 13 四、程序填充 ................................................................................................................................. 18 五、读程序写出运行结果 ............................................................................................................. 31 六、指出以下程序或函数的功能 ................................................................................................. 44 七、程序改错 ................................................................................................................................. 46 八、程序设计 ................................................................................................................................. 52 《面向对象程序设计》答案 ......................................................................................................... 61

一、单选题

1. C++源程序文件的缺省扩展名为( A )。

A. cpp B. exe C. obj D. lik

2. 由C++源程序文件编译而成的目标文件的缺省扩展名为( C )。 A. cpp B. exe C. obj D. lik

3. 由C++目标文件连接而成的可执行文件的缺省扩展名为( B )。 A. cpp B. exe C. obj D. lik

4. 编写C++程序一般需经过的几个步骤依次是( B )。 A. 编译、编辑、连接、调试 B. 编辑、编译、连接、调试 C. 编译、调试、编辑、连接 D. 编辑、调试、编辑、连接

6. 能作为C++程序的基本单位是( C )。

A. 字符 B. 语句 C. 函数 D. 源程序文件 8. C++程序的基本模块为（ D ）。

A. 表达式 B. 标识符 C. 语句 D. 函数 10. 存储以下数据，占用存储字节最多的是（ D ）。 A. 0 B. ?0? C. “0” D. 0.0 38. 以下说法中正确的是（ B ）。

A. C++程序总是从第一个定义的函数开始执行 B. C++程序总是从main函数开始执行

C. C++函数必须有返回值，否则不能使用函数

1

D. C++程序中有调用关系的所有函数必须放在同一个程序文件中 40. 函数重载是指（ A ）。

A. 两个或两个以上的函数取相同的函数名，但形参的个数或类型不同

B. 两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同 C. 两个以上的函数名字不同，但形参的个数或类型相同

D. 两个以上的函数取相同的函数名，并且函数的返回类型相同 41. 以下关于函数模板叙述正确的是（ C ）。 A. 函数模板也是一个具体类型的函数

B. 函数模板的类型参数与函数的参数是同一个概念

C. 通过使用不同的类型参数，函数模板可以生成不同类型的函数 D. 用函数模板定义的函数没有类型 42. 下列（ C ）的调用方式是引用调用。

A. 形参和实参都是变量 B.形参是指针，实参是地址值 C. 形参是引用，实参是变量 D.形参是变量，实参是地址值

43. 为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（ A ）。

A. 内联函数 B.重载函数 C.递归函数 D.函数模板 55. 以下正确的描述是（ C ）。 A. 不允许设置参数的默认值

B. 设置参数的默认值只能在定义函数时设置 C. 设置参数的默认值时，应该设置右边的参数 D. 设置参数的默认值时，应该全部参数都设置 56. 采用重载函数的目的是（ D ）。 A. 实现共享 B. 减少空间

C. 提高速度 D. 使用方便，提高可读性 59. 下面的标识符中，( C )是文件级作用域。

A. 函数形参 B.语句标号 C.外部静态类标识符 D.自动类标识符 60. 以下叙述不正确的是( D )。

A. 宏替换不占用运行时间 B. 宏名无类型

C. 宏替换只是字符替换 D. 宏名必须用大写字母表示 61. C++语言的编译系统对宏命令的处理是( D )。 A. 在程序运行时进行 B. 在程序连接时进行

C. 和C++程序的其它语句同时进行编译

D. 在对源程序中其它成分正式编译之前进行

62. 当#include后面的文件名用双引号括起来时，寻找被包含文件的方式是( B ) A. 直接按系统设定的标准方式搜索目录

B. 先在源程序所在目录搜索，再按系统设定的标准方式搜索目录 C. 仅仅搜索源程序所在目录 D. 搜索当前逻辑盘上的所有目录

63. 当#include后面的文件名用尖括号括起来时，寻找被包含文件的方式是( A ) A. 直接按系统设定的标准方式搜索目录

B. 先在源程序所在目录搜索，再按系统设定的标准方式搜索目录 C. 仅仅搜索源程序所在目录 D. 搜索当前逻辑盘上的所有目录

。 。 2

67. 文件包含命令中被包含的文件的扩展名（ C ）。

A. 必须是.h B. 不能是.h C. 可以是.h或.cpp D. 必须是.cpp 70. 用new运算符创建一个含10个元素的一维整型数组的正确语句是( C )。 A. int *p=new a[10]; B. int *p=new float[10];

C. int *p=new int[10]; D. int *p=new int[10]={1,2,3,4,5}

80. 假定p指向的字符串为”string”，则cout<

83. 假定p是具有int**类型的指针变量，则给p赋值的正确语句为（ B ）。

A. p=new int; B. p=new int*; C. p=new int**; D. p=new int[10]; 84. 要使语句“p=new int[10][20];”能够正常执行，p应被事先定义为（ D ）。 A. int *p; B. int **p; C. int *p[20]; D. int(*p)[20]; 85. 假定有“struct BOOK{char title[40]; float price;}; BOOK *book=new BOOK;”，则正确的语句为（ A ）。

A. strcpy(book->title,”Wang Tao”); B. strcpy(book.title,”Wang Tao”);

C. strcpy(*book.title,”Wang Tao”); D. strcpy((*book)->title,”Wang Tao”);

86. 假定有“struct BOOK{char title[40]; float price;}; BOOK *book;”，则不正确的语句为（ A ）。

A. BOOK *x=new book; B. BOOK x={\ C. BOOK *x=new BOOK; D. BOOK *x=book;

87. 假定有“struct BOOK{char title[40]; float price;}book;”，则正确的语句为（ B ）。

A. BOOK &x= &book; B. BOOK &x=book; C. BOOK &x=new BOOK; D. BOOK &x=BOOK; 88. 下列对引用的陈述中不正确的是（ C ）。

A. 每一个引用都是其所引用对象的别名,因此必须初始化 B. 形式上针对引用的操作实际上作用于它所引用的对象

C. 一旦定义了引用，一切针对其所引用对象的操作只能通过该引用间接进行 D. 不需要单独为引用分配存储空间

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

A. delete p; B. delete *p; C. delete &p; D. delete []p; 92. 假定指针变量p定义为“int *p=new int[30];”，要释放p所指向的动态内存，应使用语句（ D ）。

A. delete p; B. delete *p; C. delete &p; D. delete []p; 93. 假定变量x定义为“int x=5;”，要使rx成为x的引用（别名），rx应定义为（ D ）。 A. int rx=x; B. int rx=&x; C. int *rx=&x; D. int &rx=x; 94. 关于消息，下列说法中不正确的是（ B ）。

A. 发送消息的对象请求服务，接受消息的对象提供服务

3

B. 消息的发送者必须了解消息的接收者如何相应消息

C. 在C++中，消息的发送具体体现为对接收消息的对象的某个函数的调用 D. 每个对象只能接收某些特定格式的消息 95. 关于封装，下列说法中不正确的是（ D ）。

A. 通过封装，对象的全部属性和操作结合在一起，形成一个整体 B. 通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见） C. 通过封装，每个对象都成为相对独立的实体 D. 通过封装，对象的属性都是不可见的 96. 面向对象方法的多态性是指（ C ）。 A. 一个类可以派生出多个特殊类

B. 一个对象在不同的运行环境中可以有不同的变体

C. 针对一消息，不同的对象可以以适合自身的方式加以响应 D. 一个对象可以是由多个其他对象组合而成的 97. 软件产品在需求发生变化、运行环境发生变化或发现软件产品本身的错误或不足时进行相应的软件更新的难易程度叫做软件的（ A ）。

A. 可维护性 B. 可复用性 C. 兼容性 D. 正确性

98. 软件产品可被全部或部分地再用于新的应用的能力叫做软件的（ B ）。 A. 可维护性 B. 可复用性 C. 兼容性 D. 正确性

99. 软件产品与其他软件产品组合成一个整体的难易程度叫做软件的（ C ）。 A. 可维护性 B. 可复用性 C. 兼容性 D. 正确性

100. 软件产品准确执行软件需求规格说明书中所规定的任务的能力叫做软件的（ D ）。

A. 可维护性 B. 可复用性 C. 兼容性 D. 正确性 101. 面向对象软件开发中使用的OOA表示（ A ）。 A. 面向对象分析 B. 面向对象设计 C. 面向对象语言 D. 面向对象方法

102. 面向对象软件开发中使用的OOD表示（ B ）。 A. 面向对象分析 B. 面向对象设计 C. 面向对象语言 D. 面向对象方法

103. 关于面向对象系统分析，下列说法中不正确的是（ B ）。 A. 术语“面向对象分析”可以用缩写OOA表示

B. 面向对象分析阶段对问题域的描述比实现阶段更详细 C. 面向对象分析包括问题域分析和应用分析两个步骤 D. 面向对象分析需要识别对象的内部和外部特征 104. 在一个类的定义中，包含有（ C ）成员的定义。

A. 数据 B. 函数 C. 数据和函数 D. 数据或函数 105. 在类作用域中能够通过直接使用该类的（ D ）成员名进行访问。 A. 私有 B. 公用 C. 保护 D. 任何 106. 在关键字public后面定义的成员为类的（ B ）成员。 A. 私有 B. 公用 C. 保护 D. 任何

107. 在关键字private后面定义的成员为类的（ A ）成员。 A. 私有 B. 公用 C. 保护 D. 任何

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

A. x(a) B. x[a] C. x->a D. x.a

4

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

A. x.a B. x.a() C. x->a D. x->a()

110. 假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（ C ）。

A. px(a) B. px[a] C. px->a D. px.a

111. 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ D ）。 A. x.a B. x.a() C. x->GetValue() D. x.GetValue()

112. 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（ A ）。

A. int AA::a() B. int AA:a() C. AA::a() D. AA::int a()

113. 假定AA为一个类，a为该类公有的数据成员，若要在该类的一个成员函数中访问它，则书写格式为（ A ）。

A. a B. AA::a C. a() D. AA::a()

114. 若需要把一个类外定义的成员函数指明为内联函数，则必须把关键字（ B ）放在函数原型或函数头的前面。

A. in B. inline C. inLine D. InLiner

115. 在多文件结构的程序中，通常把类的定义单独存放于（ D ）中。 A. 主文件 B. 实现文件 C. 库文件 D. 头文件

116. 在多文件结构的程序中，通常把类中所有非内联函数的定义单独存放于（ B ）中。

A. 主文件 B. 实现文件 C. 库文件 D. 头文件

117. 在多文件结构的程序中，通常把含有main()函数的文件称为（ A ）。 A. 主文件 B. 实现文件 C. 程序文件 D. 头文件 118. 一个C++程序文件的扩展名为（ C ）。

A. .h B. .c C. .cpp D. .cp

119. 在C++程序中使用的cin标识符是系统类库中定义的（ A ）类中的一个对象。 A. istream B. ostream C. iostream D. fstream

120. 在C++程序中使用的cout标识符是系统类库中定义的（ B ）类中的一个对象。 A. istream B. ostream C. iostream D. fstream

121. 假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数的类型为（ D ）。

A. int B. char C. AA D. AA*

122. 假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数为（ C ）。

A. abc B. *this C. this D. this& 123. 假定AA是一个类，“AA& abc();”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc()调用该成员函数后，x的值（ A ）。 A. 已经被改变 B. 可能被改变

C. 不变 D.不受函数调用的影响

124. 假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（ C ）。 A. 已经被改变 B. 可能被改变

5

C. 不变 D. 受到函数调用的影响 125. 类中定义的成员默认为（ B ）访问属性。

A. public B. private C. protected D. friend 126. 结构中定义的成员默认为（ A ）访问属性。

A. public B. private C. protected D. friend

127. 当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为( C )。

A. n B. n+1 C. n-1 D. n-2

128. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队尾（即最后一个）元素的位置为( C )。 A. length+1 B. first+length

C. (first+length-1)%MS D. (first+length)%MS

129. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队尾的后一个位置为( D )。

A. length+1 B. first+length

C. (first+length-1)%MS D. (first+length)%MS

130. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队首的后一个位置为( B )。 A. first+1 B. (first+1)%MS

C. (first-1)%MS D. (first+length)%MS 131. 在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队非空，则进行插入时必须把新结点的地址赋给( D )。 A. elemHead B. elemTail

C. elemHead->next和elemHead D. elemTail->next和elemTail 132. 在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队为空，则进行插入时必须把新结点的地址赋给( C )。 A. elemHead B. elemTail

C. elemHead和elemTail D. elemHead或elemTail 133. 队列具有（ A ）的操作特性。

A. 先进先出 B. 先进后出 C. 进出无序 D. 进出任意 134. 栈具有（ B ）的操作特性。

A. 先进先出 B. 先进后出 C. 进出无序 D. 进出任意 135. 对于一个类的构造函数，其函数名与类名( A )。

A. 完全相同 B. 基本相同 C. 不相同 D. 无关系 136. 对于一个类的析构函数，其函数名与类名( C )。

A. 完全相同 B. 完全不同 C. 只相差一个字符 D. 无关系 137. 类的构造函数是在定义该类的一个( C )时被自动调用执行的。 A. 成员函数 B. 数据成员 C. 对象 D. 友元函数 138. 类的析构函数是一个对象被( B )时自动调用的。 A. 建立 B. 撤消 C. 赋值 D. 引用 139. 一个类的构造函数通常被定义为该类的( A )成员。 A. 公用 B. 保护 C. 私有 D. 友元 140. 一个类的析构函数通常被定义为该类的( C )成员。

6

A. 私有 B. 保护 C. 公用 D. 友元

141. 假定AB为一个类，则执行 “AB x;”语句时将自动调用该类的( B )。 A. 带参构造函数 B. 无参构造函数 C. 拷贝构造函数 D. 赋值重载函数 142. 假定AB为一个类，则执行 “AB x(a,5);”语句时将自动调用该类的( A )。 A. 带参构造函数 B. 无参构造函数 C. 拷贝构造函数 D. 赋值重载函数 143. 假定AB为一个类，则执行 “AB *s=new AB(a,5);”语句时得到的一个动态对象为( D )。

A. s B. s->a C. s.a D. *s

144. 假定AB为一个类，则执行 “AB r1=r2;”语句时将自动调用该类的( D )。 A. 无参构造函数 B. 带参构造函数 C. 赋值重载函数 D. 拷贝构造函数 145. 若需要使类中的一个指针成员指向一块动态存储空间，则通常在( B )函数中完成。

A. 析构 B. 构造 C. 任一成员 D. 友元

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

A. n B. n+1 C. n-1 D. 1 147. 假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A x(4,5);”语句后，x.a和x.b的值分别为( C )。

A. 4和5 B. 5和4 C. 4和20 D. 20和5

148. 假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 “A x(4);”语句后，x.a和x.b的值分别为( D )。

A. 1和0 B. 1和4 C. 4和1 D. 4和0

149. 假定AB为一个类，则( B )为该类的拷贝构造函数的原型说明。

A. AB(AB x); B. AB(AB& x); C. void AB(AB& x); D. AB(int x); 150. 假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为( C )。 A. 1 B. 2 C. 3 D. 4

151. 假定一个类AB只含有一个整型数据成员a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为( D )。

A. AB() {a=0;} B. AB(int aa=0): a(aa) {} C. AB(int aa): a(aa) {} D. AB() {}

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

A. AB() {} B. AB(): a(0){} C. AB(int aa=0) {a=aa;} D. AB(int aa) {}

153. 对于任一个类，用户所能定义的构造函数的个数至多为( D )。 A. 0 B. 1 C. 2 D. 任意个

154. 对于任一个类，用户所能定义的析构函数的个数至多为( B )。 A. 0 B. 1 C. 2 D. 任意个

155. 假定AB为一个类，则执行 “AB *px=new AB[n];”语句时将( A )。 A. 动态分配一个数组 B. 动态分配一个对象 C. 静态分配一个数组 D. 静态分配一个对象

156. 设px是指向一个类对象的指针变量，则执行 “delete px;”语句时，将自动调用该类的( C )。

A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 拷贝构造函数

7

157. 当一个类对象离开它的作用域时，系统自动调用该类的( D )。

A. 无参构造函数 B. 带参构造函数 C. 拷贝构造函数 D. 析构函数

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

A. 0 B. 1 C. n D. n-1 159. 假定AB为一个类，则执行 “AB a[10];”语句时调用该类无参构造函数的次数为( D )。

A. 0 B. 1 C. 9 D. 10 160. 假定AB为一个类，则执行 “AB *px=new AB[n];”语句时调用该类无参构造函数的次数为( A )。

A. n B. n-1 C. 1 D. 0

161. 假定AB为一个类，则执行 “AB a, b(3), *p;”语句时共调用该类构造函数的次数为( A )。

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

162. 假定AB为一个类，则执行 “AB a(2), b[3], *p[4];”语句时共调用该类构造函数的次数为( B )。

A. 3 B. 4 C. 5 D. 9

163. 假定AB为一个类，则执行“AB a, b(2), c[3], *p=&a;”语句时共调用该类无参构造函数的次数为( D )。

A. 5 B. 6 C. 3 D. 4 164. 假定AB为一个类，则执行“AB *p=new AB(1,2);”语句时共调用该类构造函数的次数为( B )。

A. 0 B. 1 C. 2 D. 3

165. 假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为( C )。 A. 0 B. 1 C. n D. n+1

166. 对类对象成员的初始化是通过构造函数中给出的( B )实现的。

A. 函数体 B. 初始化表 C. 参数表 D. 初始化表或函数体 167. 对类中常量成员的初始化是通过构造函数中给出的( C )实现的。

A. 函数体 B. 参数表 C. 初始化表 D. 初始化表或函数体 168. 对类中引用成员的初始化是通过构造函数中给出的( C )实现的。

A. 函数体 B. 参数表 C. 初始化表 D. 初始化表或函数体 169. 类的构造函数可以带有( D )个参数。 A. 0 B. 1 C. 2 D. 任意 170. 类的析构函数可以带有( A )个参数。 A. 0 B. 1 C. 2 D. 任意 171. 一个类的静态数据成员所表示属性 ( C )。

A. 是类的或对象的属性 B. 只是对象的属性 C. 只是类的属性 D. 类和友元的属性 172. 类的静态成员的访问控制（ D ）。 A. 只允许被定义为private

B. 只允许被定义为private或protected C. 只允许被定义为public

D. 可允许被定义为private、protected或public 173. 静态成员函数对类的数据成员访问（ B ）。

8

A. 是不允许的 B. 只允许是静态数据成员

C. 只允许是非静态数据成员 D. 可允许是静态数据成员或非静态数据成员 174. 被非静态成员函数访问的类的数据成员( A )。

A. 可以是非静态数据成员或静态数据成员 B. 不可能是类的静态数据成员 C. 只能是类的非静态数据成员 D. 只能是类的静态数据成员 175. 静态数据成员的初始化是在（ D ）中进行的。 A. 构造函数 B. 任何成员函数 C. 所属类 D. 全局区

176. 当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的（ D ）。

A. 只能是公有成员 B. 只能是保护成员 C. 只能是除私有成员之外的任何成员 D. 具有任何权限的成员 177. 引入友元的主要目的是为了（ C ）。

A. 增强数据安全性 B. 提高程序的可靠性 C. 提高程序的效率和灵活性 D. 保证类的封装性

178. 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（ A ）。 A. 需加上类域的限定 B. 不需加上类域的限定 C. 类域的限定可加可不加 D. 不需要任何限定

179. 一个类的友元不是该类的成员，与该类的关系密切，所以它（ D ）。 A. 有this指针，有默认操作的对象 B. 没有this指针，可以有默认操作的对象 C. 有this指针，不能执行默认操作

D. 没有this指针，也就没有默认操作的对象

180. 在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（ B ）。 A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符 C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符 181. 在成员函数中进行双目运算符重载时，其参数表中应带有（ B ）个参数。 A. 0 B. 1 C. 2 D. 3

182. 双目运算符重载为普通函数时，其参数表中应带有（ C ）个参数。 A. 0 B. 1 C. 2 D. 3

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

A. a.operator+(b) B. b.operator+(a) C. operator+(a,b) D. operator(a+b)

184. 如果表达式a==b中的“==”是作为普通函数重载的运算符，若采用运算符函数调用格式，则可表示为（ C ）。

A. a.operator==(b) B. b.operator==(a) C. operator==(a,b) D. operator==(b,a)

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

A. a.operator++() B. operator++(a) C. operator++(a,1) D. operator++(1,a)

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

A. a.operator++(1) B. operator++(a)

9

C. operator++(a,1) D. a.operator++() 187. 关于运算符重载，下列说法正确的是（ C ）。 A. 重载时，运算符的优先级可以改变。 B. 重载时，运算符的结合性可以改变。 C. 重载时，运算符的功能可以改变。

D. 重载时，运算符的操作数个数可以改变。 188. 关于运算符重载，下列说法正确的是（ B ）。 A. 所有的运算符都可以重载。

B. 通过重载，可以使运算符应用于自定义的数据类型。 C. 通过重载，可以创造原来没有的运算符。 D. 通过重载，可以改变运算符的优先级。

189. 一个程序中数组a和变量k定义为“int a[5][10],k;”，且程序中包含有语句“a(2,5)=++k*3;”，则此语句中肯定属于重载操作符的是（ A ）。 A. ( ) B. = C. ++ D. *

190. 假定K是一个类名，并有定义“K k; int j;”，已知K中重载了操作符 ( )，且语句“j=k(3);”和“k(5)=99;”都能顺利执行，说明该操作符函数的原形只可能是（ C ）。 A. K operator ( ) (int); B. int operator ( )(int&); C. int & operator ( )(int); D. K &operator( )(int);

191. 假定M是一个类名，且M中重载了操作符=，可以实现M对象间的连续赋值，如“m1=m2=m3;”。重载操作符=的函数原型最好是（ D ）。

A. int operaotor=(M); B. int operator=(M&); C. M operator=(M&); D. M& operator=(M);

192. 下面是重载双目运算符+的普通函数原形，其中最符合+原来含义的是（ A ）。 A. Value operator+(Value, Value); B. Value operator+(Value,int);

C. Value &operator+(Value, Value); D. Value &operator+(Value&, Value&); 193. 下面是重载双目运算符-的成员函数原形，其中最符合-原来含义的是（ A ）。 A. Value Value::operator-(Value); B. Value Value::operator-(int); C. Value& Value::operator-(Value); D. Value& Value::operator-(Value&); 194. 在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（ D ）。 A. 该运算符是一个单目运算符。 B. 该运算符函数有一个隐含的参数this。 C. 该运算符函数是类的成员函数。 D. 该运算符函数是类的友元函数。

195. 关于插入运算符<<的重载，下列说法不正确的是（ B ）。 A. 运算符函数的返回值类型是ostream & 。 B. 重载的运算符必须定义为类的成员函数。

C. 运算符函数的第一个参数的类型是ostream & 。 D. 运算符函数有两个参数。

196. 从一个基类派生出的各个类的对象之间( C )。

A. 共享所有数据成员，每个对象还包含基类的所有属性 B. 共享部分数据成员，每个对象还包含基类的所有属性

C. 不共享任何数据成员，但每个对象还包含基类的所有属性 D. 共享部分数据成员和函数成员

10

197. 如果是类B在类A的基础上构造，那么，就称（ B ）。 A. 类A为基类或父类，类B为超类或子类

B. 类A为基类、父类或超类，类B为派生类或子类 C. 类A为派生类，类B为基类

D. 类A为派生类或子类，类B为基类、父类或超类 198. C++的继承性允许派生类继承基类的（ C ）。

A. 部分特性，并允许增加新的特性或重定义基类的特性 B. 部分特性，但不允许增加新的特性或重定义基类的特性 C. 所有特性，并允许增加新的特性或重定义基类的特性 D. 所有特性，但不允许增加新的特性或重定义基类的特性 199. 派生类的成员函数可以直接访问基类的（ B ）成员。

A. 所有 B. 公有和保护 C. 保护和私有 D. 私有 200. 对于公有继承，基类的公有和保护成员在派生类中将( D )成员。 A. 全部变成公有 B. 全部变成保护

C. 全部变成私有 D. 仍然相应保持为公有和保护 201. 对于公有继承，基类中的私有成员在派生类中将 ( C )。

A. 能够直接使用成员名访问 B. 能够通过成员运算符访问 C. 仍然是基类的私有成员 D. 变为派生类的私有成员

202. 当保护继承时，基类的（ B ）在派生类中成为保护成员，在类作用域外不能够通过派生类的对象来直接访问该成员。

A. 任何成员 B.公有成员和保护成员 C. 保护成员和私有成员 D.私有成员

203. 在定义一个派生类时，若不使用保留字显式地规定采用何种继承方式，则默认为（ A ）方式。

A. 私有继承 B. 非私有继承 C. 保护继承 D. 公有继承

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

A. 自己所属类、对象成员所属类、基类 B. 对象成员所属类、基类、自己所属类 C. 基类、对象成员所属类、自己所属类 D. 基类、自己所属类、对象成员所属类

205. 当派生类中有和基类一样名字的成员时，一般来说，（ B ）。

A. 将产生二义性 B. 派生类的同名成员将覆盖基类的成员 C. 是不能允许的 D. 基类的同名成员将覆盖派生类的成员 206. C++中的虚基类机制可以保证：（ D ）。 A. 限定基类只通过一条路径派生出派生类

B. 允许基类通过多条路径派生出派生类，派生类也就能多次继承该基类

C. 当一个类多次间接从基类派生以后，派生类对象能保留多份间接基类的成员 D. 当一个类多次间接从基类派生以后，其基类只被一次继承 207. 下列对派生类的描述中错误的说法是：（ D ）。 A. 派生类至少有一个基类

B. 派生类可作为另一个派生类的基类

C. 派生类除了包含它直接定义的成员外，还包含其基类的成员 D. 派生类所继承的基类成员的访问权限保持不变

11

208. 派生类的对象对其基类中（ A ）可直接访问。 A. 公有继承的公有成员 B. 公有继承的私有成员 C. 公有继承的保护成员 D. 私有继承的公有成员

二、判断题

1．C++中标识符内的大小写字母是没有区别的。（F ） 2．C++是一种以编译方式实现的高级语言。（T ）

3．计算函数参数顺序引起的二义性是由不同的编译系统决定的。（T ） 4．返回值类型、参数个数和类型都相同的函数也可以重载。（F ）

5．使用关键字class定义的类中缺省的访问权限是私有（private）的。（T ）

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

7．多继承情况下，派生类的构造函数的执行顺序取决于成员初始化列表中的顺序。（F ） 8．在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。（F ） 9．在私有继承中，基类中所有成员对派生类都是不可见的。（F ）

10．在保护继承中，对于垂直访问等同于公有继承，对于水平访问等同于私有继承。（T ） 11．构造函数可以声明为虚函数。（F ）

12．在析构函数中调用虚函数时，采用动态束定。（F ）

13．在一个成员函数内调用一个虚函数时，对该虚函数的调用进行动态束定。（T ） 14．公有继承可以实现子类型。（T ） 15．构造函数可以声明为纯虚函数。（F ）

16.说明函数原型时不需要指明每个函数参数的名字，只需要说明每个参数的类型和返回值类型就可以了。对

17.所有的表达式都有值。错

18.程序的编译是以文件为单位的，因此将程序分到多个文件中可以减少每次对程序修改所

带来的编译工作量。对

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

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

其它的函数访问。错

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

的所有成员。对

22.当函数的返回值是数组类型的，传递的是数组第一个元素的地址。错

23.如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同，那么，这

个函数自动继承基类中虚函数的特性。对

24.字符串’hello,world”在内存中存放时，占用11个字节的空间。错

12

25.用new动态申请的内存空间，必须用delete来释放 。对 26.静态数据成员必须在类外定义和初始化。（ √ ）

27.保护继承时，派生类中的成员函数可以直接访问基类中的protected成员。（√ ） 28.静态成员函数可以引用属于该类的任何函数成员。（ × ） 29.指针常量可以指向相应类型的常量。（√ ）

30.友元函数是在类声明中由关键字friend修饰说明的类的成员函数。（ × ） 31.如果程序中未声明构造函数，则系统自动产生出一个默认形式的构造函数。（ √ ） 32.友元函数访问对象中的成员可以不通过对象名（ × ）

33.如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。（√ ） 34.类中的成员数据可以是另一个类的对象。（ √ ） 35.常引用做形参，在函数中不能更新所引用的对象。（√） 36.虚函数不能是类的静态成员。对

37.重定义虚函数的派生类必须是公有继承的。对

38.对于从基类继承的虚函数，派生类也可以不进行重定义。对 39.纯虚函数与函数体为空的虚函数等价。错 40.多态类提供了一种动态多分支派送机制。对

41.作为虚函数隐含参数的this指针，决定了虚函数调用时执行的代码。对

三、填空题

1. C++语言是在_________语言的基础上发展起来的。

2. C++语言的编译单位是扩展名为__________的__________文件。 5. 用于输出表达式值的标准输出流对象是_________。

6. 用于从键盘上为变量输入值的标准输入流对象是________。 8. 一个函数的函数体就是一条_________语句。 9. 当执行cin语句时，从键盘上输入每个数据后必须接着输入一个________符，然后才能继续输入下一个数据。

10. 在C++程序中包含一个头文件或程序文件的预编译命令为__________。

13. 在#include命令中所包含的头文件，可以是系统定义的头文件，也可以是________定义的头文件。

14. 使用#include命令可以包含一个头文件，也可以包含一个______文件。 17．C++头文件和源程序文件的扩展名分别为______和______。 18．程序文件的编译错误分为________和________两类。

22. 当执行cout语句输出endl数据项时，将使C++显示输出屏幕上的光标从当前位置移动到________的开始位置。

38. 在C++中存储字符串”abcdef”至少需要________个字节。 39. 在C++中存储字符串”a+b=c”至少需要________个字节。

52. 设enum Printstatus{ready,busy,error}; 则 cout<

13

53. 设enum Printstatus{ready=2,busy,error}; 则cout<

55. 枚举类型中的每个枚举值都是一个__________，它的值为一个__________。 87. 在C++语言中，一个函数由函数头和__________组成。

88. 重载一个函数的条件是：该函数必须在参数的个数或参数的__________上与其它同名函数有所不同。

89. 如果一个函数只允许同一程序中的函数调用，则应在该函数定义前加上__________C++保留字。

90. 若“double x=100;”是文件F1.CPP中的一个全局变量定义语句，若文件F2.CPP中的某个函数需要访问此x , 则应在文件F2.CPP中添加对x的声明语句为_________________。

91. 定义一个函数模板要用到的第一个修饰符是____________。

92. 在函数模板的参数中，用class修饰的参数称为__________参数。

93. 如果一个函数直接或间接地调用自身，这样的调用称为____________调用。 94. 已知int cubin(int n){return n*n*n;} 和double cubin(double n){return n*n*n;} 是一个函数模板的两个实例，假定类型参数用T表示，则该函数模板的定义是__________________________________。

96. 如果一个函数定义中使用了__________修饰，则该函数不允许被其它文件中的函数调用。

97. 如果一个函数中有多个默认参数，则默认参数必须全部处在形参表的________部分。

98. 定义外部变量时，不用存储类说明符_________，而声明外部变量时用它。

99．调用系统函数时，要先使用#include命令包含该系统函数的原型语句所在的__________。

100. 函数形参的作用域是该函数的____________。

101. C++提供的预处理命令有宏定义命令，条件编译命令和____________。

103. C++程序运行时的内存空间可以分成全局数据区，堆区，栈区和__________。 104. 全局变量和静态局部变量具有静态生存期，存放在内存的____________区中。 105. 局部变量具有局部生存期，存放在内存的____________区中。

135. 执行int p=new int操作得到的一个动态分配的整型对象为________。

136. 执行int *p=new int[10]操作，使p指向动态分配的数组中下标为0的元素，该元素可表示为_______或________。

137. 执行char *p=new char(’a’)操作后，p所指向的数据对象的值为________。 138. 执行new char[m][n]操作时的返回值的类型为________。 139. 执行________操作将释放由p所指向的动态分配的数据空间。 140. 执行________操作将释放由p所指向的动态分配的数组空间。

141. NULL是一个符号常量，通常作为空指针值，它的具体值为________。 153. 以面向对象方法构造的系统，其基本单位是__________。 154. 每个对象都是所属类的一个__________。

155. 对象将其大部分实现细节隐藏起来，这种机制称为__________。 156. 基类和派生类的关系称为__________。

157. 复杂对象可以由简单对象构成，这种现象称为__________。

158. 对象是对问题域中客观事物的________，它是一组属性和在这些属性上操作的__________。

159. 特殊类的对象拥有其一般类的全部属性与操作，称特殊类________了一般类。

14

160. 如果一个派生类的基类不止一个，则这种继承称为____________。

161. 如果一个派生类只有一个唯一的基类，则这样的继承关系称为__________。 162. C++支持两种多态性：_________时的多态性和__________时的多态性。

163. 在C++中，编译时的多态性是通过__________实现的，而运行时的多态性则是通过__________实现的。

164. 面向对象软件开发的生命周期分为三个阶段，即分析、__________和__________。 165. 面向对象的分析包括__________分析和__________分析两步。 166. 类定义中，既包含数据成员，也包含________成员。 167. 类中的数据成员的访问属性通常被指明为________。

168. 类中的供外部调用定义的函数成员，其访问属性通常被定义为________。 169. 对于类中定义的任何成员，其隐含访问权限为________。 170. 对于结构中定义的任何成员，其隐含访问权限为________。 171. 为了使类中的成员不能被类外的函数通过成员操作符访问，则应把该成员的访问权限定义为________。

172. 若在类的定义体中给出了一个成员函数的完整定义，则该函数属于________函数。

173. 若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上________和两个冒号分隔符。

174. 若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上类名和两个________分隔符。

175. 若要把类外定义的成员函数规定为内联函数，则必须把________关键字放到函数原型或函数头的前面。

176. 把一个类的定义体和所有成员函数的定义体所构成的程序范围叫做该类的____________。

177. 假定AA是一个类，“AA* abc();”是该类中一个成员函数的原型，则在类外定义时的函数头为__________________。

178. 成员函数的参数表在类作用域中，成员函数的返回值类型________类作用域中。 179. 为了避免在调用成员函数时修改对象中的任何数据成员，则应在定义该成员函数时，在函数头的后面加上________关键字。

180. 若只需要通过一个成员函数读取数据成员的值，而不需要修改它，则应在函数头的后面加上________关键字。

181. 若采用x.abc(y)表达式调用一个成员函数，在成员函数中使用的________就代表了类外的x对象。

182. 若采用p->abc(y)表达式调用一个成员函数，在成员函数中使用的________就代表了类外的p指针。

183. 内联函数的定义模块与________模块必须放在同一个文件中。

184．假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，在该函数体中（能够/不能够）__________向*this或其成员赋值。

185．在一个用数组实现的队列类中，包含有两个数据成员，一个指明队首元素位置，另一个指明____________。

186. 在一个用数组实现的队列类中，包含有两个数据成员，一个指明队列长度，另一个指明__________元素的位置。

187. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则插入一个新元素的位置为__________。

188. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队

15

列长度为length，则删除一个元素后队首的位置为__________。

189. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队列为空的条件为__________。

190. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队列为满的条件为__________。

191. 当一个队列为空时，不能对其做________元素的操作。 192. 当一个队列为满时，不能对其做________元素的操作。 193．从一个队列中删除元素就是删除________位置上的元素。

194．向一个队列中插入元素就是把该元素放到________元素的后一位置上。

195．在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，当链队非空时，_____________指向队首结点的后继（即下一个）结点。

196. 在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，当链队非空时，新插入结点的地址应当赋给___________所指结点的next域。

197. 在一个用链表实现的队列类中，队尾结点的指针域的值为________。 198. 在一个用链表实现的队列类中，若链队中只含有一个结点，则队首指针的值与队尾指针的值________。

199. 在一个用链表实现的队列类中，若链队为空或只含有一个结点，则队首指针的值与队尾指针的值________。

200. 在一个用链表实现的队列类中，若队首指针与队尾指针的值不同，则说明链队中至少包含有________个结点。

201．一个类的__________函数实现对该类对象的初始化功能。

202．一个类的__________函数通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。

203．当用户为一个类定义有____________时，则系统不会为该类再自动生成一个默认构造函数。

204．假定用户没有给一个名为AB的类定义构造函数，则系统为其定义的构造函数为__________。

205．假定用户没有给一个名为AB的类定义析构函数，则系统为其定义的析构函数为__________。

206．定义类动态对象数组时，其元素只能靠自动调用该类的____________来进行初始化。

207．在一个类中定义拷贝构造函数的目的，是为了当利用该类的一个对象初始化另一个对象时，能够避免这两个对象的同一指针同时指向同一块__________________。

208．为了释放类对象中指针成员所指向的动态存储空间，则需要为该类定义____________。

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

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

211．对类中对象成员的初始化是通过在构造函数中给出的______________来实现的。 212．对类中常量成员的初始化是通过在构造函数中给出的______________来实现的。 213．对类中引用成员的初始化只能通过在构造函数中给出的______________来实现。 214．对类中一般数据成员的初始化既可以通过在构造函数中给出的初始化表来实现，

16

也可以通过构造函数中的____________来实现。

215. 假定要把aa定义为AB类中的一个常量整数型数据成员，则定义语句为____________。

216. 假定要把aa定义为AB类中的一个引用整数型数据成员，则定义语句为____________。

217. 假定AB类中只包含一个整型数据成员a，并且它是一个常量成员，若利用参数aa对其进行初始化，则该类的构造函数的定义为____________________。

218. 假定AB类中只包含一个整型数据成员a，并且它是一个引用成员，若利用引用参数aa对其进行初始化，则该类的构造函数的定义为____________________。

219．假定指针p指向一个动态分配的类对象，则当执行“delete p;”语句时，在释放p所指向的动态存储空间之前将自动调用该类的____________。

220．假定用户为类AB定义了一个构造函数“AB(int aa) {a=aa;}”，则系统（会/不会）_________为该类自动定义一个无参构造函数\{}\。

221. 假定用户为类AB定义了一个构造函数“AB(int aa, char *bb=NULL):a(aa),b(bb){}”，则该类中至少包含有__________个数据成员。

222．假定用户为类AB定义了一个构造函数“AB(int aa) {a=aa;}”，该构造函数实现对数据成员_________的初始化。

223．假定用户为类AB定义了一个构造函数“AB(int aa=0):a(aa){}”，则定义该类的对象时，可以有________种不同的定义格式。

224．假定用户为类AB定义了一个构造函数“AB(int aa):a(aa){}”，则定义该类的对象时，有________种定义格式。

225．假定用户只为类AB定义了一个构造函数“AB(int aa, int bb=0) {a=aa; b=bb;}”，则定义该类的对象时，其实参表中至多带有_________个实参。

226．假定用户只为类AB定义了一个构造函数“AB(int aa, int bb=0) {a=aa; b=bb;}”，则定义该类的对象时，其实参表中至少带有_________个实参。

227．假定用户为类AB定义了一个构造函数“AB(int aa=0, int bb=0) {a=aa; b=bb;}”，则定义该类的对象时，可以有________种不同的定义格式。

228．假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则定义该类对象x的定义语句“AB x();”是_________(正确/错误)的。

229．假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则定义该类对象x的定义语句“AB x;”是_________(正确/错误)的。

230．假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则定义该类对象x的定义语句“AB x(5);”是_________(正确/错误)的。

231．假定AB为一个类，则类定义体中的“AB(AB x);”语句为该类______________的原型语句。

232．假定AB为一个类，则该类的拷贝构造函数的函数头为_____________。

233．假定AB为一个类，该类中含有一个指向动态数组空间的指针成员pa，则在该类的析构函数中应该包含有一条______________语句。

234. 静态成员函数____访问类的静态数据成员， ____访问类的非静态数据成员。 235. 静态数据成员必须在所有函数的定义体外进行__________。 236. 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明必须在函数

17

名前加上__________的限定。

237. 重载运算符时，该运算符的__________、结合性以及操作符的个数不允许改变。 238. 一个单目运算符作为类的成员函数重载时有________个参数；如果作为独立函数重载，则有________个参数。

239. 一个双单目运算符作为类的成员函数重载时有________个参数；如果作为独立函数重载，则有________个参数。

240. 除了__________运算符外，其他重载的运算符都可以被派生类继承。 241. 作为类的成员函数重载一个运算符时，参数表中只有一个参数，说明该运算符有________个操作数。

242. 在重载一个单目运算符时，参数表中没有参数，说明该运算符函数只能是类的_____________。

243. 重载插入运算符<<时，其运算符函数的返回值类型应当是____________。 244. 重载抽取运算符>>时，其运算符函数的返回值类型应当是____________。 245. 重载插入运算符<<或抽取运算符>>时，其运算符函数的参数有________个。 246. 重载插入运算符<<或抽取运算符>>时，其运算符函数不能被定义为类的________函数。

247. 类型转换函数没有____________类型，而且参数表为____________。 248. 在一个或若干个类的基础上构造一个新类，被称为___________。

249. 派生类的成员函数可以直接访问基类的__________成员，不能直接访问基类的 ______成员。

250. 当保护继承时，基类的__________成员在派生类中成为保护成员，派生类对象不能直接访问基类的__________成员。

251. 在定义一个派生类时，使用__________关键字或者不显式地使用它则表示为__________继承。

252. 若多个基类及其派生类中都定义了同名函数成员，要访问相应函数时，就需要在函数名前加上______和类区分符。

253. 若要保证一个公共的基类在派生类中只产生一个基类子对象，则必须都以____________的方式直接继承它。

254. 引进虚基类的根本目的是为了消除____________。

255. 在每个成员函数中，隐含的第一个参数的参数名为________。

四、程序填充

21. 已知一维数组类ARRAY的定义如下，ARRAY与普通一维数组区别是：其重载的运算符[ ]要对下标是否越界进行检查。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator[](int n);

18

};

___(1)___ operator[](int n) //[ ]的运算符成员函数定义 {

if(n<0 || ___(2)___) {cerr<<\下标越界！\ return ___(3)___; }

(1) (2) (3)

22. 已知一维数组类ARRAY的定义如下，构造函数的作用是把参数n的值赋给s，给v动态分配长度为n的数组空间，接着利用数组参数a初始化v所指向的数组。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator[](int n); };

___(1)___ ARRAY(int a[], int n) {

if(n<=0) {v=NULL;s=0;return;} s=n;

v=___(2)___;

for(int i=0; i

(1) (2) (3)

23. 下面是一维数组类ARRAY的定义，ARRAY与普通一维数组区别是：(a)用()而不是[]进行下标访问，(2)下标从1而不是从0开始，(c)要对下标是否越界进行检查。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator()(int n); }; ___(1)___ operator()(int n) { // ()的运算符函数定义

if(___(2)___) {cerr<<\下标越界！\ return ___(3)___; }

19

(1) (2) (3)

24. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素 //进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 };

该类中MaxA()函数的实现如下，请在标号位置补充适当的内容。 int ____(1)_____ {

int x=a[0];

for(int i=1; ix) ___(2)___; ___(3)___; }

(1) (2) (3)

25. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a， //用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素 //进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序 void PrintA(); //依次输出数组a中的前n个元素 };

20

#include class A {

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1);

___(1)___; //由a指向长度为MaxLen的动态数组 for(int i=0; i

~A() {delete []a;}

int GetValue(int i) ___(2)___ //函数体返回a[i]的值 };

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10); int i,s=0;

for(i=0; i<10; i++); ___(3)___ //把r对象的a数据成员中的每个 //元素值依次累加到s中 cout<<\ }

(1) (2) (3)

36. #include #include class A {

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1); a=new int[MaxLen];

___(1)___; //以i为循环变量把aa数组中每个元素值 //传送给a数组的对应元素中 } ~A();

int GetValue(int i) {return a[i];} //函数体返回a[i]的值

};

26

___(2)___ //析构函数的类外定义

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10); int i,s=0;

___(3)___ ; //以i为循环变量，把r对象的a数据成员中的 //每个元素值依次累加到s中 cout<<\ }

(1) (2) (3)

37. 一种类定义如下: class Goods {

private:

char gd_name[20]; //商品名称 int weight; //商品重量

static int totalweight; //同类商品总重量 public:

Goods (char*str,int w){ //构造函数 strcpy(gd_name,str); weight=w;

totalweight+=weight; }

~ Goods (){totalweight -= weight;}

char* GetN(){___(1)___;} //返回商品名称 int GetW(){return weight;}

___(2)___ GetTotal_Weight() { //定义静态成员函数返回总重量 ___(3)___; } }

(1) (2) (3)

38. class Point {

private: int x, y; public:

Point(){x=y=0;}

Point(int x0,int y0) {x=x0;y=y0;}

27

int GetX() { return x; } int GetY() { return y; }

void Print(){cout<<\ ___(1)___; //友元函数声明 ___(2)___; //友元函数声明 };

Point operator+(Point& pt,int dd)

//加号操作符重载函数，实现Point类对象与整数加法 {

Point temp=pt; temp.x+=dd; temp.y+=dd; return temp; }

Point operator+(Point& pt1,Point& pt2)

//加号操作符重载函数，实现两个Point类对象的加法 {

Point temp=pt1; temp.x+=pt2.x; ___(3)___; return temp; }

(1) (2) (3)

39. 在下面一段类定义中， Derived类是由直接基类Base 1和Base 2所派生的，Derived类包含有两个间接基类BaseBase，在初始化函数Init中，需要把x1和x2的值分别赋给属于基类Base1的x成员和属于基类Base2的x成员。 class BaseBase { protected: int x; public:

BaseBase(){ x = 1;} };

class Base1: public BaseBase { public: Base1(){} };

class Base2: public BaseBase { public: Base2(){}

28

};

class Derived: ___(1)___ {

public:

Derived() {}

void Init(int x1, int x2) { ___(2)___; ___(3)___; }

void output() {cout<

(1) (2) (3)

40. 在下面一段类定义中， Derived类公有继承了基类Base。需要填充的函数由注释内容给出了功能。 class Base {

private:

int mem1,mem2; //基类的数据成员 public:

Base(int m1,int m2) { mem1=m1; mem2=m2; }

void output(){cout<

class Derived: public Base {

private:

int mem3; //派生类本身的数据成员 public:

//构造函数,由m1和m2分别初始化mem1和mem2，由m3初始化mem3 Derived(int m1,int m2, int m3); //输出mem1,mem2和mem3数据成员的值 void output(){

___(1)___; cout<

Derived::Derived(int m1,int m2, int m3): ___(2)___ {___(3)___;}

29

(1) (2) (3)

41. 在下面一段类的定义中，需要填充的函数由注释内容给出了功能。 class Point //定义坐标点类 {

public:

int x,y; //点的横坐标和纵坐标 Point(){x=0;y=0;}

Point(int x0,int y0) {x=x0; y=y0;} int X(){return x;} int Y(){return y;}

void PrintP(){cout<<\};

class Line: public Point //利用坐标点类定义直线类 {

private:

class Point pt1,pt2; //直线的两个端点 public:

Line(Point pts, Point pte); //构造函数，分别用参数初始化对应的端点 double Dx(){return pt2.x-pt1.x;} double Dy(){return pt2.y-pt1.y;} double Length(){ //计算直线的长度 return sqrt(___(1)___); };

void PrintL(); //输出直线的两个端点和直线长度 };

Line::Line(Point pts, Point pte) ___(2)___ void Line::PrintL() {

cout<<\ pt1.PrintP(); cout<<\ pt2.PrintP();

cout<<\}

(1) (2) (3)

42. 在下面一段类的定义中，自行车类的虚基类为车辆类，机动车类的虚基类也为车辆类，摩托车类的基类为自行车类和机动车类，类之间均为公有继承。 class vehicle //车辆类

30

{

private:

int MaxSpeed; //最大车速 int Weight; //车重 public:

vehicle(){MaxSpeed=0; Weight=0;};

virtual void Run() {cout<<\};

class bicycle : ___(1)___ //自行车类 {

private:

int Height; //车高 public:

bicycle(){};

void Run() {cout<<\};

class motorcar : ___(2)___ //机动车类 {

private:

int SeatNum; //乘人数 public:

motorcar(){};

void Run() {cout << \};

class motorcycle: ___(3)___ //摩托车类 {

public:

motorcycle (){};

void Run() {cout<<\};

(1) (2) (3)

五、读程序写出运行结果

28. #include #include class CD { char* a; int b;

31

public:

void Init(char* aa, int bb) {

a=new char[strlen(aa)+1]; strcpy(a,aa); b=bb; }

char* Geta() {return a;} int Getb() {return b;}

void Output() {cout<

CD dy;

dx.Init(\

dy.Init(\ dx.Output(); dy.Output(); }

29．#include #include class CD { char* a; int b; public:

void Init(char* aa, int bb) {

a=new char[strlen(aa)+1]; strcpy(a,aa); b=bb; }

char* Geta() {return a;} int Getb() {return b;}

void Output() {cout<

CD dx,dy; char a[20];

dx.Init(\ strcpy(a,dx.Geta()); strcat(a,\

dy.Init(a,dx.Getb()+20);

32

dx.Output(); dy.Output(); }

30. #include class CE { private: int a,b;

int getmax() {return (a>b? a:b);} public: int c;

void SetValue(int x1,int x2, int x3) { a=x1; b=x2; c=x3; }

int GetMax(); };

int CE::GetMax() { int d=getmax(); return (d>c? d:c); }

void main() {

int x=5,y=12,z=8; CE ex, *ep=&ex; ex.SetValue(x,y,z);

cout<SetValue(x+y,y-z,20); cout<GetMax()<

31. #include class CE { private: int a,b;

int getmin() {return (a

void SetValue(int x1,int x2, int x3) { a=x1; b=x2; c=x3; }

int GetMin(); };

int CE::GetMin() { int d=getmin();

33

return (d

void main() {

int x=5,y=12,z=8; CE *ep; ep=new CE;

ep->SetValue(x+y,y-z,10); cout<GetMin()<

cout<

32. #include

class Franction { //定义分数类 int nume; //定义分子 int deno; //定义分母 public:

//把*this化简为最简分数，具体定义在另外文件中实现 void FranSimp();

//返回两个分数*this和x之和，具体定义在另外文件中实现 Franction FranAdd(const Franction& x); //置分数的分子和分母分别0和1

void InitFranction() {nume=0; deno=1;} //置分数的分子和分母分别n和d

void InitFranction(int n, int d) {nume=n; deno=d;} //输出一个分数

void FranOutput() {cout<

void main() {

Franction a,b,c,d; a.InitFranction(7,12); b.InitFranction(-3,8); c.InitFranction(); c=a.FranAdd(b); d=c.FranAdd(a);

cout<<\ cout<<\ cout<<\ cout<<\ }

33. #include

34

class Franction { //定义分数类 int nume; //定义分子 int deno; //定义分母 public:

//把*this化简为最简分数，具体定义在另外文件中实现 void FranSimp();

//返回两个分数*this和x之和，具体定义在另外文件中实现 Franction FranAdd(const Franction& x); //置分数的分子和分母分别0和1

void InitFranction() {nume=0; deno=1;} //置分数的分子和分母分别n和d

void InitFranction(int n, int d) {nume=n; deno=d;} //输出一个分数

void FranOutput() {cout<

void main() {

Franction a,b,c,d; a.InitFranction(6,15); b.InitFranction(3,10); c.InitFranction(); c=a.FranAdd(b); d=c.FranAdd(a);

cout<<\ cout<<\ cout<<\ cout<<\ }

34.

#include #include class A { char *a; public:

A(char *s) {

a=new char[strlen(s)+1]; strcpy(a,s); cout<

~A() {

delete []a;

cout<<\ }

35

}

43.

#include class Date {

public:

Date(int y=2001,int m=1,int d=1){Year=y; Month=m; Day=d;} void PrintDate(){ cout<

int Year,Month,Day; };

class Time {

public:

Time(int h=5,int m=30,int s=0){Houre=h; Minutes=m; Seconds=s;} void PrintTime(){ cout<

int Houre, Minutes, Seconds; };

class Date_Time: public Date, public Time {

public:

Date_Time( ){};

Date_Time(int y,int mo,int d,int h=0,int mi=0,int s=0): Date(y,mo,d), Time(h,mi,s){}

void PrintDate_Time(){PrintDate();PrintTime();} };

void main( ) {

Date_Time a, b(2002,10,1,6,20,0), c(2003,3,8,6,7); a.PrintDate_Time(); b.PrintDate_Time(); c.PrintDate_Time(); }

44.

//*********************test.h********************// #include class Base {

public:

Base (int i,int j){ x0=i; y0=j;}

void Move(int x,int y){ x0+=x; y0+=y;}

41

void Show(){ cout<<\ private: int x0,y0; };

class Derived: private Base {

public:

Derived(int i,int j,int m,int n):Base(i,j){ x=m; y=n;} void Show (){cout<<\ void Move1(){Move(2,3);} void Show1(){Base::Show();} private: int x,y; };

//**************************test.cpp************************// #include \void main( ) {

Base b(1,2); b.Show();

Derived d(3,4,10,15); d.Move1(); d.Show(); d.Show1(); }

45.

/************* test.h ***********************/ #include class Point {

public:

void InitP(float x0=0, float y0=0) {X=x0;Y=y0;} void Move(float xf, float yf) {X+=xf;Y+=yf;} float GetX() {return X;} float GetY() {return Y;} private: float X,Y; };

class Rectangle: public Point {

public:

void InitR(float x, float y, float w, float h) { InitP(x,y);W=w;H=h;

42

}

void ZoomR(float k){W*=k,H*=k;} float GetH() {return H;} float GetW() {return W;} private: float W,H; };

//**************************test.cpp************************// #include \void main() {

Rectangle rect;

rect.InitR(10,20,30,40);

cout<

cout<

cout<

46.

//*********************test.h********************// #include class Base {

public:

virtual void Set(int b){x=b;} virtual int Get(){ return x;} private: int x; };

class Derived: public Base {

public:

void Set(int d){y = d;} int Get(){return y;} private: int y; };

//**************************test.cpp************************// #include \

43

void main( ) {

Base B_obj; Derived D_obj; Base *p=&B_obj; p->Set(100);

cout<<\ p=&D_obj; p->Set(200);

cout<<\ p->Base::Set(300);

cout<<\ p->Set(p->Get()+200);

cout<<\}

六、指出以下程序或函数的功能 17. int f8(const char* str1, const char* str2) {

int i=0;

while(str1[i] && str2[i]) if(str1[i]==str2[i]) i++;

else if(str1[i]>str2[i]) return 1; else return -1;

if(str1[i]==str2[i]) return 0; else if(str1[i]>str2[i]) return 1; else return -1; }

18. IntNode* FindMax(IntNode *f) {

if(!f) return NULL; IntNode *p=f; f=f->next; while(f) {

if(f->data > p->data) p=f; f=f->next; }

return p; }

假定IntNode的类型定义为： struct IntNode {

int data; //结点值域

44

IntNode* next; //结点指针域 };

19. int Count(IntNode *f) {

if(!f) return 0; int c=0; while(f) { c++;

f=f->next; }

return c; }

假定IntNode的类型定义为： struct IntNode {

int data; //结点值域 IntNode* next; //结点指针域 };

20. void Output(IntNode *f) {

if(!f) return; while(f) {

cout<data<<’ ’; f=f->next; }

cout<

假定IntNode的类型定义为： struct IntNode {

int data; //结点值域 IntNode* next; //结点指针域 };

21. void Input(IntNode*& f) {

int n;

cout<<”从键盘给n输入一个整数:”; do cin>>n; while(n<0); if(n==0) {f=NULL; return;} f=new IntNode; IntNode* p=f;

cout<<”从键盘输入”<

45

p=p->next=new IntNode; cin>>p->data; }

p->next =NULL;

p=f; f=f->next; delete p; }

假定IntNode的类型定义为： struct IntNode {

int data; //结点值域 IntNode* next; //结点指针域 };

22. int f(const char *s) {

int i=0;

while(*s++)i++; return i; };

23. char *f(char *s){ int n=strlen(s);

char* r=new char[n+1]; for(int i=0; i

if(s[i]>='a' && s[i]<='z') r[i]=s[i]-'a'+'A'; else r[i]=s[i]; r[n]=’\\0’;

return r; }

七、程序改错

1. 在下面的定义中，NODE是链表结点的结构，appendToList则是一函数，其功能是：在list所指向的链表的末尾添加一个新的值为x的结点，并返回表头指针。函数中有两处错误，指出错误所在行的行号并提出改正意见。 struct NODE{ int data; NODE *next; };

NODE* appendToList(NODE *list, int x){ //1行 NODE *p=new int; //2行 p->data=x; //3行 p->next=NULL; //4行 if(list==NULL) return p; //5行

46

NODE *p1=list; //6行

while(p1->next!=NULL) p1=p1->next; //7行，链表非空先找到表尾

p1=p; //8行，让原表尾指针指向新添加的结点

return list; }

错误行的行号为______和________。

分别改正为______________和______________。

2. 在下面的定义中，NODE是链表结点的结构，addToList则是一函数，其功能是：将一个值为x的新结点添加到以plist为表头指针的链表的首部(即第一个结点的前面)并返回表头指针。函数中有两处错误，指出错误所在行的行号并提出改正意见。 struct NODE{ int data; NODE *next; };

NODE* adndToList(NODE * plist, int x){ //1行 NODE *p; //2行 *p=new NODE; //3行 p->data=x; //4行 p->next=NULL; //5行 plist=p; //6行 return p; //7行 }

错误行的行号为______和________。

分别改正为______________和______________。

3. 假定要求下面程序的输出结果为“11/15”,其主函数中存在着三行语句错误，请指出错误语句行的行号并改正错误行。 #include

class Franction { //定义分数类 int nume; //定义分子 int deno; //定义分母 public:

//把*this化简为最简分数，具体定义在另外文件中实现 void FranSimp();

//返回两个分数*this和x之和，具体定义在另外文件中实现 Franction FranAdd(const Franction& x); //置分数的分子和分母分别0和1

void InitFranction() {nume=0; deno=1;} //置分数的分子和分母分别n和d

void InitFranction(int n, int d) {nume=n; deno=d;} //输出一个分数

47

void FranOutput() {cout<

void main() //1行 { //2行 Franction a,b,c; //3行 a.InitFranction(6,15); //4行 b.InitFranction(1); //5行 c.InitFranction(); //6行 c=FranAdd(a,b); //7行 cout<

错误行的行号为______、________和________。

分别改正为____________________、________________和___________________。

4. 假定要求下面程序的输出结果为“23/20”,其主函数中存在着三条语句错误，请指出错误语句行的行号并改正。 #include

class Franction { //定义分数类 int nume; //定义分子 int deno; //定义分母 public:

//把*this化简为最简分数，具体定义在另外文件中实现 void FranSimp();

//返回两个分数*this和x之和，具体定义在另外文件中实现 Franction FranAdd(const Franction& x); //置分数的分子和分母分别0和1

void InitFranction() {nume=0; deno=1;} //置分数的分子和分母分别n和d

void InitFranction(int n, int d) {nume=n; deno=d;} //输出一个分数

void FranOutput() {cout<

void main() //1行 { //2行 Franction *a=new Franction; //3行 Franction *b=new Franction; //4行 a->InitFranction(6,15); //5行 b.InitFranction(3,4); //6行 Franction c; //7行 c.InitFranction(); //8行 c=a.FranAdd(b); //9行 cout<

48

} //11行

错误行的行号为______、________和________。

分别改正为____________________、________________和___________________。

5. 下面是一个类的定义，存在着3处语法错误，请指出错误行的行号并改正。 class CE { //1行 private: //2行 int a,b; //3行 int getmin() {return (a

错误行的行号为______、________和________。

分别改正为____________________、________________和___________________。

6. 下面程序段第4-10行中存在着三条语句的语法错误，请指出错误语句的行号并改正。

class A { //1行 int a,b; //2行 const int c; //3行 public //4行 A():c(0);a(0);b(0) {} //5行 A(int aa, int bb) c(aa+bb); {a=aa; b=bb;} //6行 }; //7行 A a,b(1,2); //8行 A *x=&a, &y=b; //9行 A *z=new A, w[10]; //10行

错误行的行号为______、________和________。

分别改正为____________________、_____________________ 和______________________________________。 Public: A():c(0),a(0),b(0) {}

A(int aa, int bb): c(aa+bb) {a=aa; b=bb;}

7. 下面程序段第4-9行中存在着三条语句错误，请指出错误语句的行号并说明原因。

49

class A { //1行 int a,b; //2行 const int c; //3行 public: //4行 A() {a=b=c=0;} //5行 A(int aa, int bb):c(aa+bb) {a=aa; b=bb;} //6行 }; //7行 A a,b(1,2,3); //8行 A x(2,3), y(4); //9行

错误行的行号为______、________和________。

错误原因分别为___________________、__________________和__________________。

8. 下面程序段第10-17行中存在着三条语句错误，请指出错误语句的行号并说明原因。 class A { //1行 int a; //2行 public: //3行 A(int aa=0):a(aa){} //4行 }; //5行 class B { //6行 int a,b; //7行 const int c; //8行 A d; //9行 public: //10行 B():c(0) {a=b=0;} //11行 B(int aa, int bb):d(aa+bb) { //12行 a=aa; b=bb; c=aa-bb; //13行 } //14行 } //15行 B a,b(1,2); //16行 B x=a,y(b),z(1,2,3),; //17行

错误行的行号为______、________和________。

错误原因分别为_____________________、______________________ 和_____________________。

9. 假定要求下面程序输出结果为“d=800,f=60”，在第4-23行中存在着三条语句错误，请指出错误语句的行号并改正。 #include

class A { //1行 int a[10]; int n; //2行 public: //3行 A(int aa[], int nn): n(nn) { //4行 for(int i=0; i

50

本文来源：https://www.bwwdw.com/article/ohdr.html