【百题通关参考答案】面向对象程序设计辅导练习题参考答案

单选题

题目 1（单选题）

在下列各种高级语言中, 不属于面向对象程序设计编程语言的是

• A. C++

• B. Java

• C. C

• D. Python

题目 2（单选题）

关于 C++ 与 C 语言的关系描述中，错误的是

• A. C++ 语言与 C 语言是兼容的

• B. C 语言是 C++ 语言的一个子集

题目 3（单选题）

C++ 通过下列哪种特性防止程序中变量命名冲突问题

• A. 强制转换

• B. 名字空间

• C. 布尔类型

• D. 函数重载

题目 4（单选题）

要求函数 func() 实现不太复杂的功能，且执行速度较快，可以将其设计为

• A. 内联函数

• B. 重载函数

• C. 递归函数

• D. 嵌套函数

题目 5（单选题）

面向对象程序设计的特征不包括

• A. 封装性

• B. 兼容性

• C. 继承性

• D. 多态性

题目 6（单选题）

C++ 对 C 作了很多改进，从面向过程成为面向对象的主要原因是

• A. 引进了类和对象的概念

• B. 增加了一些新的运算符

• C. 规定函数必须用原型

• D. 允许函数重载，并允许设置参数默认值

题目 7（单选题）

假如有定义”int a[5]; int *p;”, 则下面的赋值语句不正确的是

• A. p = a;

• B. p =&a[0];

• C. p = new int[5];

• D. p = b[5];

题目 8（单选题）

假如有定义 int** p = NULL, 则下面的赋值语句正确的是

• A. p = new int;

• B. p = new int[10];

• C. p = new int*;

• D. p = new int**;

题目 9（单选题）

下列设置默认值的函数原型声明中错误的是

• A. int func(int x, int y, int z);

• B. int func(int x=1, int y=2, int z);

• C. int func(int x, int y=2, int z=3);

• D. int func(int x=1, int y=2, int z=3)

题目 10（单选题）

C++ 中，局部变量可以隐藏全局变量，那么在有同名全局变量和局部变量的 情形时，可以采用下面哪种特性实现对全局变量的访问

• A. 域解析符

• B. 类运算符

• C. 函数重载

• D. 变量引用

题目 11（单选题）

下列不符合函数重载条件要求的是

• A. 函数的参数类型不同

• B. 函数的参数个数不同

• C. 函数的参数顺序不同

• D. 函数的返回类型不同

题目 12（单选题）

主函数内使用 f(10) 调用下列各重载函数时, 将导致二义性结果的是

• A. void f(int x) 和 void f(double x);

• B. void f(int x) 和 void f(in x, int y=0);

• C. void f(int x) 和 void f(double x, double y);

• D. void f(int x) 和 void f(double x,char *y);

题目 13（单选题）

已知数组 arr 的定义如下，下列语句中输出结果不是 2 的为

• A. cout<<*arr + 1<<endl;

• B. cout<<*(arr+1)<<endl;

• C. cout<<arr[1]<<endl;

• D. cout<<*arr<<endl;

题目 14（单选题）

在说明”const char *ptr;” 中，这里的 ptr 确切含义应该是

• A. 指向字符的指针

• B. 指向字符的常量指针

• C. 指向字符串的常量指针

• D. 指向字符串常量的普通指针

题目 15（单选题）

程序中已有定义 const char *p =“Tsinghua”; 下面语句中错误的是

• A. cout << p ;

• B. p[1]= ‘q’;

• C. p = “SDNU”;

• D. p = new char[4];

题目 16（单选题）

阅读如下程序，程序输出结果为

• A. 10;

• B. 20;

• C. 30;

• D. 40;

题目 17（单选题）

下面语句中错误的是

• A. const double ∗p ;

• B. double * const p ;

• C. int const buffer = 16 ;

• D. const int buffer = 16;

题目 18（单选题）

下面进行正确的引用定义是

• A. int &a[10];

• B. int &*p;

• C. int &&pp;

• D. int i, &p=i;

题目 19（单选题）

有关 C++ 引用特性的叙述正确的是

• A. 引用在内存中占有独立存储空间

• B. 引用就是某个单一变量的别名

• C. 无法通过变量的引用修改变量值

• D. 声明引用时无须立即进行初始化

题目 20（单选题）

在 C++ 源程序中，关于语句 int *p = new int(5); 的语句描述正确的是

• A. 用指针 p 申请了连续 5 个 int 型的空间，但未向动态空间内初始化赋初值;

• B. 用指针 p 申请了 1 个 int 型的空间，同时向该动态空间内赋入初始值为 5;

