c++题库

假定 AB 引用是某个变量的别名，对引用的操作就是对被引用变量的操作。

A. 对 B. 错

假定 AB 为一个类，则执行 AB x; 语句时将自动调用该类的无参构造函数。

A. 对 B. 错

构造函数用来初始化类的新对象，构造函数与类同名，返回类型只能为void。

A. 对 B. 错

用new动态分配的内存是在堆中分配的，而不是在栈中分配的。

A. 对 B. 错

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

A. 对 B. 错

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

A. 对 B. 错

C++语言的标识符是不区分大小写的。

A. 对 B. 错

作用域运算符（::）只能用来限定成员函数所属的类。

A. 对 B. 错

声明对象时，类名前面不需要加class关键字。

A. 对 B. 错

C++程序一般应当含有main函数，它是C++程序执行的入口。

A. 对 B. 错

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

A. 对 B. 错

C++语言中，既允许单继承，又允许多继承。

A. 对 B. 错

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

A. 对 B. 错

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

A. 对 B. 错

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

A. 对 B. 错

构造函数和析构函数都不能重载。

A. 对 B. 错

在基类中被声明为虚函数的类的成员函数必须在每个派生类中显式声明为虚函数，才能具有多态的特征。

A. 对 B. 错

关于运算符重载，运算符函数的返回类型不能声明为基本数据类型。

A. 对 B. 错

将类的一个对象赋值给该类的另一个对象时，调用拷贝构造函数。

A. 对 B. 错

模板可以使程序对任何数据类型进行同样方式的处理。

A. 对 B. 错

1. 编译源文件后产生的文件是（ ）。

A. 目标文件 B. 可执行文件 C. 源文件 D. 头文件

2. 每个C++程序只能有一个（ ）。

A. 全局变量 B. 函数 C. 头文件 D. 主函数

3. 使用内联函数的好处是（ ）。

A. 增加函数调用次数 B. 提高代码执行效率

C. 减少代码量，增强代码可读性 D. 隐藏内部实现

4.下列不是函数重载所要求的条件是（ ）。

A. 函数名相同 B. 函数返回值类型不同 C. 参数类型不同 D. 参数个数不同

5. 下列哪两个函数为重载函数（ ）。

A. void a1(), void a2() B. intb(int x), float b(int x)

C. char c(double y), char c(int y, double z) D. bool d(double y), bool d(double y, int x = 0) 6. 在面对对象方法中，实现信息隐蔽依靠的是（ ）。

A. 对象的封装 B. 对象的继承 C. 对象的多态 D. 对象的分类

7. 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是（ ）。

A. 类 B. 对象

C. 函数体 D. 数据块

8. 下列关于类定义的说法中，正确的是（ ）。

A. 在类里定义的函数为内联函数 B. 类成员的默认访问权限是保护的 C. 数据成员必须被声明为私有的 D. 成员函数只能在类体外进行定义 9. 关于类和对象不正确的说法是（ ）。

A. 类是一种类型，它封装了数据和操作 B. 对象是类的实例 C. 一个类的对象只有一个 D. 一个对象必属于某个类

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

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

12. 有关构造函数的叙述不正确的是（ ）。 ）。

A. 构造函数名必须和类名一致 B. 构造函数在定义对象时自动执行 C. 构造函数无任何函数类型 D. 在一个类中构造函数有且仅有一个

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

A. 析构函数可以重载 B. 析构函数由系统自动调用 C. 每个对象的析构函数只被调用一次 D. 每个类都有析构函数

14. 通常拷贝构造函数的参数是（ ）。

A. 对象名 B. 对象的成员名 C. 对象的引用名 D. 对象的指针名

15. 在类外定义成员函数时，需要在函数名前加上（ A. 类名 B. 对象名 C. 作用域运算符 D. 类名和作用域运算符

16. 在类定义中，为说明成员的访问权限，private，（ ）。

A. 次数没有具体限制 B. 每种至多一次

）。

，public可以出现次数 protected C. public 至少一次 D. 每种至少一次

17. 关于静态数据成员的描述中错误的是（ ）。

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

