精品文档
124. 假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（ C ）。 A. 已经被改变 B. 可能被改变
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 )成员。 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. 拷贝构造函数
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 ）。
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) 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. 该运算符是一个单目运算符。
.
《c++》复习题集及答案 (2)