• C. 用指针 p 申请了 1 个 int 型的空间，同时为指针 p 赋入初始数值为 5;

• D. 该语句存在语法错误;

题目 21（单选题）

下列语句中错误的是

• A. int* p = new int;

• B. int* p = new int(10) ;

• C. int* p = new int[10]{0};

• D. int** p = new int**;

题目 22（单选题）

有关函数重载的叙述中错误的是

• A. 函数重载就是用相同的函数名定义多个函数

• B. 重载函数的返回值类型必须不同

• C. 重载函数的参数列表必须不同

• D. 重载函数的参数可以带有默认值

题目 23（单选题）

在主函数内通过语句 f(10) 调用下列函数时, 将导致二义性结果的是

• A. void f(int x) 和 void f(double x);

• B. void f(int x) 和 void f(int &x);

• C. void f(int x) 和 void f(int x, char *y);

• D. void f(int x) 和 void f(double x, double y);

题目 24（单选题）

下列有关运算符重载的叙述中, 正确的是

• A. 重载运算符时可以改变其优先级。

• B. 重载运算符时可以改变其结合性。

• C. c++ 可以通过运算符重载创造新的运算符。

• D. 运算符函数的名称总是以 operator 为前缀。

题目 25（单选题）

有如下语句序列: char str[10]; cin>> str; 当从键盘输入”I love sdnu” 时，字符串 str 中存储的内容为：

• A. “I love sdnu”

• B. “I love sdn”

• C. “I love”

• D. “I”

题目 26（单选题）

为了提高函数调用的实际运行速度，可以将简单的函数定义为

• A. 内联函数

• B. 重载函数

• C. 静态函数

• D. 构造函数

题目 27（单选题）

有关 C++ 异常处理的过程不包括

• A. try 语句块检查异常

• B. throw 函数块抛出异常

• C. catch 函数块捕捉异常

• D. return 语句返回异常

题目 28（单选题）

已知函数 func 的原型为 void func(int a, int *p, int &r)，变量 x，y，z 的定义形 式为：int x, y, z ;, 下列调用语句中正确的是

• A. func(x,&y,z);

• B. func(x,y,z);

• C. func(x,y, &z);

• D. func(&x,&y,&z);

题目 29（单选题）

下列有关类和对象的描述不正确的是

• A. 对象是类的一个实例

• B. 一个类只能有一个对象

• C. 任何一个对象只能隶属于一个具体的类

• D. 类和对象的关系同数据类型与变量的关系相似

题目 30（单选题）

下列有关类的说法中不正确的是

• A. 类中的成员函数可以访问和修改类内的私有数据。

• B. 类在本质上是用户自定义的数据类型，对象则是类的一个变量。

• C. 在类中，如果不做访问属性说明，则所有的数据成员均为私有属性。

• D. 在类中，如果不做访问属性说明，则所有的成员函数均为公有属性。

题目 31（单选题）

在 C++ 中每个类含有的构造函数的个数为：

• A. 只能有一个

• B. 可以有多个

• C. 可以有非公有的

• D. 只可有默认的。

题目 32（单选题）

假如已定义类 A，则在类外对类 A 的构造函数和析构函数进行正确定义的 是

• A. void A::A(){}; void A::∼A(){};

• B. A::A(参数){}; A::∼A(参数){};

• C. A::A(参数){}; A::∼A(){};

• D. void A::A(参数){}; void A::∼A(参数){};

题目 33（单选题）

若有如下类的声明： }; 那么执行语句：Myclass x, y(2), z[3], *p[2]; Myclass &r = x; 程序的输出结果为

• A. **

• B. ****

• C. *****

• D. *******

题目 34（单选题）

类 Student 的拷贝构造函数的声明语句为

• A. Student& Student (const Student other) ;

• B. Student Student(const Student other);

• C. Student(const Student &other);

• D. Student(Student *other);

题目 35（单选题）

通常类的拷贝构造函数的形式参数是

• A. 该类的某个对象名称;

• B. 该类的某个对象指针;

• C. 该类的某个对象引用;

• D. 该类的某个对象成员;

题目 36（单选题）

下列关于类的拷贝构造函数的描述正确的是

• A. 通过拷贝构造函数可以实现不同对象间数据的拷贝;

• B. 不能在拷贝构造函数内直接访问类内私有成员变量;

• C. 系统默认拷贝构造函数无法完成动态内存资源的拷贝;

• D. 拷贝构造函数的形式参数可以为该类的某个对象;

题目 37（单选题）

假设 a 表示 Book 类的的一个对象，且赋有初始值，当执行语句 Book b = a; 时， 则编译系统会

• A. 程序执行出错，出现异常；

• B. 自动调用无参构造函数；