B. 类的静态数据成员在在该类每个对象中都保留一个备份 C. 类的静态数据成员必须进行初始化 D. 类的静态数据成员可以不通过对象来访问

18. 若一个类的数据成员用 const 关键字修饰，则该数据成员（ ）。

A. 静态函数中可以对该成员赋值

B. 构造函数只能通过初始化列表对该成员初始化 C. 任何函数都不能使用该成员 D. 外部函数可以对该成员赋值

19. 有两个类 X和Y，且 Y 有一个构造函数 Y::Y(X x); 那么以下语句： X a; Yb(a);

不会调用下面的哪个函数（ ）。

A. Y 的构造函数 Y(X x) B. Y 的拷贝（复制）构造函数 C. X 的默认构造函数 D. X 的拷贝（复制）构造函数

20. 已知类 A 的定义。假设 x 为 A 的对象，则在类外访问 x 对象中数据成员a和b分别应采用（ ）。 class A { private: int a;

public:

int getValue() { return a; } int b; };

A. x::getValue(), x::b B. x.a, x.b C. x.a(), x.b() D. x.getValue(), x.b

21. 假设程序中先前已经定义了 A、B、C 三个类，他们的构造函数分别会输出A constructed、B constructed 和C constructed，那么又定义了类 D，并在 main 函数中定义了一个D 类的对象，部分代码如下： class D{ public:

D():a(), b(), c() { } private: A a; B b; C c; };

intmain() { D d; return 0; }

程序的输出结果为（ ）。

A. A constructed B constructed C constructed B. C constructed B constructed A constructed

C. 编译错误 D. 编译器决定

22. 已知类 CA 中的某个成员是类 CB 的对象，若要把这两个类定义在同一个文件中，则（ ）。

A. CA 必须定义在 CB 之前 B. CB 必须定义在 CA 之前

C. 若 CA 定义在 CB 之后，则 CA 的声明必须出现在 CB 的定义之前 D. 若 CB 定义在 CA 之后，则 CB 的声明必须出现在 CA 的定义之前 23. 在设计一个类的时候，如果希望允许一个不属于该类的函数访问该类的私有成员，应该使用哪个关键字（ ）。

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

24. 关于友元函数的描述中,错误的是（ ）。

A. 友元函数是成员函数 B. 友元函数能访问类中私有成员 C. 友元函数破坏封装性 D. 友元函数声明在类体内

25. 如果类 A 是类 B 的友元，则（ ）。

A. 类 A 的成员是类 B 的成员 B. 类 B 的成员是类 A 的成员

C. 类 A 的成员函数可以访问类 B 的私有成员 D. 类 B 是类 A 的友元

26. 已知类 A 是类 B 的友元类，类 B 是类 C 的友元类，则（ ）。

A. 类 A 一定是类 C 的友元 B. 类 C 一定是类 A 的友元

C. 类 C 的成员函数可以访问类 B 的对象的任何成员 D. 类 A 的成员函数可以访问类 B 的对象的任何成员

27. 已知Point类含有无参（默认）构造函数和有参构造函数，使用Point a[3] = { Point(1, 2), Point(3,4), Point() }; 时，调用了（ ）次Point类的无参（默认）构造函数。

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

28. 要定义一个引用变量p使之引用类MyClass的一个对象,正确的定义语句是（ ）。

A. MyClass p = MyClass; B. MyClass p = new MyClass; C. MyClass &p = new MyClass; D. MyClass a, &p = a;

29. 关于this指针的说法不正确的是（ ）。

A. 不能在程序中修改this指针

B. this指针可以给其他指针赋值，但不能修改this指针 C. 静态成员函数中没有this指针 D. this指针可以被赋值

30. 关于C++的动态存储分配，下列说法正确的是（ ）。

A. new和delete是C++语言中专门用于动态内存分配和释放的函数 B. 动态分配的内存空间也可以被初始化

C. 当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间

D. 当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new 31. 观察程序 #include using namespace std; int main() {

int *first, *second; first = new int[5]; second = first; delete[] second; delete[] first; return 0; }

该程序是否正确，原因是什么 ？

A. 正确，因为first和second都是独立的指针变量 B. 不正确，因为first和second是相关而非独立的指针变量 C. 正确，second会拷贝first的内容 D. 不正确，second和first指向相同的内容 32. C++中，不能被派生类继承的有（ ）。

