内容发布更新时间 : 2024/5/5 23:40:43星期一 下面是文章的全部内容请认真阅读。

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