• C. 自动调用赋值运算符函数；

• D. 自动调用拷贝构造函数；

题目 38（单选题）

若 Time 表示一个时间类，该类的普通成员函数隐含的第一个形式参数为 this, 则 this 参数的类型为

• A. Time

• B. Time&

• C. Time*

• D. int

题目 39（单选题）

某程序的头文件内容如下，在所有描述的函数中，函数第一形参隐藏 this 指针 的函数是 };

• A. f1

• B. f2

• C. f3

• D. f4

题目 40（单选题）

执行下面的程序，将输出结果为 1 #include 2 using namesapce std; 3 class Myclass 4 { private: int m; 10 }; 11 int main() 12 { Myclass obj1(100); 20 }

• A. m = 100; m = 200;

• B. m = 100; const: m = 200;

• C. const: m = 100 ; const: m = 200;

• D. const: m = 100 ; m = 200;

题目 41（单选题）

下列程序中，错误的语句是：

题目 42（单选题）

下列是对类的静态数据成员的描述，正确的是 using namesapce std; private: int val ; }; Myclass obj2(20);

• A. 语句 1

• B. 语句 2

• C. 语句 3

• D. 语句 4

题目 43（单选题）

下列有关友元函数的说法，不正确的是

• A. 友元函数可以访问类的私有数据成员；

• B. 友元函数可以提高程序的运行效率；

• C. 友元函数实现时在类外或类内均可实现；

• D. 友元函数声明和定义都需要添加 friend 修饰；

题目 44（单选题）

下列关于常成员函数的说法中，不正确的是

• A. 常对象只能调用常成员函数；

• B. 常对象的数据成员均为常数据成员；

• C. 常成员函数不允许调用类的普通成员函数；

• D. 常数据成员必须在类构造函数初始化列表内进行初始化；

题目 45（单选题）

关于使用 const 关键字修饰的对象的描述，错误的是

• A. 该对象中的函数都是 const 函数

• B. 该对象可以用一般的成员函数来访问

• C. 该对象可直接访问 const 成员函数

• D. 该对象不能直接访问普通的成员函数

题目 46（单选题）

下列函数中, 只能访问类的静态成员变量的是

• A. 构造函数；

• B. 析构函数；

• C. 友元函数；

• D. 静态函数；

题目 47（单选题）

下列函数中, 只能访问类的静态成员变量的是

• A. 构造函数；

• B. 析构函数；

• C. 友元函数；

• D. 静态函数；

题目 48（单选题）

静态成员遵循类的其他成员所遵循的访问限制，除了

• A. 静态成员函数

• B. 静态数据成员初始化

• C. 私有静态数据成员

• D. 公有静态数据成员

题目 49（单选题）

下面程序在进行编译时，哪几行无法编译通过 using namesapce std; Circle () radius = 0.0; total++ ; PI = 3.14; }; Circle c; cout << “c.area() =”<< c.area()<<endl; // 5

• A. 1⃝ 2⃝ 3⃝ 4⃝

• B. 1⃝ 2⃝ 3⃝

• C. 1⃝ 3⃝ 4⃝

• D. 2⃝ 4⃝ 5⃝

题目 50（单选题）

下列代码声明了三个类, 关于这些类之间关系的描述错误的是

• A. 类 Person 是类 Undergraduate 的基类

• B. 类 Undergraduate 从类 Student 公有继承

• C. 类 Student 是类 Person 的派生类

• D. 类 Undergraduate 是类 Person 的派生类

题目 51（单选题）

下列关于继承方式的描述中，错误的是

• A. 如果不显式地指定继承方式，缺省的继承方式为私有 private

• B. 采用公有继承时，基类中的公有成员在派生类中仍然是公有成员

• C. 采用保护继承时，基类中的保护成员在派生类中仍然是保护成员

• D. 采用私有继承时，基类中的私有成员在派生类中仍然是私有成员

题目 52（单选题）

派生类的某个对象可以直接访问基类成员中的

• A. 公有继承的公有成员

• B. 公有继承的私有成员

• C. 公有继承的保护成员

• D. 私有继承的公有成员

题目 53（单选题）

在类的访问属性和继承方式缺省的情况下，系统默认为

• A. public

• B. private

• C. protected

• D. static

题目 54（单选题）

下列关于基类和派生类关系的叙述中正确的是

• A. 每个类最多只能有一个直接基类。

• B. 派生类中的成员可以访问基类中的所有成员。

• C. 派生类将部分接收来自基类中的非静态数据成员；

• D. 派生类除了继承基类的成员还可以再定义新的成员；

题目 55（单选题）

下列对基类和派生类的关系描述中，错误的是