A. 析构函数 B. 虚函数 C. 静态成员函数 D. 友元函数

33. 下列关于派生类的叙述中，错误的是（ ）。

A. 派生类至少要有一个基类 B. 派生类中包括了从基类继承的成员 C. 一个派生类可以作为另一个派生类的基类 D. 基类成员被派生类继承以后访问权限保持不变 34. 下列关于类型转换正确的是（ ）。

A. 基类的对象可以被当作公有派生类对象使用 B. 派生类对象必须显式的转换为基类对象 C. 派生类对象可以初始化基类的引用 D. 基类的指针可以隐含转换为派生类的指针 35. 下列关于虚基类的描述中，错误的是（ ）。

A. 使用虚基类可以消除由多继承产生的二义性 B. 构造派生类对象时，虚基类的构造函数只被调用一次 C. 声明“classB:virtual public A”说明类B为虚基类 D. 建立派生类对象时，首先调用虚基类的构造函数 36. 以下说法正确的是（ ）。

A. 同一个运算符可以被重载多次

B. 可以通过运算符重载来创建C++中原来没有的运算符 C. 自增运算符重载时，重载函数不允许有输入参数 D. 运算符函数的返回类型不能声明为基本数据类型

37. 若A是一个类名，则如下语句将会产生的A对象个数为（ A a1,*a2; A *a3= new A(); A& a4 = a1;

）。 A. 1 B. 2 C. 3 D. 4

38. 类C2是类C1的派生类，下列说法中错误的是（ ）。

A. C1的成员都是C2的成员 B. C2的对象可以赋值给C1的变量 C. C1的友元函数都是C2的友元函数 D. 创建C2的对象时，要执行C1的构造函数

39. 若类A和类B都是类模板T的模板类，则以下说法正确的是（ ）。

A. A的友元函数中，可以访问B的私有成员 B. A的对象可以赋值给B类型的变量 C. A和B共享T的静态成员变量

D. A的成员函数中，不能访问B的私有成员

40.若类B是从类A派生而来，而语句 p.Do(); 在被多次执行时，有的时候调用的是类A的Do成员函数，有的时候调用的是类B的Do成员函数，那么 p 的类型可以是（ ）。

A. A & B. A * C. B D. A

41. 将一个对象放入STL中的容器里时，（ ）。

A. 实际上被放入的是该对象的一个拷贝（副本） B. 实际上被放入的是该对象的指针

C. 实际上被放入的是该对象的引用 D. 实际上被放入的就是该对象自身 42. 以下说法正确的是（ ）。

A. 在multiset容器中，可以同时存储多个相同的元素 B. 在set容器中，各元素的存储位置取决于它们的插入顺序 C. 向deque容器添加新对象时，需要比较对象的大小 D. 在list容器中，各元素的存储位置取决于它们的值 43. 若有如下定义：

set::iterator it1, it2, it3; set s;

则以下语句不符合语法的是（ ）。

A. it1++; B. --it2; C. it3 = it1 + 1;

D. boolisEnd = (it1 == s.end());

44. 关于函数对象，如下说法中正确的是（ ）。

A. 如果一个类重载了“()”运算符，该类的对象是函数对象 B. 如果一个类定义了函数指针成员变量，则该类的对象是函数对象 C. 函数对象类中只能定义成员函数，不能定义成员变量 D. 函数对象类只能定义一个函数对象 45. 有如下两个类定义： class AA { }; class BB { AA v1, *v2; BB v3;

int v4; }

其中有一个成员变量的定义是错误的，这个变量是（ ）。

A. v1 B. v2 C. v3 D. v4

46. 对于如下代码，请指出错误的代码行号是（ 1 class A { 2 public:

3 A(int a = 0) { 4 x = a; 5 }

6 static void f1() { 7 x++; 8 }; 9 private: 10 int x; 11 static int y; 12 };

A. 3 B. 4 C. 7 D. 11

47. 对于如下代码 1 class B { 2 public:

）。

3 void f() { } 4 void g() { f(); } 5 }