• A. 派生类是基类定义的延续

• B. 派生类是基类的具体化。

• C. 派生类是基类的组合；

• D. 派生类是基类的子集；

题目 56（单选题）

在公有派生的情况下，派生类中定义的成员函数只能访问原基类的

• A. 公有成员和私有成员

• B. 私有成员和保护成员

• C. 公有成员和保护成员

• D. 公有、私有和保护成员

题目 57（单选题）

有如下类定义，其中横线处应该填写的内容是 using namesapce std; AA(int x = 0) {this−>a = x ;} }; BB(int n) _____________ ; };

• A. : a(n)

• B. : AA(n)

• C. :a(n)

• D. :a = n

题目 58（单选题）

如有如下类的定义， 已知 obj 是类 Derived 的对象，下列语句中不违反成员访问控制权限的是

• A. obj.fun1();

• B. obj.var1;

• C. obj.fun2();

• D. obj.fun3();

题目 59（单选题）

基类内的哪一种数据成员可以被其派生类所继承，且允许在派生类内访问该 成员，但不允许在派生类的外部访问该成员。

• A. 公有数据成员

• B. 保护数据成员

• C. 私有数据成员

• D. 以上皆是

题目 60（单选题）

在 C++ 中，设置虚基类的目的是

• A. 避免二义性

• B. 简化程序代码

• C. 减少目标代码

• D. 提高程序运行效率

题目 61（单选题）

下列关于派生类构造函数和析构函数的说法中错误的是

• A. 派生类的构造函数会隐含调用基类的构造函数

• B. 如果基类中没有缺省的构造函数，那么派生类必须显式调用基类构造函数

• C. 在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数

• D. 在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

题目 62（单选题）

派生类构造函数的成员初始化列表中不能包括的初始化项是

• A. 基类的构造函数

• B. 派生类对象成员所属类的构造函数

• C. 基类的对象成员所属类的构造函数

• D. 派生类自身定义的数据成员

题目 63（单选题）

当派生类中有和基类具有相同名字的成员时，下列说法正确的是

• A. 派生类的同名成员将覆盖基类的成员

• B. 基类的同名成员将覆盖派生类的成员

• C. 将产生二义性

• D. 是不能允许的

题目 64（单选题）

有如下类定义，其中横线处应该填写的内容是 using namesapce std; AA(int x = 0) {this−>a = x ;} }; private： AA m; BB(int n) _____________ };

• A. : a(n),m(n){ }

• B. : AA(n),m(n){ }

• C. {a(n);m(n)}

• D. {a = n;m(n)}

题目 65（单选题）

阅读如下程序，程序的输出结果为： private: int a; Base(int x = 0):a(x) {cout<< x ;} }; Base val; Derived(int x = 0) }; Derived d(1);

• A. 0

• B. 1

• C. 01

• D. 001

题目 66（单选题）

如下程序中，有语法错误的语句是 }; a = 1; b = 2; c = 3; }; Derive d;

• A. 1⃝ 2⃝ 3⃝ 5⃝ 7⃝

• B. 2⃝ 3⃝ 4⃝ 5⃝ 6⃝

• C. 3⃝ 4⃝ 5⃝ 6⃝

• D. 1⃝ 6⃝ 7⃝

题目 67（单选题）

下列关于某派生类声明的开始部分，其中正确的是

• A. BCAD∼D∼A∼C∼B

• B. ABCCD ∼D∼C∼C∼B∼A

• C. ABCD∼D∼C∼B∼A

• D. BCACD∼D∼C∼A∼C∼B

题目 68（单选题）

下列关于虚基类顶顶顶顶描述中，错误的是

• A. 使用虚基类可以消除由多继承产生的二义性

• B. 建立派生类对象时，首先调用虚基类的构造函数

• C. 构造派生类对象时，虚基类的构造函数只被调用一次

• D. 对于声明”class B : virtual public A” , 说明类 B 为虚基类

题目 69（单选题）

如下程序代码，程序执行结果为 private: int a; AA() ~AA() {cout<< “A”;} {cout<< “~A”;} }; private: int b; BB() ~BB() {cout<< “B”;} {cout<< “~B”;} }; private: int c; CC() ~CC() {cout<< “C”;} {cout<< “~C”;} }; CC c; ~DD(){cout<< “~D”;} }; DD *p = new DD;

题目 70（单选题）

下列关于虚基类初始化的说法中正确的是 类的构造函数时，不再调用虚基类的构造函数。

• A. 虚基类的初始化可由它的各层派生类构造函数引起，故不止一次初始化。

• B. 虚基类直接派生类的构造函数的初始化列表中必须包含虚基类的构造函数。