6 class D : public B { 7 public:

8 void f() { } 9 void g() { B::f() } 10 }

11 int main() {

12 B b, pb = &b; 13 D d, pd = &d; 14 b.f(); 15 pd->f(); 16 return 0; 17 }

其中第14行代码和第15行代码分别调用的是（ A. B::f() 与 D::f() B. B::f() 与 B::f() C. D::f() 与 D::f() D. D::f() 与 B::f()

48. 以下程序的输出结果是（ ）。 #include using namespace std; class A { public:

A(int a1, int a2):a1(a1), a2(a2) { } void print(); void print() const; private:

）。

int a1, a2; };

void A::print() { cout<< a1 << \}

void A::print()const { cout<< a2 << \}

int main() { A a(1, 2); const A b(1, 2); a.print(); b.print(); return 0; }

A. 1 1 B. 1 2 C. 2 1 D. 2 2 49. 有如下程序： #include using namespace std; class A { private: int a; public:

A(int a = 0):a(a) { cout<< \ }

A(A &x) { a = x.a; cout<< \ } ~A() {

cout<< a; }

int get_a() { return a; } };

int main() {

A d1(5), d2(d1); A *pd = new A(8); cout<< pd->get_a(); delete pd; return 0; }

程序运行时的输出结果是（ A. 12185 B. 1215588 C. 128512 D. 1218855 50. 有如下程序： #include using namespace std; class A { public:

void setA(int);

）。

private: int a; }; class B { public:

void setB(int); private: int b; };

class C:public A,private B { public:

void setC(int, int, int); private: int c; };

void A::setA(intx){ a = x; }

void B::setB(intx){ b = x; }

void C::setC(int x, int y, int z) { setA(x); setB(y); c = z; }

int main() { C obj;

obj.setA(5); // A obj.setB(6); // B

obj.setC(6, 7, 9); // C return 0; }

main函数中（ ）是错误的。

A. A语句 B. B语句 C. C语句

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

A. 区分类是否有虚函数 B. 使类成为抽象类 C. 提高程序运行效率 D. 消除二义性

52. 运行时多态是基于（ ）。

A. 友元函数 B. 虚函数 C. 函数重载 D. 运算符重载

53. C++泛型编程通过（ ）实现。

A. class B. template C. virtual D. typedef

54. 关于函数声明 float fun(int a, int b) throw，下列叙述正确的是（ ）。

A. 表明函数抛出 float 类型异常 B. 表明函数抛出任何类型异常 C. 表明函数不抛出任何类型异常 D. 语法错误 55. 有如下两个程序片段： #include //程序片段一 std::vectorvec;

for(auto itr =vec.begin(); itr != vec.end(); itr++) itr->print(); //程序片段二 std::vectorvec;

for(autoitr = vec.begin(); itr != vec.end(); ++itr) itr->print();

则下列说法中，正确的有（ ）。 (a)itr的类型为auto

(b)程序二性能上要比程序一更好 (c)程序一和程序二性能上没有区别

A. ab B. b C. ac D. c

56. 如果 X 是整型变量，则合法的形式是（ ）。

A. &(X+1) B. *X

C. *&X D. &*X

57. 判断以下程序的正确性，并说明原因。 #include using namespace std; int main() { int *first, *second; first = new int[5]; second = first; delete[] second; delete[] first; return 0; }

A. 正确，因为 first 和 second都指向动态内存，需要手动释放 B. 不正确，应该先释放 first 指向的内存空间 C. 正确，second 会拷贝 first 的内容

D. 不正确，second 和 first 指向相同的动态内存，重复释放会可能导致未定义行为

58. C++中既可以用于文件输入又可以用于文件输出的流类是（ ）。

A. fstream B. ifstream C. ofstream D. iostream

59. 下列是关于函数模板的程序，则下列说法中正确的有（ ）。 #include using namespace std;

template void f(T &i) { cout << \

template<> void f(const int &i) { cout << \int main() { int i = 42; f(i); return 0; }

(a)程序输出1 (b)程序输出2

(c)template <>void f(const int &i) 显式实例化void f(const int &) (d)f(i)隐式实例化函数void f(int &)

A. ad B. bc C. acd D. bcd

60. 下列程序的输出为（ ）。 #include using namespace std; class Shape { public:

virtual void print() { cout<< \}

virtual ~Shape() { } };

classBox : public Shape { public:

virtual void print(int i) { cout<< \}

};

int main() {

Shape *s = new Box(); s->print(); delete s; return 0; }

A. SHAPE B. BOX C. 未定义行为

1、从完成C++源文件编辑，到生成执行文件，C++编译器必须执行的步骤依次为编译、链接。

A. 对 B. 错 C++是强类型语言。

A. 对 B. 错

3、如果a为int型变量，b为int型变量，则a/static_cast(b)的值为int型。

A. 对 B. 错

4、数组可以通过值参数和引用参数两种方式传递给函数。

A. 对 B. 错

5、当一个函数在运行过程中产生一个异常，则这个函数会终止，但是整个程序不一定终止运行。

A. 对 B. 错

6、构造函数和析构函数都不能重载。

A. 对 B. 错

7、构造函数可以声明为虚函数。

A. 对 B. 错

8、已知类X成功地重载了--、=、+和[]这几个运算符，其中肯定属于成员函数的运算符是=和[]。

A. 对 B. 错

9、在声明一个对象时如果使用同一类类型的另一个对象来初始化，这时调用的是该类的拷贝构造函数。

A. 对 B. 错

10、C++语言中，既允许单继承，又允许多继承。

A. 对 B. 错

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

A. 对 B. 错

12、派生类是从基类派生出来的，它不能再生成新的派生类。

A. 对 B. 错

13、构造函数可以被继承，析构函数不能被继承。

A. 对 B. 错

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

A. 对 B. 错

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

A. 对 B. 错

16、某类的友元类中的所有成员函数可以存取或修改该类的私有成员。

A. 对 B. 错

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

A. 对 B. 错

18、虚函数和普通函数的区别在于函数名字与函数体之间的绑定方式不同，普通函数使用的是静态绑定，而虚函数使用的是动态绑定。

A. 对 B. 错

19、在抽象类中定义的函数只能是纯虚函数。

A. 对 B. 错

20、模板对类型参数化提供了很好的支持，类模板实例化时，编译器将根据给出的模板实参生成一个类。

A. 对 B. 错

1. 算法是一个计算过程，是程序设计的基础和精髓。一个有效的算法应该具有如下特点，其中错误的是（ ）。

A. 零个或多个输入及一个或多个输出 B. 有效性 C. 无穷性 D. 确定性

2. #include与 #include\的区别是（ ）。

A. 前者首先从当前工作路径搜寻并引用file.h，而后者首先从标准库的路径寻找和引用file.h

B. 前者首先从标准库的路径寻找和引用file.h，而后者首先从当前工作路径搜寻并引用file.h

C. 两者都是首先从标准库的路径寻找和引用file.h D. 两者都是首先从当前工作路径搜寻并引用file.h 3. 头文件中的ifndef/define/endif的作用是（ ）。

A. 定义常量

B. 标记为特殊的头文件 C. 防止头文件被重复引用 D. 注释头文件

4. 在一个程序中，如果函数fA调用了函数fB，函数fB又调用了函数fA，那么（ ）。

A. 称为函数的循环调用 B. 这样调用方式是不允许的 C. 称为函数的直接递归调用 D. 称为函数的间接递归调用

5. 引入内联函数的目的是为了（ ）。

A. 方便变量的使用 B. 提高函数调用的效率 C. 扩大局部变量的使用范围 D. 节省内存空间

6. 当给函数的参数设置默认值时，正确的说法是（ ）。

A. 若给某一参数设置了默认值，那么在参数表中其前所有的参数都必须也设置默认值

B. 若给某一参数设置了默认值，那么在参数表中其后所有的参数都必须也设置默认值

C. 给函数的参数设置默认值可以提高程序运行效率 D. 任何情况下，函数调用时均可不列出已设置默认值的参数 7.下列说法正确的是（ ）。 int *p1 =new int[10]; int *p2 =new int[10]();

A. p1和p2申请的空间里面的值都是随机值 B. p1和p2申请的空间里的值都已经初始化

C. p1申请的空间里的值是随机值，p2申请的空间里的值已经初始化 D. p1申请的空间里的值已经初始化，p2申请的空间里的值是随机值 8. 按照常理，下列概念可以理解为对象而不是类的是（ ）。

A. 国际知名学府 B. 国家重点建设大学 C. 诺贝尔奖获得者 D. 杭州师范大学

9. 在面向对象程序设计中，实现信息隐蔽是靠（ ）。

A. 对象的封装 B. 对象的继承 C. 对象的间接访问 D. 对象的分类

10. 下列有关类的说法，错误的是（ ）。

A. 在类中，如果不作特别说明，所有的数据成员均为私有数据成员 B. 类是一种用户自定义的数据类型

C. 在类中，如果不作特别说明，所有的成员均为公有成员 D. 只有类中的成员函数或类的友元函数才能存取类中的私有数据 11. 下面有关类与对象的说法中，错误的是（ ）。

A. 对象是类的实例

B. 类和对象的关系与数据类型和变量的关系相似 C. 一个对象不能同时属于多个没有关系的独立的类 D. 一个类只能有一个对象

12. 下列关于构造函数说法，错误的是（ ）。

A. 构造函数必须与类同名 B. 构造函数必须有返回值 C. 构造函数可以省略不写

D. 在构造函数中可以对类中的成员进行初始化 13. 以下有关析构函数的叙述，错误的是（ ）。

A. 析构函数名前必须冠有符号“~” B. 在一个类只能定义一个析构函数

C. 析构函数不允许用返回值

D. 析构函数和构造函数一样可以有形参 14. 关于类的对象，说法错误的是（ ）。

A. 释放对象时，相应类的析构函数被自动执行

B. 在成员函数中，只能访问成员函数所作用的对象的private成员 C. 对象的成员变量可以是其他类的对象 D. 同类的对象间，可以互相赋值

15. 设已经有A、B、C、D4个类的定义，程序中A、B、C、D析构函数调用顺序是（ ）。 C c; int main() { A *pa = new A(); B b; static D d; delete pa; }

A. A B C D B. A B D C C.A C D B D. A C B D

16. 以下说法中正确的是（ ）。

A. 构造函数中可以调用本类的静态成员函数 B. 构造函数和析构函数都可以是虚函数

C. 通过赋值号“=”用一个对象对另一个对象进行赋值，就会引发复制构造函数的调用

D. 用new运算符动态创建对象时，用于初始化该对象的一定是无参数的构造函数

17. 下列情况中，不会调用对象析构函数的是（ ）。

A. 将对象指针强行赋值为NULL时

B. 函数中定义的动态对象变量当函数执行结束时 C. 用delete删除对象指针时 D. 当对象变量脱离其作用域时

18. 关于类的静态成员，说法错误的是（ ）。

A. 在类的静态成员函数中，可以访问该类的静态成员变量 B. 在类的非静态成员函数中，不可以访问该类的静态成员变量 C. 不需要创建类的对象，就可以访问类的静态成员 D. 类的静态成员变量由该类的全部对象共有

19. 假设Complex是一个复数类，下面（ ）将不会引起拷贝构造函数的调用。

A. Complexc1(5); Complex c2(c1); B. Complexc1(5); Complex c2 = c1; C. Complexc1(5); Complex c2[2] ={ c1, 2}; D. Complexc1(5), c2; c2 = c1;

20. 关于常量成员和静态成员，下面说法正确的是（ ）。

A. 从同一个类模板得到的两个模板类可以共享同一个静态成员 B. 公有的静态成员在没有对象生成的时候也能被直接访问 C. 常量成员函数只有常量对象可以调用

D. 在静态成员函数中不能访问非静态成员，但可以访问常量成员 21. 下列关于运算符重载的说法中，错误的是（ ）。

A. new和delete运算符可以重载

B. 重载运算符不能改变其原有的操作数个数

C. 三元运算符“?:”不能重载

D. 所有运算符既可以作为类的成员函数重载,又可以作为非成员函数重载

22. 若需要为xv类重载乘法运算符，运算结果为xv类型，在将其声明为类的成员函数时，下列原型声明正确的是（ ）。

A. xv operator*(xv,xv); B. xv*(xv); C. operator*(xv); D. xv operator*(xv);

23. 已知表达式++a中的“++”是作为成员函数重载的运算符，则与++a等效的运算符函数调用形式为（ ）。

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

24. 将运算符重载为类成员函数时，其参数表中没有参数，说明该运算符是（ ）。

A. 不合法的运算符 B. 一元运算符 C. 无操作数的运算符 D. 二元运算符

25. 将运算符“+”重载为非成员函数，下列原型声明中,错误的是（ ）。

A. MyClock operator+(MyClock, long); B. MyCIock operator+(MyClock, MyCIock); C. MyClock operator+(long, long); D. MyCIock operator+(long,MyClock);

26. 下列对派生类的描述中，错误的是（ ）。

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

B. 派生类中继承的基类成员的访问权限到派生类保持不变 C. 派生类至少有一个基类

D. 派生类成员除了它自己的成员外，还包含它的基类成员 27. 当派生类从基类公有继承时，以下说法错误的是（ ）。

A. 可以把指向派生类对象的指针赋给基类对象的指针 B. 可以用基类对象为派生类对象赋值

C. 可以把派生类对象的地址赋给基类对象的指针 D. 可以用派生类对象为基类对象赋值

28. 由于以下（ ）原因，在编程实践中很少使用私有继承。

A. 经过私有继承之后，基类的成员再也无法在以后的派生类中直接发挥作用 B. 私有继承不能很好的保护基类成员的安全性 C. 私有继承对基类的编写方法有更为严格的要求 D. 私有继承的性能低于公有继承 29. 以下说法正确的是（ ）。

A. 通过指针访问对象的虚函数时，所执行的函数体由指针的类型决定 B. 在基类的函数成员中，可以利用多态机制访问派生类的成员函数 C. 派生类的对象中不包括基类的private成员

D. 类B是类A的派生类，若函数f是A的友元，则f也是B的友元 30. 类的成员函数中，下列函数中不能为虚函数的是（ ）。

A. 构造函数 B. 析构函数

C. 运算符重载函数 D. const函数

31. C1是一个抽象类，下列语句中错误的是（ ）。

A. C1 *pC;

B. void fun(C1 arg); C. void fun(C1 *arg); D. void fun(C1 &arg);

32. 下列关于说法中，正确的是（ ）。

A. 类的虚函数中，不能访问this指针 B. 类的静态成员函数中，不能访问this指针 C. 类的友员函数中，不能访问this指针 D. 类的构造函数中，不能访问this指针 33. 有如下类定义： class Animal { public:

virtual void Name() = 0; };

class Koala : public Animal { public:

void Name() { /* 函数体略 */ } };

关于上述类定义，下列描述中错误的是（ ）。

A. 类Koala是类Animal的派生类 B. 类Koala中的Name函数是一个虚函数

C. 类Animal中的Name函数是一个纯虚函数

D. 语句“Animal a;”能够建立类Animal的一个对象a 34. 关于基类中的虚函数与一般成员函数，正确的是（ ）。

A. 虚函数只能定义一个，而一般成员函数可以多个 B. 虚函数与一般成员函数在基类中没什么区别 C. 虚函数不能定义函数体，而一般成员函数可以 D. 虚函数不能被调用，而一般成员函数可以

35. 基类中的虚函数如果在派生类中未重新定义，则会出现（ ）的情况。

A. 无法使用派生类的对象调用这个函数 B. 不允许定义派生类的对象 C. 无法使用基类的对象调用这个函数

D. 使用派生类的对象调用的仍然是基类的这个函数 36. 关于抽象类，下列说法正确的是（ ）。

A. 纯虚函数与虚函数的声明语法相同 B. 可用new操作符来生成抽象类的对象 C. 带有纯虚函数的类称为抽象类

37. 下面有关封装、继承、多态的描述，说法错误的是（ ）。

A. 封装是指把客观事物封装成抽象的类，类的数据和函数只让可信的类或对象操作，不可信的则信息隐藏

B. 继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展

C. 隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了

D. 覆盖是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同 38. 关于函数模板，下列说法正确的是（ ）。

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