• C. 无论是否定义最后派生类的对象。虚基类的构造函数一定至少调用一次。

• D. 在最后派生类构造函数的调用中，优先调用虚基类的构造函数，再调用其他基

题目 71（单选题）

假设类 B 是类 A 的公有派生类，并且已定义如下语句, 则根据赋值兼容规则， 下列正确赋值的语句是 A a, *pa = &a; B b, *pb = &b;

• A. a = b;

• B. *pb = *pa

• C. b = a;

• D. pb = pa;

题目 72（单选题）

编译时的多态性可以通过使用哪种方式获得

• A. 函数重载和运算符重载。

• B. 虚函数和基类指针。

• C. 虚函数和基类引用。

• D. 虚函数和对象。

题目 73（单选题）

函数重载的目的是

• A. 提高可读性

• B. 提高速度

• C. 减少空间

• D. 实现共享

题目 74（单选题）

c++ 编译器区分重载函数时，无任何意义的信息是

• A. 函数形参的个数

• B. 函数形参的类型

• C. 函数形参的顺序

• D. 函数返回值类型

题目 75（单选题）

运算符重载不需要保持的性质是

• A. 运算符操作数个数。

• B. 运算符操作数类型。

• C. 运算符的优先级。

• D. 运算符的结合性。

题目 76（单选题）

下列运算符中, 不能够被重载的是

• A. &&

• B. ++

• C. ::

• D. !=

题目 77（单选题）

下列关于运算符函数的描述中，错误的是

• A. 运算符函数的参数可以是类的对象

• B. 运算符函数只能定义为类的成员函数

• C. 运算符函数的名称总是以 operator 为前缀

• D. 在表达式中使用重载的运算符相当于调用运算符重载函数

题目 78（单选题）

下列关于运算符重载的叙述中，错误的是

• A. 有些运算符可以作为非成员函数重载

• B. 所有运算符都可以通过重载而被赋予新的含义

• C. 不得为重载的运算符函数的参数设置默认数值

• D. 有些运算符只能作为类的成员函数形式进行重载

题目 79（单选题）

假定要对类 A 定义加号运算符重载成员函数，实现两个 A 类对象的加法操作, 并返回相加结果。则该成员函数的声明语句为

• A. A operator+(A &a, A &b);

• B. A operator+(A &a);

• C. operator+(A a);

• D. A operator+( );

题目 80（单选题）

假定要对类 A 定义加号运算符重载为友元函数，实现两个 A 类对象的加法操 作, 并返回相加结果。则该成员函数的声明语句为

• A. friend A operator+(A &a, A &b);

• B. friend A operator+(A &a);

• C. friend operator+(A a);

• D. friend A operator+( );

题目 81（单选题）

将运算符重载为类的成员函数时，其参数表中没有参数，说明该运算符为

• A. 不合法的运算符

• B. 无操作数的运算符

• C. 单目运算符

• D. 双目运算符

题目 82（单选题）

运行时的多态性可以通过使用哪种方式获得

• A. 函数重载

• B. 运算符重载

• C. 虚函数与基类指针（或基类引用）

• D. 同名覆盖

题目 83（单选题）

C++ 动态多态性实现的前提条件不包括

• A. 派生类必须公有继承自基类

• B. 派生类与基类必须具有原型相同的函数

• C. 基类内必须有 virtual 函数存在

• D. 派生类至少要包含 1 个纯虚函数

题目 84（单选题）

通过运算符重载，可以改变运算符原有的是

• A. 优先级

• B. 结合性

• C. 操作数类型

• D. 操作数个数

题目 85（单选题）

将运算符”+” 重载为非成员函数，下列函数原型声明中，错误的是

• A. Myclass operator+(Myclass, Myclass);

• B. Myclass operator+(Myclass, double);

• C. Myclass operator+(double, Myclass);

• D. Myclass operator+(double, double);

题目 86（单选题）

若将前缀运算符 ++ 重载为复数类 Complex 的友元函数，下列函数原型声明 中，能正确用于在类中说明的是

• A. Complex& operator++(int);

• B. Complex& operator++(Complex &, int);

• C. friend Complex& operator++(Complex &);

• D. friend Complex& operator++(Complex &, Complex &);

题目 87（单选题）

下列运算符重载的函数原型中，错误的是

• A. friend int operator+(Myclass &, int);

• B. int operator+(Myclass &);

• C. friend Myclass operator=(Myclass &, int);

• D. friend int operator»(istream &, Myclass&);

题目 88（单选题）

给定表达式”operator++(), operator- -(c,0)”, 其中 c 表示某类的对象。则以下叙 述正确的是

• A. 运算符”++”, 是非成员函数重载

• B. 运算符”- -”, 是成员函数重载

• C. 运算符”++”, 是后缀运算符

• D. 运算符”- -”, 是后缀运算符

题目 89（单选题）

在一个类体的下列声明中，正确的纯虚函数声明是

• A. friend virtual void func()=0;

• B. friend virtual void func();

• C. virtual int func(int)=0;

• D. virtual int func(int);

题目 90（单选题）

虚函数必须是类的

• A. 成员函数

• B. 友元函数

• C. 私有函数

• D. 公有函数

题目 91（单选题）

下列关于虚函数和虚基类的说明中，正确的是

• A. 从虚基类继承的函数都是虚函数

• B. 虚基类中的函数都是虚函数

• C. 定义了虚函数的类必须作为虚基类使用

• D. 以上说法都不对

题目 92（单选题）

在一个抽象类中，一定包含有

• A. 虚函数

• B. 纯虚函数

• C. 模板函数

• D. 重载函数

题目 93（单选题）

下面关于虚函数的描述中，错误的是

• A. 虚函数是构成动态多态性的必要条件之一

• B. 纯虚函数一定是虚函数，但虚函数不一定是纯虚函数

• C. 派生类的虚函数名称前面必须要用 virtual 关键字进行修饰

• D. 基类析构函数为虚函数时，其派生类析构函数自动成为虚函数

题目 94（单选题）

一个在基类中说明了虚函数，但是在该基类中没有定义，需要其派生类都必须 定义自己的版本，此类函数被称为

• A. 静态成员函数

• B. 纯虚函数

• C. 虚构造函数

• D. 虚析构函数

题目 95（单选题）

类 Shape 的定义如下： 关于 Shape 类的描述中，正确的是

• A. 类 Shape 是抽象类

• B. 类 Shape 是虚基类

• C. 类 Shape 中的 Draw 函数声明有误

• D. 语句”Shape s;” 能建立 Shape 的一个对象 s

题目 96（单选题）

下面关于纯虚函数与抽象类的描述中，错误的是

• A. 纯虚函数是一种特殊的虚函数，它没有具体的实现

• B. 抽象类是指带有纯虚函数的类

• C. 一个基类中如果具有纯虚函数，该基类的派生类不能再是抽象类

• D. 抽象类只能作为基类来用，其纯虚函数的实现需要由派生类给出

题目 97（单选题）

有如下程序，执行该程序输出的结果是 }; }; A *p = new B; p−>func1(); p−>func2();

• A. A1A2;

• B. B1A2;

• C. B1B2;

• D. A1B2;

题目 98（单选题）

面向对象中设置“纯虚函数和抽象类”的目的是

• A. 提高运行效率

• B. 消除二义性

• C. 统一接口

• D. 简化程序

题目 99（单选题）

下列类中的哪些函数可以成为虚函数

• A. 内联函数

• B. 友元函数

• C. 静态成员函数

• D. 某个被公有继承的函数

题目 100（单选题）

下面程序执行结果是 }; }; }; B b; C c; A *p[2]; p[0]=&b; p[1]=&c; p[0]−>area(); p[1]−>area(); f (b); f (c) ;

• A. BCBC

• B. BBCC

• C. CCBB

• D. CBCB

填空题

题目 1（填空题）

如果将”>>” 作为 c++ 中控制输入的提取符时，其右边只能跟

题目 2（填空题）

在语句”cin>>a ;” 中，cin 在本质上是一个 对象 ，其中的符号 >> 在本质上是一

题目 3（填空题）

C++ 中提供了namespace 来防止命名冲突．C++ 语言提供的名字空间std 涵盖

题目 4（填空题）

面向对象程序设计的三大典型特征为: 封装 , 继承 , 多态

题目 5（填空题）

在 C++ 语言中，throw用于抛出异常。try语句块用于检测异常。catch语句块儿

题目 6（填空题）

在动态内存空间管理方面。C++ 语言用new运算符取代了 c 语言中的 malloc 进

题目 7（填空题）

若要定义一个 int 类型的指针 ptr。请按以下要求分别指出 ptr 能正确的定义形

题目 8（填空题）

关键字

题目 9（填空题）

在 c++ 语言中，对于功能完全相同或类似，只是在形式参数的 个数 、 类型 或

题目 10（填空题）

在定义类的对象时,C++ 程序将自动调用该对象的 构造 函数初始化对象自身.

题目 11（填空题）

对于任意一个类，其类的构造函数通常可以有多个，但析构函数最多只能有1

题目 12（填空题）

当用一个已知对象来初始化一个新对象时，编译系统会自动调用 拷贝 构造函

题目 13（填空题）

在类定义中，如果没有定义，则由系统自动生成的成员函数有: 构造函数、析

题目 14（填空题）

给定全局函数 void func(Date &r), 若将其作为类 Date 的友元函数，则其在类

题目 15（填空题）

已知 print 函数是某个类的常成员函数，没有任何返回值，则该函数在类内的

题目 16（填空题）

对于类内公有的 static 静态成员变量可以通过类名:: 静态成员变量来访问；对

题目 17（填空题）

当类的一个成员函数被某对象调用时，该成员函数的 this 指针将指向调用它

题目 18（填空题）

类与类之间的三种关系包括

题目 19（填空题）

类通过继承可以提高代码的 可重用性 ，通常类与类的继承方式共有三种：

题目 20（填空题）

类的 public 继承方式没有改变基类中数据成员的访问属性，是使用频度最高

题目 21（填空题）

C++ 根据派生类的直接基类的个数，可以划分为 单继承 和 多继承 。

题目 22（填空题）

派生类对象在创建时，其构造函数被调用的先后次序为：首先调用 基类 构造

题目 23（填空题）

派生类对象在创建时，需要负责对其直接基类构造函数的调用，该调用通过在

题目 24（填空题）

在赋值兼容性规则中，要求派生类必须以 public 方式 继承自基类，当程序需

题目 25（填空题）

C++ 采用 内联 函数的目的在于提高程序的运行效率；采用 重载 函数的目的在

题目 26（填空题）

设置虚基类的目的是避免在多重继承（尤其是菱形继承）中产生 二义性 的问

题目 27（填空题）

静态多态的实现方式有两种，分别为： 函数重载 和 运算符重载 。

题目 28（填空题）

C++ 中并非所有的运算符都能被重载，其中有 5 个运算符在类内和类外都无

题目 29（填空题）

动态多态需借助 虚 函数和基类 指针或引用 来实现，在具体实现时需要满足两

题目 30（填空题）

在 C++ 中，含有纯虚函数的类被称为 抽象 类，该类不能定义对象，但是可

判断题

题目 1（判断题）

C++ 语言和 C 语言都是面向对象的程序设计语言

题目 2（判断题）

C 语言是 C++ 语言的一个子集,C++ 语言继承, 改进和扩展了 C 语言

题目 3（判断题）

C++ 语言支持封装性和多态性, 不支持继承性.

题目 4（判断题）

面向过程的程序设计以功能为中心, 而面向对象的程序设计以数据为中心

题目 5（判断题）

同一个问题的求解, 用面向对象的方法一定优于面向过程的方法

题目 6（判断题）

Smalltalk-80 被认为是面向对象程序设计语言的鼻祖.

题目 7（判断题）

C++ 语言和 C 语言一样, 都表现为由一系列函数组成.

题目 8（判断题）

编译 C++ 源程序时出现了警告 (Warning), 也可以生成可执行文件.

题目 9（判断题）

开发 C++ 程序也需要经过编辑, 编译, 链接和运行这四个步骤.

题目 10（判断题）

C++ 语言是由 C 语言发展而来, 因此与 C 语言一样是一种面向过程的语言.

题目 11（判断题）

若用 new 申请了动态空间，则用 delete 释放空间。否则会产生内存垃圾。

题目 12（判断题）

C++ 函数的形式参数可以带有默认值，因此调用时不需要再提供实际参数。

题目 13（判断题）

引用参数与值形式参数一样，对应的实际参数可以是常量、变量、表达式。

题目 14（判断题）

引用与指针用作参数时都可以改变对应实参的值，因此在作形式参数时他们 都需要临时分配内存空间，用以接收实参的信息。

题目 15（判断题）

调用内联函数实际上是用内联函数体的代码替换掉内联函数调用语句。

题目 16（判断题）

在 c++ 语言中，通过在同名全局变量前加上域解析符:: 对被隐藏的同名全局变 量进行访问。这种方式扩大了同名全局变量的作用域，使全局变量真正具有了全 局作用范围。

题目 17（判断题）

类在本质上是一种数据类型，而对象则是类的变量。

题目 18（判断题）

如果用户自定义了类的构造函数，那么系统提供的默认构造函数将不会再被 调用。

题目 19（判断题）

类的拷贝构造函数的形式参数是类的对象类型。

题目 20（判断题）

类的构造函数和析构函数都可以被定义多个, 都可以实现函数重载。

题目 21（判断题）

类的友元函数在本质上并不是类的成员函数，不受类内访问属性的限制，可以 在类内或类外定义函数体。

题目 22（判断题）

已知类 A 是类 B 的友元，类 B 是类 C 的友元，那么类 A 也是类 C 的友元。

题目 23（判断题）

友元打破了类的封装性，但提高了对类内数据成员的访问效率。

题目 24（判断题）

引用本身不再另外占用内存空间，在声明引用时必须立即初始化。

题目 25（判断题）

在建立类的对象数组时，构造函数被调用的次数与数组大小完全相同。

题目 26（判断题）

在建立类对象的时候系统会自动调用与之匹配的构造函数，而定义类对象的 指针变量时不会调用构造函数。

题目 27（判断题）

通过类的构造函数间接实现对类对象的初始化而非直接通过赋值形式进行初 始化是封装性的典型体现。

题目 28（判断题）

静态数据成员的初始化既可以在类内进行，也可以在类外进行。

题目 29（判断题）

静态数据成员都可以通过“类名:: 静态成员变量”方式进行访问。

题目 30（判断题）

静态成员函数可以访问类的普通非静态成员函数。

题目 31（判断题）

普通非静态成员函数可以访问类的静态成员函数。

题目 32（判断题）

静态成员变量被其在的类所有，并可以被类的所有对象共享访问。

题目 33（判断题）

静态成员变量在该类的任何对象被创建之前就已经存在，因此其初始化工作 不能通过类的构造函数完成，必须在类定义结束之后单独进行。

题目 34（判断题）

常数据成员的初始化只能在构造函数的初始化列表中进行，不能在构造函数 的函数体中用赋值等语句实现。

题目 35（判断题）

静态数据成员的初始化不能在构造函数的初始化列表中进行，不能在构造函 数的函数体中进行，只能在类外进行初始化。

题目 36（判断题）

常对象只能调用常成员函数，不可以调用普通的成员函数，因为普通函数是可 以修改数据成员值的。

题目 37（判断题）

常对象的数据成员均为常数据成员。

题目 38（判断题）

关键字 const 不可以作为与其他同名成员函数进行函数重载的标志。

题目 39（判断题）

类的普通对象将优先调用类内的非常成员函数，如果函数不存在，则调用同名 的常成员函数。

题目 40（判断题）

派生类可以作为基类派生出其他的派生类。

题目 41（判断题）

如果基类的构造函数不带参数，则定义一个派生类的对象时不一定会调用基 类的构造函数。

题目 42（判断题）

当生成一个派生类的对象时，无论其直接基类内有没有数据成员，派生类都会 去调用该基类的构造函数。

题目 43（判断题）

派生类中只包含直接基类中的成员，不包含间接基类中的成员。

题目 44（判断题）

在多重继承派生类的构造函数中，调用各个基类的构造函数的顺序取决于各 个基类的构造函数在派生类初始化列表中出现的先后次序。

题目 45（判断题）

多重继承的多个平行基类中，如果有同名成员，则在派生类中访问该成员时， 可以通过采用基类名限定的方法避免二义性或同名冲突。

题目 46（判断题）

根据赋值兼容规则，公有派生类的对象可以赋值给基类的引用，因此可以通过 该引用调用在派生类中新增加的公有成员函数。

题目 47（判断题）

C++ 语言中所有的运算符都可以被重载。

题目 48（判断题）

运算符重载不可以改变其优先级和结合性，也不能改变运算符操作数的个 数。

题目 49（判断题）

运算符重载在本质上是函数重载，重载某运算符时，运算符名称前需要带上 operator 关键字。

题目 50（判断题）

与前缀 ++ 运算符相比较，后缀运算符就是在函数原型中额外增加一个 int 形 式参数加以区别。

题目 51（判断题）

以成员函数形式或友元函数形式重载运算符“+”时的主要区别在于函数内形参 个数的不同。

题目 52（判断题）

静态多态也称为编译时的多态。动态多态也称为运行时多态。

题目 53（判断题）

动态多态性必须通过虚函数以及基类的指针或者基类的引用共同来实现，不 可以通过派生类的指针或其引用来实现。

题目 54（判断题）

内联函数、友元函数和静态成员函数都无法实现动态多态。

题目 55（判断题）

析构函数无法实现动态多态。

题目 56（判断题）

纯虚函数是只有声明没有函数体的函数，该函数只能在抽象类的派生类中进 行具体实现。

题目 57（判断题）

含有 1 个或多个纯虚函数的类一定是抽象类，抽象类无法生成对象，但是可以 被其派生类继承。

题目 58（判断题）

某个派生类倘若没有实现抽象基类的所有纯虚函数，那么该派生类依然是抽 象类。

题目 59（判断题）

通过基类指针或引用调用虚函数与通过对象直接访问虚函数没有区别。

题目 60（判断题）

如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同， 那么派生类内的这个函数自动继承基类中虚函数的特性。