期末复习---面向对象C++考试题目汇总
这些题目我是直接在OneNote上直接复制的，不显示答案，想要OneNote格式的可以在评论区找我要，我私发给你
一、单项选择题（总分 45）
-
（分值： 0.2 分）下列关于运算符重载的描述中，错误的是( )。
A: ::运算符不能重载
B: 类型转换运算符只能作为成员函数重载
C: 将运算符作为非成员函数重载时必须定义为友元
D: 重载[ ]运算符应完成 下标访问 操作
序号： 16 难度： 2 考查点：重载 -
（分值： 0.2 分）将运算符重载为类成员函数时，其参数表中没有参数，说明该运算符是
A: 不合法的运算符
B: 一元运算符
C: 无操作数的运算符
D: 二元运算符
序号： 18 难度： 1 考查点：重载 -
（分值： 0.2 分）下列关于虚基类的描述中，错误的是( )。
A: 使用虚基类可以消除由多继承产生的二义性
B: 构造派生类对象时，虚基类的构造函数只被调用一次
C: 声明”class B : virtual public A”说明类 B 为虚基类
D: 建立派生类对象时，首先调用虚基类的构造函数
序号： 19 难度： 2 考查点：多态性与虚函数 -
（分值： 0.2 分） Sample 是一个类，执行下面语句后，调用 Sample 类的构造函数的次数
是 Sample a[2], *P = new Sample;
A: 0
B: 1
C: 2
D: 3
序号： 20 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下列关于 C++流的描述中，错误的是
A: cout>>'A’表达式可输出字符 A
B: eof()函数可以检测是否到达文件尾
C: 对磁盘文件进行流操作时，必须包含头文件 fstream
D: 以 ios_base::out 模式打开的文件不存在时，将自动建立一个新文件
序号： 26 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）下列字符串中可以用作 C++标识符的是
A: 2009var
B: goto
C: test-2009
D: _123
序号： 32 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）有如下类定义：
class XX
{
int xdata;
public:
XX(int n=0) : xdata(n){}
};
class YY : public XX
{
int ydata;
public:
YY(int m=0, int n=0) : XX(m), ydata(n){}
};
YY 类的对象包含的数据成员的个数是( )。
A: 1
B: 2
C: 3
D: 4
序号： 35 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下列关于运算符函数的描述中，错误的是( )。
A: 运算符函数的名称总是以 operator 为前缀
B: 运算符函数的参数可以是对象
C: 运算符函数只能定义为类的成员函数
D: 在表达式中使用重载的运算符相当于调用运算符重载函数
序号： 36 难度： 2 考查点：重载 -
（分值： 0.2 分）有如下程序：
#include
using namespace std;
class AA
{
int k;
protected:
int n;
void setK(int k){ this->k=k; }
public:
void setN(int n){ this->n=n; }
};
class BB: public AA
{ /类体略/ };
int main( )
{
BB x;
x.n=l; //1#
x.setN(2); //2#
x.k=3; //3#
x.setK(4); //4#
return 0;
}
在标注号码的四条语句中正确的是( )。
A: 1
B: 2
C: 3
D: 4
序号： 59 难度： 1 考查点：类与对象 -
（分值： 0.2 分）已知表达式++a 中的++是作为成员函数重载的运算符，则与++a
等效的运算符函数调用形式为
A: .operator++(1)
B: operator++(a)
C: operator++(a,1)
D: a.operator++()
序号： 61 难度： 1 考查点：重载 -
（分值： 0.2 分）建立一个类对象时，系统自动调用
A: 析构函数
B: 构造函数
C: 静态函数
D: 友元函数
序号： 66 难度： 1 考查点：类与对象 -
（分值： 0.2 分）通过派生类的对象可直接访问其
A: 公有继承基类的公有成员
B: 公有继承基类的私有成员
C: 私有继承基的公有成员
D: 私有继承基类的私有成员
序号： 67 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）运算符重载时不需要保持的性质是
A: 操作数个数
B: 操作数类型
C: 优先级
D: 结合性
序号： 75 难度： 1 考查点：重载 -
（分值： 0.2 分）下列字符串常量中，错误的表示是( )。
A: ““Yes” or"No” "
B: “abcd\n”
C: ′ ABC′
D: “\tOK!”
序号： 106 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）定义变量 int a=6，则 a++的值是__________。
A: 7
B: 6
C: 5
D: 4
序号： 108 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）下列常量中不能作为 c++常量的是__________。
A: 0382
B: 0xB4
C: .5e-2
D: 123
序号： 110 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）定义整型变量 x,y,z 并赋初始值 6 的正确语句是__________。
A: int x=y=z=6;
B: int x=6,y=6,z=6;
C: x=y=z=6;
D: int x,y,z=6;
序号： 113 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）关于 C++和 c 语言的描述中，错误的是__________。
A: C 语言是 C++的一个子集
B: C 语言和 C++是兼容的
C: C++对 C 语言进行了一些改进
D: C 语言和 C++都是面向对象的
序号： 116 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）以下对派生类叙述不正确的是__________。
A: 一个派生类可以作另一个派生类的基类
B: 一个派生类可以有多个基类
C: 具有继承关系时，基类成员在派生类中的访问权限不变
D: 派生类的构造函数与基类的构造函数有成员初始化参数传递关系
序号： 117 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）一个类的友元函数能够访问该类的__________。
A: 私有成员
B: 保护成员
C: 公有成员
D: 所有成员
序号： 119 难度： 1 考查点：类与对象 -
（分值： 0.2 分）有以下类定义：
class A
{
public:
int x;
};
B是类 A 的派生类，且 b 为 B 类对象，若要求正确执行以下语句： b.x=5;则 B 对 A
的继承方式是（ ）。
A: public
B: private
C: protected
D: 都不对
序号： 120 难度： 1 考查点：继承与派生 -
（分值： 0.2 分） C++中的模块包括__________。
A: 对象模块和函数模块
B: 对象模块和类模块
C: 函数模块和类模块
D: 对象模块和变量模块
序号： 121 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下列有关类的说法，不正确的是__________。
A: 类是一种用户自定义的数据类型
B: 只有类中的成员函数或类的友元函数才能存取类中的私有数据
C: 在类中，如果不作特别说明，所有的数据成员均为私有数据成员
D: 在类中，如果不作特别说明，所有的成员均为公有成员
序号： 122 难度： 1 考查点：类与对象 -
（分值： 0.2 分）结构化程序由三种基本结构组成，不包括__________。
A: 顺序结构
B: 选择结构
C: 控制结构
D: 循环结构
序号： 123 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）下列关于构造函数说法不正确的是__________。
A: 构造函数必须与类同名
B: 构造函数可以省略不写
C: 构造函数必须有返回值
D: 在构造函数中可以对类中的成员进行初始化
序号： 127 难度： 1 考查点：类与对象 -
（分值： 0.2 分）用 c++语言编写的代码程序__________。
A: 可立即执行
B: 是一个源程序
C: 经过编译即可执行
D: 经过解释才能执行
序号： 129 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）下列关于 C++语言类的描述中错误的是__________。
A: 类用于描述事物的属性和对事物的操作
B: 类与类之间通过封装而具有明确的独立性
C: 类与类之间必须是平等的关系，而不能组成层次结构
D: 类与类之间可以通过一些方法进行通信和联络
序号： 130 难度： 1 考查点：类与对象 -
（分值： 0.2 分）在面向对象程序设计中，实现信息隐蔽是靠__________。
A: 对象的继承
B: 对象的封装
C: 对象的分类
D: 对象的多态
序号： 132 难度： 1 考查点：类与对象 -
（分值： 0.2 分）在 C++语言中．表示一条语句结束的标号是__________。
A: #
B: ;
C: }
D: //
序号： 138 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）下面 4 个选项中， （ ）是用来声明虚函数的。
A: virtual
B: public
C: using
D: false
序号： 141 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）如果一个类至少有一个纯虚函数，那么就称该类为（ ）。
A: 抽象类
B: 虚函数
C: 派生类
D: 其他都不对
序号： 143 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分） C++类体系中，不能被派生类继承的有（ ）。
A: 构造函数
B: 虚函数
C: 静态成员函数
D: 赋值操作函数
序号： 144 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）下列虚基类的声明中，正确的是（ ）。
A: class virtual B:public A
B: virtual class B:public A
C: class B:public A virtual
D: class B: virtual public A
序号： 145 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）以下关于派生机制的描述中，不正确的是
A: 派生类不仅可以继承基类的成员，也可以添加自己的成员
B: 设置 protected 成员是为派生类访问基类成员之用
C: 采用不同的继承方式，将限制派生类对基类成员的访问
D: 采用私有继承，派生类只能得到基类的公有成员
序号： 147 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）关于虚函数的描述中， （ ）是正确的。
A: 虚函数是一个静态成员函数
B: 虚函数是一个非成员函数
C: 虚函数既可以在函数说明时定义，也可以在函数实现时定义
D: 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型
序号： 148 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）有关类的多态性不正确的说法是_________。
A: 同名函数成员可有不同的参数和类型
B: 同一个操作符可表示不同的处理
C: 同类对象的类定义
D: 模板编程
序号： 163 难度： 1 考查点：类与对象 -
（分值： 0.2 分）有语句定义char a[16];如果从键盘输入一个含空格的字串，可
用语句________。
A: cin>>a;
B: cin>>a[0];
C: cin.get(a,16) ;
D: cin.get(a[0],16);
序号： 166 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）有关类与对象的说法不正确的是______。
A: 类是同类对象的定义
B: 对象是类的具体化实例
C: 类包含对象的具体属性值
D: 类包含同类对象的属性名
序号： 168 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下列关于 c++源程序正确的说法是
A: 每行只能写一个语句
B: 每条语句(包括预处理命令)必须以分号结束
C: 注释语句会生成机器码
D: 最好向右缩进表达程序的层次结构
序号： 183 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）当要用 I/O 流操作文件时，需要包含________文件。
A: iso.h
B: fstream.h
C: iostream.h
D: cmath
序号： 197 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）当要建立一个文件，并从其中读数据和向其中写数据时，应该建立下
面哪种流类的对象_________。
A: ifstream
B: ofstream
C: fstream
D: ios
序号： 199 难度： 1 考查点：输入输出流 -
（分值： 0.2 分） cin 是 I/O 流库预定义的( )。
A: 类
B: 对象
C: 包含文件
D: 常量
序号： 201 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）下面有关类与对象的说法中，错误的是________。
A: 对象是类的实例
B: 一个对象只能属于一个具体的类
C: 一个类只能有一个对象
D: 类和对象的关系与数据类型和变量的关系相似
序号： 202 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下面有关重载的说法中，错误的是 __________。
A: 函数重载要求同名函数在参数个数或参数类型上不同
B: 运算符重载是用同一个运算符针对不同类型数据进行不同的运算操作
C: 所有的运算符都可以重载
D: 运算符重载函数通常是类的成员函数和友元函数
序号： 203 难度： 1 考查点：重载 -
（分值： 0.2 分）关于源程序中注释部分的说法， ___________是正确的。
A: 注释参加编译，出现在目标程序中
B: 注释参加编译，但不出现在目标程序中
C: 注释不参加编译，但出现在目标程序中
D: 注释不参加编译，也不出现在目标程序中
序号： 218 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）编译程序的功能是( )。
A: 将汇编语言程序转换为目标程序
B: 将汇编语言程序转换为高级语言程序
C: 将高级语言程序转换为目标程序
D: 将高级语言程序转换为汇编语言程序
序号： 235 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分） 类的概念是( ) 。
A: 对象的抽象。
B: 同一类记录的集合。
C: 同一类数据的集合。
D: 所有对象的集合。
序号： 240 难度： 1 考查点：类与对象 -
（分值： 0.2 分） C++源程序文件的扩展名为 。
A: .CPP
B: .C
C: .DLL
D: .EXE
序号： 241 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分）以下关于文件操作的叙述中，不正确的是（ ）。
A: 打开文件的目的是使文件对象与磁盘文件建立联系
B: 文件读写过程中，程序将直接与磁盘文件进行数据交换
C: 关闭文件的目的之一是保证将输出的数据写入硬盘文件
D: 关闭文件的目的之一是释放内存中的文件对象
序号： 243 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）若有语句
char str[20]; cin>>str;
当输入为：
This is a C++ program
时， str 所得结果是（ ）
A: This is a C++ program
B: This
C: This is
D: This is a C
序号： 244 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）下列函数中， （ ）是对文件进行写操作的。
A: read()
B: seekg()
C: get()
D: put()
序号： 245 难度： 1 考查点：输入输出流 -
（分值： 0.2 分） cout 是 I/O 流库预定义的（ ）。
A: 类
B: 对象
C: 包含文件
D: 常量
序号： 247 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）下列关于输入流类成员函数 getline( )的描述中，错误的是（ ）。
A: 该函数是用来读取键盘输入的字符串的。
B: 该函数读取的字符串长度是受限制的。
C: 该函数读取字符串时，遇到终止符便停止。
D: 该函数读取字符串时，可以包含空格。
序号： 249 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）语句 ofstream f（”SALARY.DAT”,ios::app ）的功能是建立流对象 f，
并试图打开文件 SALARY.DAT 与 f 关联，而且（ ）。
A: 若文件存在，将其置为空文件；若文件不存在，打开失败
B: 若文件存在，将文件指针定位于文件尾；若文件不存在，建立一个新文件
C: 若文件存在，将文件指针定位于文件首；若文件不存在，打开失败
D: 若文件存在，打开失败；若文件不存在，建立一个新文件
序号： 250 难度： 1 考查点：输入输出流 -
（分值： 0.2 分） C++流中重载了运算符<<，它是一个（ ）。
A: 用于输出操作的成员函数
B: 用于输入操作的非成员函数
C: 用于输入操作的成员函数
D: 用于输出操作的非成员函数
序号： 254 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）下列输出字符 d 的方法中， （ ）是错误的。
A: cout<
C: cout.put(‘d’);
D: char a=‘d’; cout< -
（分值： 0.2 分）在 ios 中提供控制的标志中， （ ）是转换为十六进制形成的标
志位。
A: hex
B: oct
C: dec
D: left
序号： 259 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）使用 setw()对数据进行格式输出时，应包含（ ） 文件。
A: iostream.h
B: fstream.h
C: iomanip.h
D: stdlib.h
序号： 261 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）设有以下类和对象的定义:
class A
{
public:
int k;
};
A x1,x2,*p1,*p2;
则下面针对成员变量 k 的引用，正确的是（ ）。
A: x1->k=1;
B: x2.k=2;
C: p1.k=3;
D: (*p2)->k=4;
序号： 262 难度： 1 考查点：类与对象 -
（分值： 0.2 分）设有以下类的定义：
class Ex
{ int x;
public:
void setx(int t=0);
};
若在类外定义成员函数 setx(),以下定义形式中正确的是（ ）。
A: void setx(int t) {R-}
B: void Ex::setx(int t) {R-}
C: Ex::void setx(int t) {R-}
D: void Ex::setx(){R-}
序号： 263 难度： 1 考查点：类与对象 -
（分值： 0.2 分）如果没有显式定义构造函数（包括复制构造函数）， C++编译器就
（ ）。
A: 出现编译错误
B: 没有构造函数
C: 必须显示定义
D: 隐式定义默认的构造函数
序号： 266 难度： 1 考查点：类与对象 -
（分值： 0.2 分）关于成员函数特征的下述描述中，错误的是（ ）。
A: 成员函数一定是内联函数
B: 成员函数可以重载
C: 成员函数可以设置参数的默认值
D: 成员函数可以是静态的
序号： 269 难度： 1 考查点：类与对象 -
（分值： 0.2 分）对类的构造函数和析构函数描述正确的是（ ）。
A: 构造函数可以重载，析构函数不能重载
B: 构造函数不能重载，析构函数可以重载
C: 构造函数和析构函数均可以重载
D: 构造函数和析构函数均不能重载
序号： 270 难度： 1 考查点：类与对象 -
（分值： 0.2 分）以下有关析构函数的叙述，不正确的是（ ）。
A: 在一个类只能定义一个析构函数
B: 析构函数和构造函数一样可以有形参
C: 析构函数不允许用返回值
D: 析构函数名前必须冠有符号~
序号： 271 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下面关于友元函数描述正确的是（ ）。
A: 友元函数的实现必须在类的内部定义
B: 友元函数是类的成员
C:
友元函数破坏了类的封装性和隐藏性
D: 友元函数不能访问类的私有成员
序号： 272 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下面对静态数据成员的描述中，正确的是（ ）。
A: 类的每一个对象都有自己的静态数据成员
B: 类的不同对象有不同的静态数据成员值
C: 静态数据成员不能通过类的对象调用
D: 静态数据成员是类的所有对象共享的数据
序号： 273 难度： 1 考查点：类与对象 -
（分值： 0.2 分）以下不是构造函数特征的是（ ）。
A: 构造函数的函数名与类名相同
B: 构造函数可以重载
C: 构造函数可以设置默认参数
D: 构造函数必须指定类型说明
序号： 274 难度： 1 考查点：类与对象 -
（分值： 0.2 分）有定义：
char a;
int b;
则 a+4/b 值的数据类型为( )。
A: int
B: char
C: float
D: unsigned
序号： 327 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分） _________不是 Vc++6.0 的开发过程。
A: 创建工程
B: 创建 c++源程序文件
C: 使用 exe 程序
D: 编译源程序
序号： 337 难度： 1 考查点： C++基础知识 -
（分值： 0.2 分） int 变量的字节长度为_______。
A: 8
B: 2
C: 4
D: 10
序号： 345 难度： 1 考查点： C++基础知识 -
（ 分 值 ： 0.2 分 ） 有 以 下 类 定 义 :
class A
{
private:
int x;
protected:
int y;
public:
int z;
};
类 B 是类 A 的公有派生类，在类 B 中不能正确使用的语句是（ ）。
A: x=5;
B: y=6;
C: z=7;
D: 都不能
序号： 355 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下面关于多重继承的叙述，正确的是( )。
A: C++不支持多重继承
B: 多重继承是指从多层基类中派生出的子类
C: 多重继承中派生类成员的访问控制规则与单一继承规则不相同
D: 多重继承中可以通过虚基类防止二义性问题
序号： 359 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下列描述中错误的是( )。
A: 继承分为多重继承和单继承
B: 对象间通信靠传递消息实现
C: 在外面看不到对象的内部特征是基于对象的"模块独立性好"这个特征
D: 类是具有共同属性、共同方法的对象的集合
序号： 361 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）派生类由 public 方式继承基类成员，则( )。
A: 基类中的私有成员可以被派生类的成员函数访问
B: 基类中的保护成员不能被派生类的成员函数访问
C: 基类中的公有成员可以被派生类的成员函数访问
D: 都不正确
序号： 362 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下列特征中不是面向对象方法的主要特征的是( )。
A: 多态性
B: 继承
C: 封装性
D: 模块化
序号： 364 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）有如下的运算符重载函数定义：
double operator +(int i , int k)
{ return double(i+k); }
但定义有错误，对这个错误最准确的描述是( )。
A: +只能作为成员函数重载，而这里的+是作为非成员函数重载的
B: 两个 int 型参数的和也应该是 int 型，而这里将+的返回类型声明为 double
C: 没有将运算符重载函数声明为某个类的友元
D: C++已经提供了求两个 int 型数据之和的运算符+，不能再定义同样的运算符
序号： 366 难度： 1 考查点：重载 -
（分值： 0.2 分）假定 MyCIass 为一个类，那么下列的函数说明中， ( )为该类的析
构函数。
A: void ~MyClass( );
B: ~MyClass(int n);
C: MyClass( );
D: ~MyClass( );
序号： 367 难度： 1 考查点：类与对象 -
（分值： 0.2 分）下列对重载函数的描述中，错误的是( )。
A: 重载函数中不允许使用默认参数
B: 重载函数中编译是根据参数表进行选择的
C: 不要使用重载函数来描述毫不相干的函数
D: 构造函数重载将会给初始化带来多种方式
序号： 368 难度： 1 考查点：重载 -
（分值： 0.2 分）下面有关重载函数的描述中，正确的是( )。
A: 重载函数必须具有不同的返回值类型
B: 重载函数形参个数必须不同
C: 重载函数必须具有不同的形参列表
D: 重载函数名可以不同
序号： 369 难度： 1 考查点：重载 -
（分值： 0.2 分）下列关于 getline( )函数的描述中，错误的是( )。
A: 该函数可以用来从键盘上读取字符串
B: 该函数读取的字符串长度是受限制的
C: 该函数读取字符串时，遇到终止符时便停止
D: 该函数中所使用的终止符只能是换行符
序号： 371 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）如果类之间具有继承和派生关系，那么它们之间应具有以下几个特征：
1）类之间应具有共享的特征；
2）类之间应具有差别或新增特征；
3）类之间是一种层次结构；
上述中正确的是
A: 1）、 2）
B: 2）、 3）
C: 1）、 3）
D: 1）、 2）、 3）
序号： 374 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下面哪些对象属于继承与派生的关系： 1）交通工具与汽车 2）汽车
与轮胎 3）动物与老虎 4）电脑与内存
A: 1）和 2）
B: 3）和 4）
C: 1 ）和 3）
D: 2）和 4）
序号： 375 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）关于运算符重载，下列表述中正确的是（ ）。
A: C++已有的任何运算符都可以重载
B: 运算符函数的返回类型不能声明为基本数据类型
C: 在类型转换符函数的定义中不需要声明返回类型
D: 可以通过运算符重载来创建 C++中原来没有的运算符
序号： 376 难度： 1 考查点：重载 -
（分值： 0.2 分）设有基类定义：
class cBase
{
private:
int a;
protected:
int b;
public:
int c;
};
派生类采用( )继承方式可以使成员变量 b 成为自己的私有成员。
A: 私有继承
B: 保护继承
C: 公有继承
D: 都可以
序号： 377 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）以下哪个基类中的成员函数表示纯虚函数________。
A: virtual void tt()=0;
B: void tt(int)=0;
C: virtual void tt(int);
D: virtual void tt(int){ };
序号： 385 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）设有以下定义：
#include
class A1
{
public:
void show1()
{
cout<<“class A1”<
class A2:public A1
{
public:
void show2(){cout<<“class A2”<
class A3:protected A2
{
public:
void show3(){cout<<“class A3”<
void main()
{
A1 obj1;
A2 obj2;
A3 obj3;
}
以下不合法的调用语句是( )。
A: obj1.show1();
B: obj2.show1();
C: obj3.show1();
D: obj2.show2();
序号： 386 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下面正确的说法是________。
A: 关键字 virtual 只能用来声明虚函数
B: 声明虚函数时，才使用关键字 virtual
C: 关键字 virtual 不能用来声明虚基类
D: 关键字 virtual 能用来声明虚基类
序号： 389 难度： 1 考查点：多态性与虚函数 -
（分值： 0.2 分）下列关于运算符重载的描述中，正确的是_______。
A: 运算符重载可以改变操作数个数
B: 运算符重载可以改变优先级
C: 运算符重载可以改变结合性
D: 运算符重载不可以改变语法结构
序号： 391 难度： 1 考查点：重载 -
（分值： 0.2 分）在下列运算符中，不能重载的是________。
A: <=
B: >>
C: ::
D: &=
序号： 392 难度： 1 考查点：重载 -
（分值： 0.2 分） vehicle 类已定义，对于以下派生类的定义语句：
class car:public vehicle
{
private:
char *model;
int wheelNo;
};指出针对该定义的正确说法是( )。
A: vehicle 类是 car 类的一个子类，因而它可以被继承
B: car 类是父类， vehicle 类是子类
C: 在 car 类中定义的成员 model 和 wheelNo 会删除 vehicle 类中同名的成员
D: car 类是 vehicle 类的一个派生类，它可以继承 vehicle 类中除构造函数和析构函数以外的
所有成员
序号： 393 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下面叙述不正确的是________。
A: 成员的访问能力在私有派生类中和公有派生类中是不同的
B: 基类的私有成员在公有派生类中不可访问
C: 赋值兼容规则不是用于多重继承的组合
D: 基类公有成员在保护派生中是保护的
序号： 394 难度： 1 考查点：继承与派生
92.（分值： 0.2 分）已知类A是类B的基类，类B是类C的基类， 执行以下语句：C c1;
则它们的构造函数一共会被调用( )。
A: 1 次
B: 2 次
C: 3 次
D:多次
序号： 395 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）设置虚基类的目的是( )。
A: 简化程序
B: 消除二义性
C: 提高运行效率
D: 减少目标代码
序号： 396 难度： 1 考查点：继承与派生 -
（分值： 0.2 分） 有如下类定义
class A
{
public:
int x;
};
class B:virtual public A{};
class C:virtual public A{};
class D:public B, public C{};
现定义 D 类对象 d，则以下正确的是( )。
A: d.x=5;
B: 出现二义性
C: 会调用 5 次构造函数
D: 都不对
序号： 400 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）在多重继承中，公有派生和私有派生对于基类成员在派生类中的访问
性与单一继承的规则( )。
A: 相同
B: 不同
C: 部分相同，部分不同
D: 都不对
序号： 402 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下面叙述不正确的是( )。
A: 派生类一般都用公有派生
B: 对基类成员的访问必须是无二义性的
C: 赋值兼容规则也适用于多重继承的组合
D: 基类的公有成员在派生类中仍然是公有的
序号： 404 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）能被派生类继承的函数是( )。
A: 静态成员函数
B: 构造函数
C: 析构函数
D: 复制的构造函数
序号： 406 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）不论派生类以何种方式继承，都不能使用基类的（ ）。
A: 公有成员
B: 私有成员
C: 保护成员
D: 公有成员和保护成员
序号： 407 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下面关于继承的描述中，错误的是________。
A: 继承描述的是类的层次关系，派生类可以具有与基类相同的属性和方法
B: 一个基类可以有多个派生类，一个派生类可以有多个基类
C: C++有两种继承包括单一继承和多重继承
D: 静态成员不可以被继承
序号： 408 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）在 C++中，类与类之间的继承关系具有________。
A: 自反性
B: 对称性
C: 传递性
D: 规律性
序号： 410 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下列运算符中全都可以被友元函数重载的是( )。
A: =， +， -，
B: []， +， ()， new
C: ->， +， *， >>
D: <<， >>， +， *
序号： 412 难度： 1 考查点：重载 -
（分值： 0.2 分）假定要对类 AB 定义加号操作符重载成员函数，实现两个 AB 类对象
的加法，并返回相加结果，则该成员函数的声明语句为( )。
A: AB operator+(AB &a, AB &)
B: AB operator+(AB &)
C: opetacor+(AB a)
D: AB &operator+( )
序号： 413 难度： 1 考查点：重载 -
（分值： 0.2 分）假设类 X 以类 Y 作为它的一个基类，并且 X 类的名字 func()支配 Y
类的名字 func()， obj 为类 X 的对象，则 obj.func()语句实现的功能为________。
A: 先执行类 X 的 func()，再执行访问类 Y 的 func()
B: 先执行类 Y 的 func()，再执行访问类 X 的 func()
C: 执行类 X 的 func()
D: 执行类 Y 的 func()
序号： 414 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）以下叙述错误的是( )。
A: 基类的保护成员在公有派生类中仍然是保护成员
B: 基类的保护成员在派生类中仍然是保护成员
C: 基类的保护成员在私有派生中是私有成员
D: 基类的保护成员不能被派生类的对象访问
序号： 418 难度： 1 考查点：继承与派生 -
（分值： 0.2 分）下列关于 C++流的说明中，正确的是( )。
A: 与键盘、屏幕、打印机和通信端口的交互都可以通过流类来实现
B: 从流中获取数据的操作称为插入操作，向流中添加数据的操作称为提取操作
C: cin 是一个预定义的输出流类
D: 输出流有一个名为 open 的成员函数，其作用是生成一个新的流对象
序号： 424 难度： 1 考查点：输入输出流 -
（分值： 0.2 分）一个函数为 void f(int, char ch=‘a’)，另一个函数为 void f( int )，则它
们( )。
A: 不能在同一程序中定义
B: 可以在同一程序中定义并可重载
C: 可以在同一程序中定义，但不可以重载
D: 其他三种说法均不正确
序号： 428 难度： 1 考查点：重载 -
（分值： 0.2 分）下列是重载乘法运算符的函数原型声明，其中错误的是 ( )。
A: MyClass operator*(double, double) ;
B: MyClass operator*(double, MyClass);
C: MyClass operator*(MyClass,double);
D: MyClass operator*(MyClass, MyClass);
序号： 429 难度： 1 考查点：重载 -
（分值： 0.2 分） ( ) 既可重载为一元运算符，又可重载为二元运算符。
A: *
B: =
C: = 和 *
D: * 和 ++
序号： 430 难度： 1 考查点：重载
109.（分值： 0.2 分） 在派生类中定义虚函数时，可与基类中相应的虚函数不同的是________。
A: 参数类型
B: 参数个数
C: 函数名称
D: 函数体
序号： 431 难度： 1 考查点：多态性与虚函数
110. （分值： 0.2 分）有以下类定义：
class A
{
public:
virtual void f1(){cout<<1;};
void f2(){cout<<2;};
};
class B:public A
{
public:
void f1(){cout<<3;}
void f2(){cout<<4;}
};
若 b为 B 类对象， p 为 A 类指针，则下列选项正确的是( )。
A: 执行： p=&b; p->f1();语句，输出 3
B: 执行： p=&b; p->f2();语句，输出 4
C: 执行： p=&b; p->f1();语句，输出 2
D: 执行： p=&b; p->f2();语句，输出 1
序号： 435 难度： 1 考查点：多态性与虚函数
111. （分值： 0.2 分）在 C++中，运算对象必须为整型数的运算符是（ ）。
A: %
B: /
C: *
D: %和*
序号： 441 难度： 1 考查点： C++基础知识
112. （分值： 0.2 分）在以下选项中，可以用做变量名的是（ ）。
A: 2
B: sum
C: int
D: p
序号： 442 难度： 1 考查点： C++基础知识
113. （分值： 0.2 分）关于友元，下列说法正确的是（ ）。
A: a 类为 b 类的友元类，则 a 类中的所有函数就可以访问 b 类中的所有成员
B: 友元函数的定义在类体中
C: 友元只能是类
D: 友元只能是函数
序号： 467 难度： 1 考查点：类与对象
114. （分值： 0.2 分）对于语句 cout<
A: cout 是一个输出流对象
B: endl 的作用是输出回车换行
C: x 是一个变量
D: << 称作提取运算符
序号： 473 难度： 1 考查点：输入输出流
115. （ 分 值 ： 0.2 分 ）若有定义：
int a=10;
float x=2.6,y=5.1;
则表达式x+a%3
A: 2.8
B: 2.6
C: 2.4
D: 3.0
序号： 477 难度： 1 考查点： C++基础知识
116. （分值： 0.2 分）下列选项中不属于C++的类型的是（ ）。
A: signed short int
B: unsigned long int
C: unsigned int
D: long short
序号： 479 难度： 1 考查点： C++基础知识
117. （分值： 0.2 分）有如下表达式 19/3sqrt(4.0)/5，则该表达式值数据类型为（ ）。
A: int
B: float
C: double
D: 不确定
序号： 483 难度： 1 考查点： C++基础知识
118. （分值： 0.2 分）以下整型变量 a 定义后赋初值的结果是（ ）。 int a=2.86;
A: 12
B: 16
C: 17
D: 18
序号： 487 难度： 1 考查点： C++基础知识
119. （分值： 0.2 分）下列关于圆括号运算符的功能说法不正确的是（ ）。
A: 可用于强制类型转换
B: 可用于类型构造
C: 可用于类型声明
D: 可用于函数调用
序号： 489 难度： 1 考查点： C++基础知识
120. （分值： 0.2 分）设以下变量都已定义，下列选项中不正确的赋值表达式是（ ）。
A: ++k
B: n1 = n2 = n3
C: k = I == 1
D: a=b+c=1
序号： 490 难度： 1 考查点： C++基础知识
121. （分值： 0.2 分） 设 int b=12，表达式 b+=b-=bb 求值后 b 的值是（ ）。
A: 552
B: 264
C: 144
D: -264
序号： 491 难度： 1 考查点： C++基础知识
122. （分值： 0.2 分）在面向对象程序设计中，实现信息隐蔽是靠（ ）。
A: 对象的继承
B: 对象的封装
C: 对象的分类
D: 对象的多态
序号： 493 难度： 1 考查点：类与对象
123. （分值： 0.2 分）下列描述中（ ）是正确的。
A: 私有派生的子类无法访问父类的成员
B: 类 A 的私有派生子类的派生类 C 无法初始化其祖先类 A 对象的属性，因为类 A 的成员
对类 C 是不可访问的
C: 私有派生类不能作为基类派生子类
D: 私有派生类的所有子孙类将无法继续继承该类的成员
序号： 494 难度： 1 考查点：继承与派生
124. （分值： 0.2 分）派生类的成员函数不能访问基类的（ ）。
A: 公有成员和保护成员
B: 公有成员
C: 保护成员
D: 私有成员
序号： 496 难度： 1 考查点：继承与派生
125. （分值： 0.2 分）二进制文件与文本文件不同的是（ ）。
A: 二进制文件中每字节数据都没有用 ASCII 码表示
B: 二进制文件包含了 ASCII 码控制符
C: 二进制文件一般以字符\0结束
D: 二进制文件用字符 endl 表示行的结束
序号： 501 难度： 1 考查点：输入输出流
126. （分值： 0.2 分）下面有关重载的说法中，错误的是（ ）。
A: 函数重载要求同名函数在参数个数或参数类型上不同
B: 运算符重载是用同一个运算符针对不同类型数据进行不同的运算操作
C: 所有的运算符都可以重载
D: 运算符重载函数通常是类的成员函数和友元函数
序号： 502 难度： 1 考查点：重载
127. （分值： 0.2 分） cin 是 I/O 流库预定义的（ ）。
A: 类
B: 对象
C: 包含文件
D: 常量
序号： 503 难度： 1 考查点：输入输出流
128. （分值： 0.2 分）当要用 I/O 流操作文件时，需要包含（ ）文件。
A: iso
B: fstream
C: iostream
D: cmath
序号： 505 难度： 1 考查点：输入输出流
129. （分值： 0.2 分）对类成员访问权限的控制，是通过设置成员的访问控制属性实现的，
下列不是访问控制属性的是（ ）。
A: 公有类型
B: 私有类型
C: 保护类型
D: 友元类型
序号： 506 难度： 1 考查点：类与对象
130. （ 分 值 ： 0.2 分 ） 有 以 下 类 定 义 ：
class B
{
protected:
int count;
public:
B(int c):count©{ };
virtual void Print()=0;
};
class D:public B
{
public:
D(int c):B©{};
void Print(){cout<
void main()
{
D d(10); //①
B
B b(5); //③
pb->Print(); //④
}
①、②、③、④四个语句编译时错误的是（ ）。
A: D d(10);
B: B *pb=&d;
C: B b(5);
D: pb->Print();
序号： 508 难度： 1 考查点：多态性与虚函数
131. （分值： 0.2 分）下面关于虚函数和函数重载的叙述不正确的是（ ）。
A: 虚函数不是类的成员函数
B: 虚函数实现了 C++的多态性
C: 函数重载允许非成员函数重载，而虚函数则不行
D: 函数重载的调用根据参数的个数、序列来确定，而虚函数依据对象确定
序号： 510 难度： 1 考查点：多态性与虚函数
132. （分值： 0.2 分）下述静态数据成员的特征中， （ ）是错误的。
A: 说明静态数据成员时前边要加修饰符static
B: 静态数据成员要在类体外进行初始化
C: 引用静态数据成员时，要在静态数据成员名前加<类名 >和作用域运算符
D: 静态数据成员不是所有对象所共用的
序号： 533 难度： 1 考查点：类与对象
133. （分值： 0.2 分）以下选项中，合法的标识符是（ ）。
A: long
B: 2Test
C: 3Dmax
D: A.dat
序号： 535 难度： 1 考查点： C++基础知识
134. （分值： 0.2 分）在 C++语言中，自定义的标识符（ ）。
A: 能使用关键字并且不区分大小写。
B: 不能使用关键字并且不区分大小写。
C: 能使用关键字并且区分大小写。
D: 不能使用关键字并且区分大小写。
序号： 536 难度： 1 考查点： C++基础知识
135. （分值： 0.2 分）派生类的对象对它的基类成员中可以访问的是（ ）。
A: 公有继承的公有成员
B: 公有继承的私有成员
C: 公有继承的保护成员
D: 私有继承的公有成员
序号： 570 难度： 1 考查点：继承与派生
136. （分值： 0.2 分）在下面的类定义中，①、②、③、④四句编译时出现错误的是（ ）。
class A //①
{
public: //②
A(){func();}//③
virtual void func()=0; //④
};
A: class A
B: public:
C: A(){ func(); }
D: virtual void func()=0 ;
序号： 572 难度： 1 考查点：多态性与虚函数
137. （分值： 0.2 分）如果类 A 继承了类 B，则类 A 称为（ ）。
A: 基类
B: 派生类
C: 虚基类
D: 没有关系
序号： 573 难度： 1 考查点：继承与派生
138. （分值： 0.2 分）有以下类定义：
class A{int x;};
class B:virtual public A{int y;};
class C:virtual public A{int z;};
class D:public B, public C{};
则对于 D 类对象 d，以下正确的选项是（ ）。
A: 有 3 个成员
B: 有 4 个成员
C: 没有成员
D: 有 2 个成员
序号： 576 难度： 1 考查点：继承与派生
139. （分值： 0.2 分）若要把函数 void f()定义为类 aClass 的友元函数，则应该在类 aClass
定义中加入的语句是（）。
A: void f()
B: static void f()
C: friend f()
D: friend void f()
序号： 585 难度： 1 考查点：类与对象
140. （分值： 0.2 分）下面对运算符重载的描述正确的是（ ）
A: 运算符重载可以改变优先级。
B: 运算符重载可以改变结合性。
C: 运算符重载可以改变语法结构。
D: 运算符重载不可以改变运算符的操作数的个数。
序号： 589 难度： 2 考查点：重载
141. （分值： 0.2 分） C++语言建立类族是通过（ ）实现的。
A: 类的嵌套
B: 虚函数
C: 类的继承
D: 抽象类
序号： 592 难度： 1 考查点：继承与派生
142. （分值： 0.2 分）磁盘文件操作时，打开磁盘文件的访问方式常量中， （ ）是以追加方
式打开文件的。
A: in
B: out
C: app
D: ate
序号： 599 难度： 1 考查点：输入输出流
143. （分值： 0.2 分）当使用 ifstream 流定义一个流对象并打开一个磁盘文件时，文件的隐
含打开方式为（ ）。
A: ios::in
B: ios::out
C: ios::trunk
D: ios::binary
序号： 601 难度： 1 考查点：输入输出流
144. （分值： 0.2 分）已知大写字母 A 的 ASCII 码值是 65，小写字母 a 的 ASCII 码是 97，
则用八进制表示的字符常量"\101"是
A: 字符 A
B: 字符 a
C: 字符 e
D: 非法的常量
序号： 605 难度： 1 考查点： C++基础知识
145. （分值： 0.2 分）以下非法的赋值语句是
A: n=(i=2,++i)；
B: j++;
C: ++(i+1);
D: x=j>0；
序号： 615 难度： 1 考查点： C++基础知识
146. （分值： 0.2 分）下面正确的赋值语句是
A: a=7+b+c=a+7;
B: a=7+b++=a+7;
C: a=(7+b,b++,a+7)；
D: a=7+b,c=a+7；
序号： 616 难度： 1 考查点： C++基础知识
147. （分值： 0.2 分）语句 cout<<(a=2)&&(h=-2)；的输出结果是
A: 无输出
B: 编译错误
C: -l
D: 1
序号： 617 难度： 1 考查点： C++基础知识
148. （分值： 0.2 分） int x=3,y=4,z=5;则值为 0 的表达式是（ ）
A: x>y++
B: x<=++y
C: x!=y+z>y-z
D: y%z>=y-z
序号： 623 难度： 1 考查点： C++基础知识
149. （分值： 0.2 分）对字符常量与字符串常量的描述不正确的是（ ）。
A: 两者表示形式不同：前者使用单引号，后者使用双引号
B: 两者存放方式不同：前者存放在字符变量中，后者存放在字符数组或字符指针指定的位置
C: 存放字符串常量时系统会自动加一个结束符’‘\0’’
D: 字符和字符串都能参与连接运算
序号： 626 难度： 1 考查点： C++基础知识
150. （分值： 0.2 分） Visual C++中打开一个已存在的项目，应打开其中后缀名为( )
的文件。
A: htm
B: h
C: dsw
D: cpp
序号： 630 难度： 1 考查点： C++基础知识
151. （ 分 值 ： 0.2 分 ） 下 列 程 序 中 ， 划 线 处 正 确 的 语 句 是 ( ) 。 class Base
{
public:
void fun(){cout<<“Base::fun”<
class D :public Base
{
public:
void fun()
{
__________ ;//显式调用基类的函数fun()
cout<<“D::fun”<
};
A: fun()
B: Base.fun()
C: Base::fun()
D: Base->fun()
序号： 666 难度： 1 考查点：继承与派生
152. （分值： 0.2 分）设 MClass 是一个类，有以下定义： MClass dd,*pp=ⅆ则指针变量
pp 可以通过（ ）访问对象 dd 的成员。
A: ∷
B: .
C: &
D: ->
序号： 667 难度： 1 考查点：类与对象
153. （分值： 0.2 分）以下不属于类访问权限的是（ ）。
A: public
B: static
C: protected
D: private
序号： 668 难度： 1 考查点：类与对象
154. （分值： 0.2 分）有类定义如下：
class X
{
int a;
public:
X( int x=0 ){ a=x; }
};
class Y:public X
{
int b;
public:
Y(int x=0,int y=0):X(y){ b=x; }
};
下列定义对象的语句组中出现语法错误的是( )。
A: X *pa=new Y(1,2);
B: X a1=Y(1,3);
C: Y b1(2,3); X &a3=b1;
D: X a4(10); Y b2=a4;
序号： 669 难度： 1 考查点：继承与派生
155. （分值： 0.2 分）下列关于布尔型数据与数值型数据的转换说法中，错误的是( )。
A: 布尔量 true 当数值使用时相当于 1；
B: 布尔量 false 当数值量使用时相当于 0；
C: 数值量－1 当布尔量使用时相当于 false；
D: 数值量 0 当布尔量使用时相当于 false；
序号： 671 难度： 1 考查点： C++基础知识
156. （分值： 0.2 分）已知 f1(int)是类 A 的公有成员函数， p 是指向成员函数 f1()的指针，
采用（ ）是正确的。
A: p = f1
B: p = A::f1
C: p = A::f1()
D: p = f1()
序号： 675 难度： 1 考查点：类与对象
157. （分值： 0.2 分）已知 p 是一个指向类 A 的公有数据成员 m 的指针， A1 是类 A 的一个
对象。如果要将 A1 的 m 赋值为 5， （ ）是正确的。
A: A1.p = 5
B: A1->p = 5
C: A1.*p = 5
D: *A1.p = 5
序号： 676 难度： 1 考查点：类与对象
158. （分值： 0.2 分）控制格式 I/O 的操作中， （ ）是设置域宽的。
A: ws
B: oct
C: setfill()
D: setw()
序号： 678 难度： 1 考查点：输入输出流
159. （分值： 0.2 分） 实现运行时的多态性要使用( )。
A: 虚函数
B: 重载函数
C: 析构函数
D: 构造函数
序号： 687 难度： 1 考查点：多态性与虚函数
160.（分值： 0.2 分） 有以下重载函数定义：
int max(int a,int b){return a>b?a:b;}
double max(double a,double b){return a>b?a:b;}
char max(char a,char b){return a>b?a:b;}
则下列（ ）是错误的函数调用形式。
A: max(3, 5.5)
B: max(3, 5)
C: max(3.3, 5.5)
D: max(´3´, ´5´)
序号： 689 难度： 1 考查点：重载
161. （分值： 0.2 分）在类 A 中有虚函数的声明： virtual int f(int x, int y); 则在 A 的派生
类 B 中，以下（ ）选项是正确的虚函数声明。
A: int f(int x, int y);
B: int f(int x);
C: void f(int x, int y);
D: virtual int f(double x, double y);
序号： 691 难度： 1 考查点：多态性与虚函数
162. （分值： 0.2 分）有函数声明： int f(int x); 则以下（ ）选项是正确的函数重载。
A: double f(double x);
B: double f(int x);
C: int f( int );
D: int f(int y);
序号： 692 难度： 1 考查点：重载
163. （分值： 0.2 分）定义析构函数时，应该注意（ ）
A: 其名与类名完全相同
B: 返回类型是 void 类型
C: 无形参，也不可重载
D: 函数体中必须有 delete 语句
序号： 693 难度： 2 考查点：类与对象
164. （分值： 0.2 分）对于常成员函数，下面描述正确的是()
A: 类的成员函数可以操作常对象
B: 类的成员函数不能操作常对象
C: 只有常成员函数可以操作常对象
D: 在常成员函数中，常对象可以被更新
序号： 694 难度： 2 考查点：类与对象
165. （分值： 0.2 分） 下述静态成员的特性中，（ ）是错误的。
A: 静态成员函数不能利用 this 指针
B: 静态数据成员要在类体外进行初始化
C: 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符
D: 静态数据成员不是所有对象所共有的
序号： 695 难度： 2 考查点：类与对象
166. （分值： 0.2 分）下列是构造函数的特点，（ ）是错误的 。
A: 构造函数是一种成员函数，它具有一般成员函数的特点
B: 构造函数的名称与其类名相同
C: 构造函数必须指明其类型
D: 一个类中可定义一个或多个构造函数
序号： 696 难度： 2 考查点：类与对象
167. （分值： 0.2 分）下面概念中，不属于面向对象方法的是
A: 对象、消息
B: 继承、多态
C: 类、封装
D: 过程调用
序号： 697 难度： 2 考查点：类与对象
168. （分值： 0.2 分）为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能
把该成员的访问权限定义为（ ）。
A: public
B: protected
C: private
D: static
序号： 698 难度： 2 考查点：类与对象
169. （分值： 0.2 分）下面对静态数据成员的描述中，正确的是（ ）。
A: 静态数据成员是类的所有对象共享的数据
B: 类的每一个对象都有自己的静态数据成员
C: 类的不同对象有不同的静态数据成员值
D: 静态数据成员不能通过类的对象调用
序号： 699 难度： 2 考查点：类与对象
170. （分值： 0.2 分）下列表达方式正确的是（ ）。
A: class P{public： int x=15； void show(){cout<
D: class P{public： void Seta (int x) {a=x;}；
序号： 702 难度： 2 考查点：类与对象
171. （分值： 0.2 分）关于友元的描述中， （ ）是错误的。
A: 友元函数是成员函数，它被说明在类体内
B: 友元函数可直接访问类中的私有成员
C: 友元函数破坏封装性，使用时尽量少用
D: 友元类中的所有成员函数都是友元函数
序号： 703 难度： 2 考查点：类与对象
172. （分值： 0.2 分）下列关于 this 指针的叙述中，正确的是（ ）。
A: 任何与类相关的函数都有 this 指针
B: 类的成员函数都有 this 指针
C: 类的友元函数都有 this 指针
D: 类的非静态成员函数才有 this 指针
序号： 705 难度： 2 考查点：类与对象
173. （分值： 0.2 分）下列有关内联函数的叙述中，正确的是______。
A: 内联函数在调用时发生控制转移
B: 内联函数必须通过关键字 inline 来定义
C: 内联函数是通过编译器来实现的
D: 内联函数体的最后一条语句必须是 rennin 语句
序号： 706 难度： 2 考查点：类与对象
174. （分值： 0.2 分）下列情况中，不会调用拷贝构造函数的是______。
A: 用一个对象去初始化同一类的另一个新对象时
B: 将类的一个对象赋予该类的另一个对象时
C: 函数的形参是类的对象，调用函数进行形参和实参结合时
D: 函数的返回值是类的对象，函数执行返回调用时
序号： 707 难度： 2 考查点：类与对象
175. （分值： 0.2 分）（ ）的功能是对象进行初始化。
A: 析构函数
B: 数据成员
C: 构造函数
D: 静态成员函数
序号： 708 难度： 2 考查点：类与对象
176. （分值： 0.2 分）下面（ ）项是对构造函数和析构函数的正确定义。
A: void X::X(), void X::~X()
B: X::X(参数), X::~X()
C: X::X(参数), X::~X(参数)
D: void X::X(参数), void X::~X(参数)
序号： 709 难度： 2 考查点：类与对象
177. （分值： 0.2 分）下列关于模板的叙述中，错误的是（ ）。
A: 模板声明中的第一个符号总是关键字 template
B: 在模板声明中用 < 和 > 括起来的部分是模板的形参表
C: 类模板不能有数据成员
D: 在一定条件下函数模板的实参可以省略
序号： 710 难度： 2 考查点：类与对象
178. （分值： 0.2 分）有如下类声明： class Foo { int bar; };则 Foo 类的成员 bar 是（ ）。
A: 公有数据成员
B: 公有成员函数
C: 私有数据成员
D: 私有成员函数
序号： 711 难度： 2 考查点：类与对象
179. （分值： 0.2 分）在下列函数原型中，可以作为类 AA 构造函数的是（ ）。
A: void AA(int);
B: int AA( );
C: AA(int)const;
D: AA(int);
序号： 712 难度： 2 考查点：类与对象
180. （分值： 0.2 分）下列有关类的说法不正确的是（ ）。
A: 对象是类的一个实例
B: 任何一个对象只能属于一个具体的类
C: 一个类只能有一个对象
D: 类与对象的关系和数据类型与变量的关系相似
序号： 713 难度： 2 考查点：类与对象
181. （分值： 0.2 分）在用关键字 class 定义的类中，以下叙述正确的是( )。
A: 在类中，不作特别说明的数据成员均为私有类型
B: 在类中，不作特别说明的数据成员均为公有类型
C: 类成员的定义必须是成员变量定义在前，成员函数定义在后
D: 类的成员定义必须放在类定义体内部
序号： 714 难度： 2 考查点：类与对象
182. （分值： 0.2 分）下面对静态数据成员的描述中，正确的是（ ）。
A: 静态数据成员可以在类体内进行初始化
B: 静态数据成员不可以在类体内进行初始化
C: 静态数据成员不能受 private 控制符的作用
D: 静态数据成员不可以直接用类名调用
序号： 715 难度： 2 考查点：类与对象
183. （分值： 0.2 分）下面对于友元函数描述正确的是（ ）。
A: 友元函数的实现必须在类的内部定义
B: 友元函数是类的成员
C: 友元函数破坏了类的封装性和隐藏性
D: 友元函数不能访问类的私有成员
序号： 716 难度： 2 考查点：类与对象
184. （分值： 0.2 分）在类外部可以用 p.a 的形式访问派生类对象 p 的基类成员 a，则 a 应
是( )。
A: A.私有继承的公有成员
B: B.公有继承的私有成员
C: C.公有继承的保护成员
D: D.公有继承的公有成员
序号： 717 难度： 1 考查点：继承与派生
185. （分值： 0.2 分）解决基类私有成员在派生类中只能通过基类的（）访问。
A: A 公有成员函数
B: B 私有成员函数
C: B 私有成员数据
D: B 公有成员数据
序号： 718 难度： 1 考查点：继承与派生
186. （分值： 0.2 分）表现在计算过程中的被 0 除、内存空间不足、数据的输入输出错误等
是程序的（ ）。
A: A 运行错误
B: B 编译链接错误
C: C 模式错误
D: D.调用错误
序号： 719 难度： 1 考查点： C++工具
187. （分值： 0.2 分） C 语言处理错误时可使用 C 信号处理库中的（ ）函数设
置中断信号处理。
A: A signal
B: B raise
C: C unexpected
D: D private
序号： 720 难度： 1 考查点： C++工具
188. （分值： 0.2 分）异常对象的捕获和处理是由（ ）结构实现的。
A: A try - throw
B: B try - catch
C: C catch - try
D: D throw - try
序号： 721 难度： 1 考查点： C++工具
189. （分值： 0.2 分）如果引起异常的是致命错误，即表明程序运行进入了无法恢复正常运
行的状态，这时必须调用（ ）。
A: A 终止模式
B: B 恢复模式
C: C 调用模式
D: D 返回模式
序号： 722 难度： 1 考查点： C++工具
190. （分值： 0.2 分）自定义类型的异常对象在匹配过程中，会发生类型的隐含转换吗？
A: A 不会
B: B 会
C: C 不一定
D: D 不知道
序号： 723 难度： 1 考查点： C++工具
191. （分值： 0.2 分）在已存在的异常到达引起捕获之前又抛出一个新的异常，这会导致对
（ ）的调用。
A: A unexpected()
B: B terminate()
C: C expected()
D: D unterminate()
序号： 724 难度： 1 考查点： C++工具
192. （分值： 0.2 分）当一个异常对象抛出时，异常处理器会根据被抛出异常对象的类型顺
序匹配（ ）的异常处理分支。
A: A最早
B: B最近
C: C最远
D: D最后
序号： 725 难度： 1 考查点： C++工具
193. （分值： 0.2 分） C 语言的信号处理技术和 setjmp/longjmp 函数能调用析构函数吗？
A: A 能
B: B 不能
C: C 不一定
D: D 不知道
序号： 726 难度： 1 考查点： C++工具
194. （分值： 0.2 分） 对类的构造函数和析构函数描述正确的是（ ）。
A: 构造函数可以重载，析构函数不能重载
B: 构造函数不能重载，析构函数可以重载
C: 构造函数可以重载，析构函数也可以重载
D: 构造函数不能重载，析构函数也不能重载
序号： 727 难度： 2 考查点：类与对象
195. （分值： 0.2 分）下列关于构造函数的描述中，错误的是（）
A: 构造函数可以设置默认参数；
B: 构造函数在定义类对象时自动执行
C: 构造函数可以是内联函数；
D: 构造函数不可以重载
序号： 728 难度： 2 考查点：类与对象
196. （分值： 0.2 分） try-catch 结构中，被检测函数必须放在（）中。
A: try 块
B: catch 块
C: try-catch 块
D: 上述皆可
序号： 732 难度： 1 考查点： C++工具
197. （分值： 0.2 分）全局变量的作用域是（）。
A: 整个程序
B: 程序前半部分
C: 程序后半部分
D: 不知道
序号： 733 难度： 1 考查点： C++工具
198. （分值： 0.2 分）（）是定义命名空间必须写的关键字。
A: namespace
B: space
C: double
D: name
序号： 734 难度： 1 考查点： C++工具
199. （分值： 0.2 分）声明命名空间时，花括号内可以是（）。
A: 变量
B: 函数
C: 类
D: A、 B、 C 三项皆可
序号： 735 难度： 1 考查点： C++工具
200. （分值： 0.2 分）下列函数中，可以被定义为虚函数的是（ ）。
A: 类的静态成员函数
B: 类的构造函数
C: 非类的函数
D: 类的非静态成员函数
序号： 736 难度： 1 考查点：多态性与虚函数
201. （分值： 0.2 分）下列有关抽象类和纯虚函数的叙述中，错误的是（ ）。
A: 拥有纯虚函数的类是抽象类，不能用于定义对象
B: 抽象类的派生类若不实现纯虚函数，它也是抽象类
C: 纯虚函数的声明以=0;结束
D: 纯虚函数在派生类中不能定义函数体
序号： 737 难度： 1 考查点：多态性与虚函数
202. （分值： 0.2 分）关于虚函数的描述中，（ ）是正确的。
A: 虚函数是一个 static 类型的成员函数
B: 虚函数是一个非成员函数
C: 基类中声明了虚函数后，派生类中与其对应的函数可以不必声明为虚函数
D: 派生类中的虚函数与基类的虚函数具有不同的参数个数和类型
序号： 738 难度： 1 考查点：多态性与虚函数
203. （分值： 0.2 分）关于纯虚函数和抽象类的描述中，（ ）是错误的。
A: 纯虚函数是一种特殊的虚函数，它没有具体的实现
B: 抽象类是指具有纯虚函数的类
C: 一个抽象类的派生类一定不再是抽象类
D: 抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出
序号： 739 难度： 1 考查点：多态性与虚函数
204. （分值： 0.2 分）下列描述中，（ ）是抽象类的特性。
A: 可以定义成员函数
B: 可以进行构造函数重载
C: 可以定义友元函数
D: 不能定义对象
序号： 740 难度： 1 考查点：多态性与虚函数
205. （分值： 0.2 分）（ ）是面向对象程序设计的一个重要特性。
A: 多态性
B: 预处理
C: 函数
D: 常变量
序号： 741 难度： 1 考查点：多态性与虚函数
206. （分值： 0.2 分）关于虚函数，以下哪种说法是正确的（ ）。
A: 在类内声明虚函数需要在关键字 virtual，在类外定义虚函数时也必须加 virtual 关键字
B: 在派生类中重新定义虚函数时，函数名可以和基类的该虚函数不同
C: 当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数
D: 如果派生类中没有对基类的虚函数重新定义，则派生类不能继承其直接基类的虚函数
序号： 742 难度： 1 考查点：多态性与虚函数
207. （分值： 0.2 分）派生类中的虚函数与其基类的同名虚函数应该不同的是（ ）。
A: 函数类型
B: 函数参数个数
C: 函数参数类型
D: 函数体
序号： 743 难度： 1 考查点：多态性与虚函数
208. （分值： 0.2 分）关于函数重载，以下哪种说法是错误的（ ）。
A: 属于静态关联
B: 属于早期关联
C: 属于动态关联
D: 属于编译时的多态性
序号： 744 难度： 1 考查点：多态性与虚函数
209. （分值： 0.2 分）以下哪种情况应考虑把一个成员函数声明为虚函数（ ）。
A: 成员函数所在的类不会作为基类
B: 成员函数所在的类可能会作为基类，且在其派生类中该函数的功能不需更改
C: 派生类更改了该成员函数的功能，且仅通过对象名调用该函数
D: 派生类更改了该成员函数的功能，且通过基类指针去访问该函数
序号： 745 难度： 1 考查点：多态性与虚函数
210. （分值： 0.2 分）以下哪种说法是正确的（ ）。
A: 在程序中最好把基类的析构函数声明为虚函数
B: 构造函数可以声明为虚函数
C: 析构函数不能声明为虚函数
D: 成员函数不能声明为虚函数
序号： 746 难度： 1 考查点：多态性与虚函数
211. （分值： 0.2 分）关于抽象基类，以下哪种说法是正确的（ ）。
A: 一个抽象基类只能包含一个纯虚函数
B: 在类的层次结构中，抽象基类只能位于顶层
C: 派生类不能调用抽象基类的纯虚函数，但是抽象基类自己可以调用
D: 抽象基类是本类族的公共接口
序号： 747 难度： 1 考查点：多态性与虚函数
二、填空题（总分 20）
1.（分值： 0.3）在面向过程的程序设计中，程序功能模块由函数实现；在面向对象的程序设计中，程序模块由 类 实现。
序号： 101 难度： 1 考查点：类与对象
2.（分值： 0.3） 在 C++中定义类时，通常用 数据成员 描述对象的特征，利用成员函数（方法）描述对象的行为或功能。
序号： 102 难度： 1 考查点：类与对象
3.（分值： 0.3）有如下循环语句：
for(int i=50; i>20; i-=2) cout<
序号： 12 难度： 1 考查点： C++基础知识
4.（分值： 0.3）关系运算符、逻辑运算符和算术运算符的计算次序为： 先算术运算符再关系运算符最后逻辑运算符。
序号： 177 难度： 2 考查点： C++基础知识
5.（分值： 0.3）可存储小数的基本数据类型为 单精度实型 或 float 和双精度实型。
序号： 181 难度： 1 考查点： C++基础知识
6.（分值： 0.3）变量的基本类型有 整型 、实型、字符型和枚举型。
序号： 182 难度： 1 考查点： C++基础知识
7.（分值： 0.3） VC++源程序文件的扩展名为 cpp 或 .cpp ，可执行程序的扩展名为 exe。
序号： 183 难度： 1 考查点： C++基础知识
8.（分值： 0.3）字符和字符串常数的定界符分别为 单引号 和双引号(")。(注意：使用中文答案)
序号： 188 难度： 1 考查点： C++基础知识
9.（分值： 0.3） Visual C++6.0 的集成开发环境(IDE)集编辑、编译 、链接和调试运行于一体。
序号： 191 难度： 1 考查点： C++基础知识
10.（分值： 0.3）当一个对象定义时,C++编译系统自动调用 构造函数 建立该对象并进行初始化。
序号： 197 难度： 1 考查点：类与对象
11.（分值： 0.3）如果不做特殊说明，类成员的默认访问权限是 私有 或private。
序号： 198 难度： 1 考查点：类与对象
12.（分值： 0.3）当一个对象的生命周期结束时， C++编译系统自动调用 析构函数 撤销该对象并进行清理工作。
序号： 199 难度： 1 考查点：类与对象
13.（分值： 0.3）设有如下程序结构：
class Box
{R-};
void main()
{Box A,B,C; }
该程序运行时调用 3 次构造函数。
序号： 200 难度： 1 考查点：类与对象
14.（分值： 0.3）在 C++类的定义中，利用 属性 或 数据成员 描述对象的特征。
序号： 201 难度： 1 考查点：类与对象
15.（分值： 0.3）在 C++类的定义中，利用 成员函数 描述对象的行为。
序号： 203 难度： 1 考查点：类与对象
16.（分值： 0.3）类是对象的抽象，而对象则是类的具体 实例 。
序号： 204 难度： 1 考查点：类与对象
17.（分值： 0.3）类的成员按访问权限可分为 3 类，分别是 public、 private、 protected。
序号： 206 难度： 1 考查点：类与对象
18.（分值： 0.3）动态多态性通过 虚函数 实现。
序号： 289 难度： 1 考查点：多态性与虚函数
19.（分值： 0.3）如果类包含了一个或多个 纯虚函数 ，则它是抽象类。
序号： 296 难度： 1 考查点：多态性与虚函数
20.（分值： 0.3）已知类 sample 是一个抽象类，其成员函数 display 是无形参、无返回类型的纯虚函数，请完成其声明。
class sample
{
public:
sample( ){ };
virtual void display()=0 ;
};
( 注意：各项之间只用一个空格分隔)
序号： 301 难度： 1 考查点：多态性与虚函数
21.（分值： 0.3）在面向对象的程序设计中，将数据和处理数据的操作封装成一个整体就定义了一种事物的类型，称作"类"。类是一种抽象的概念，属于该类的一个实例叫做" 对象 "。
序号： 302 难度： 1 考查点：类与对象
22.（分值： 0.3）多态性分为两类：编译时的多态性和 运行时 的多态性。
序号： 304 难度： 1 考查点：多态性与虚函数
23.（分值： 0.3）设有如下程序结构：
class Box
{R-};
void main()
{Box A,B,C; }
该程序运行时调用 3 次析构函数。
序号： 305 难度： 1 考查点：类与对象
24.（分值： 0.3） OOP 技术由对象、 类 、方法、消息和继承五个基本的概念所组成。
序号： 306 难度： 1 考查点：类与对象
25.（分值： 0.3）类是用户定义的类型，具有类类型的变量称作 对象 。
序号： 307 难度： 1 考查点：类与对象
26.（分值： 0.3） #include
void main( )
{
int m=18,n=3;
float a=27.6,b=5.8,x;
x=m/2+n*a/b+1/4;
cout<
程序运行结果是:23.2759。
序号： 31 难度： 1 考查点： C++基础知识
27.（分值： 0.3） 构造 函数重载将会给初始化带来多种方式。
序号： 322 难度： 1 考查点：重载
28.（分值： 0.3）若 a 为整型变量，且 a 的初值为 6，则计算表达式 a+=a-=a*a 后， a 的值
为 -60。
序号： 352 难度： 1 考查点： C++基础知识
29.（分值： 0.3）若有定义语句： int a=1, b=2, c=3; 则表达式 c+=a>b?++a:++b 的值为 6。
序号： 355 难度： 1 考查点： C++基础知识
30.（分值： 0.3） C++中还有一种特殊的指针，用来指向对象自己，这个指针就是 this 指针。
序号： 377 难度： 1 考查点：类与对象
31.（分值： 0.3）面向对象程序设计的三个特性是封装性、继承性和 多态性。
序号： 378 难度： 1 考查点：类与对象
32.（分值： 0.3）在类的对象被创建时，构造 函数被自动调用。
序号： 379 难度： 1 考查点：类与对象
33.（分值： 0.3）用于给对象的数据成员进行初始化的函数是 构造函数 。
序号： 380 难度： 1 考查点：类与对象
34.（分值： 0.3）静态数据成员定义时，应在数据类型前面加上关键字 static。
序号： 381 难度： 1 考查点：类与对象
35.（分值： 0.3）在面向对象的程序设计中，不同的对象可以调用相同名称的函数并导致完全不同的行为现象称为 多态性。
序号： 385 难度： 1 考查点：多态性与虚函数
36.（分值： 0.3）在 c++类的定义中，利用数据成员描述对象的特征，利用 成员函数描述对象的行为。
序号： 389 难度： 1 考查点：类与对象
37.（分值： 0.3）关键字const写在函数参数列表之后，函数体之前，说明该函数是
常成员函数。
序号： 399 难度： 1 考查点：类与对象
38.（分值： 0.3）重载的运算符保持其原有的 操作数个数、优先级和结合性不变。
序号： 400 难度： 1 考查点：重载
39.（分值： 0.3） C++语言支持的两种多态性分别是 编译时 的多态性和运行时的多态性。
序号： 401 难度： 1 考查点：多态性与虚函数
40.（分值： 0.3）如果要把返回值为 void 的无参函数 A 声明为类 B 的友元函数，则应在类 B的定义中加入的语句是 friend void A()； 。
序号： 402 难度： 1 考查点：类与对象
41.（分值： 0.3）如果一个类至少有一个纯虚函数，那么就称该类为 抽象类。
序号： 408 难度： 1 考查点：多态性与虚函数
42.（分值： 0.3）从多个基类中派生出新的子类，这种派生方法称为 多重继承。
序号： 409 难度： 1 考查点：继承与派生
43.（分值： 0.3）设 A 为 Population 类的对象且赋有初值，则语句 Population B(A);表示将对象 A 复制给对象 B。
序号： 416 难度： 1 考查点：类与对象
44.（分值： 0.3）利用 R 对象名 .成员变量 R 形式访问的对象成员仅限于被声明为 public的成员。若要访问其他成员变量，需要通过成员函数或 友元 函数。
序号： 417 难度： 1 考查点：类与对象
45.（分值： 0.3）如果不做特殊说明，类成员的默认访问权限是 private 或 私有。
序号： 418 难度： 1 考查点：类与对象
46.（分值： 0.3） C++中的标识符只能由字母、数字和 下划线 组成。
序号： 442 难度： 1 考查点： C++基础知识
47.（分值： 0.3）十六进制常量前面应该加 0X 或 0x 为前缀。
序号： 443 难度： 1 考查点： C++基础知识
48.（分值： 0.3）为满足运算符+的可交换性，必须将其重载为 友元 函数。
序号： 548 难度： 1 考查点：重载
49.（分值： 0.3）函数重载时要求同名函数的形式参数不同，即参数 类型、个数彼此不同。
序号： 549 难度： 1 考查点：重载
50.（分值： 0.3）已知类 A 有数据成员 int x,y; 要实现以下 A 类对象定义： A a, b(2,3),c(b);
则类 A 的 构造 函数必须重载。
序号： 550 难度： 1 考查点：重载
51.（分值： 0.3）要想访问基类的 private 成员变量，只能通过基类提供的 成员函数进行间接访问。
序号： 556 难度： 1 考查点：继承与派生
52.（分值： 0.3）要想访问基类的 private 成员变量，只能通过基类提供的 成员函数进行间接访问。
序号： 559 难度： 1 考查点：继承与派生
53.（分值： 0.3）如果只想保留公共基类的一个拷贝，就必须使用关键字 virtual 把这个公共基类定义为虚基类。
序号： 560 难度： 1 考查点：继承与派生
54.（分值： 0.3）继承具有 传递性，即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。
序号： 561 难度： 1 考查点：继承与派生
55.（分值： 0.3）公有继承是基类中的 private 成员在派生类中仍是 private 的.
序号： 562 难度： 1 考查点：继承与派生
56.（分值： 0.3） C++类体系中，能被派生类继承的除了基类成员外还有 虚函数。
序号： 563 难度： 1 考查点：继承与派生
57.（分值： 0.3）利用继承能够实现 代码的复用 ，这种实现缩短了程序开发的时间， VC++中的 MFC 编程很好地体现了这一点。
序号： 564 难度： 1 考查点：继承与派生
58.（分值： 0.3）当用 public 继承从基类派生一个类时，基类的 public 成员成为派生类的 成员 成员。
序号： 565 难度： 1 考查点：继承与派生
59.（分值： 0.3）继承的方式有公有继承、私有继承和 保护继承 3 种。
序号： 63 难度： 1 考查点：继承与派生
60.（分值： 0.6）在 c++类的定义中，利用 属性 或 数据成员 描述对象的特征，利用函数成员 或 方法 或 成员函数描述对象的行为。
序号： 64 难度： 1 考查点：类与对象
61.（分值： 0.3）派生类的成员一般分为两部分，一部分是从基类 派生 或 继承 的成员，另一部分是自己定义的新成员。
序号： 66 难度： 1 考查点：继承与派生
62.（分值： 0.3）设 int x,y;则执行 y=(x=1,++x,x+2);语句后，y的值是 4。
序号： 67 难度： 1 考查点： C++基础知识
63.（分值： 0.3）由保护派生得到的派生类，它从基类继承的公有和保护成员都将变为派生类的 保护成员 。
序号： 69 难度： 1 考查点：继承与派生
64.（分值： 0.3）面向对象的模型中，最基本的概念是对象和 类。
序号： 72 难度： 1 考查点：类与对象
65.（分值： 0.3）在私有继承关系下，基类的公有成员和保护成员将成为派生类中的私有成员，它们只能由派生类的成员函数来访问。
序号： 75 难度： 1 考查点：继承与派生
66.（分值： 0.3）双目运算符重载函数为成员函数时，重载函数有 1 或 壹 或 一个参数。
序号： 76 难度： 1 考查点：重载
67.（分值： 0.3）生成一个派生类对象时，先调用 基类 的构造函数，然后调用派生类的构造函数。
序号： 77 难度： 1 考查点：继承与派生
68.（分值： 0.3）运算符重载函数通常为类的 成员 函数和友元函数。
序号： 79 难度： 1 考查点：重载
69.（分值： 0.3）标识符是以 字母 及下划线开头的数字、字母及下划线组成字串。
序号： 93 难度： 1 考查点： C++基础知识
70.（分值： 0.3）已知有类定义：
class A
{
int a,b;
public:
void f(int x, int y)
{
a=x;
b=y;
}
};
在 Visual C++6.0 中 sizeof(A)值为： 8。
序号： 98 难度： 1 考查点：类与对象
三、问答题（总分 15）
1.(分值： 0.4 分)有如下程序：
#include
using namespace std;
class VAC
{
public:
int f()const{return 3;}
int f(){return 5;}
};
int main()
{
VAC v1;
const VAC v2;
cout<
}写出其运行时的输出结果。
参考答案:
53
序号： 112 难度： 1 考查点：类与对象
2.(分值： 0.4 分)有如下程序：
#include
using namespace std;
class TestClass
{
protected:
TestClass(){cout<<‘x’;}
TestClass(char c){cout<
class TestClass1:public TestClass
{
public:
TestClass1(char c){cout<
void main()
{
TestClass1 d1(‘y’);
}执行这个程序，屏幕上将显示输出是
参考答案:
xy
序号： 113 难度： 1 考查点：继承与派生
3.(分值： 0.4 分)有如下程序：
#include
class ONE
{
public:
virtual void f(){cout<<“1”;}
};
class TWO : public ONE
{
public:
TWO(){cout<<“2”;}
};
class THREE : public TWO
{
public:
virtual void f()
{
TWO::f();
cout<<“3”;
}
};
void main()
{
ONE aa, *p;
TWO bb;
THREE cc;
p=&cc;
p->f();
}写出执行该程序的输出结果。
参考答案:
2213
序号： 115 难度： 1 考查点：继承与派生
4.(分值： 0.4 分)有如下程序：
#include
class TestClass1
{
public:
TestClass1(){cout<<“A”;}
};
class TestClass2
{
public:
TestClass2(){cout<<“B”;}
};
class TestClass3:public TestClass1
{
TestClass2 b;
public:
TestClass3(){cout<<“C”;}
};
void main()
{
TestClass3 obj;
}写出该程序的执行后的输出结果。
参考答案:
ABC
序号： 116 难度： 1 考查点：继承与派生
5.( 分 值 ： 0.4 分 ) 有 如 下 程 序 ：
#include
class Con
{
char ID;
public:
Con(){ID=‘A’;cout<<1;}
Con(char id){ID=id;cout<<2;}
char getID(){return ID;}
};
int main()
{
Con c1;
cout<
cout<
}
写出此程序的运行结果。
参考答案:
1A2B
序号： 135 难度： 1 考查点：类与对象
6.(分值： 0.4 分)有如下程序：
#include
using namespace std;
class Test
{
public:
Test(){n+=2;}
~Test(){n-=3;}
static int getNum(){return n;}
private:
static int n;
};
int Test::n=1;
int main()
{
Test* p=new Test;
delete p;
cout<<“n=”<
}
执行后的输出结果是（ ）。
参考答案:
n=3 (n=0)
序号： 165 难度： 2 考查点：类与对象
7.(分值： 0.4 分) #include
#include
using namespace std;
class MyClass
{
public:
MyClass(){cout<<‘A’;}
MyClass(char c){cout<
};
int main()
{
MyClass p1,*p2;
p2=new MyClass(‘X’ );
delete p2;
return 0;
}执行这个程序幕上将显示输出______。
参考答案:
AXBB
序号： 166 难度： 2 考查点：类与对象
8.(分值： 0.4 分)有如下程序
#include
using namespace std;
class Base
{
protected:
Base(){cout<<‘A’;}
Base(char c){cout<
class Derived:public Base
{
public:
Derived(char c ){cout<
int main()
{
Derived d1(‘B’);
return 0;
}执行这个程序屏幕上将显示输出______。
参考答案:
AB
序号： 167 难度： 2 考查点：类与对象
9.( 分 值 ： 0.4 分 ) 分 析 以 下 程 序 执 行 的 结 果
#include
#include
class Sample
{
public:
int x,y;
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
void disp(){cout<<“x=”<
void main()
{
Sample s1(2,3);
s1.disp();
}参考答案:
x=2,y=3
序号： 168 难度： 2 考查点：类与对象
10.(分值： 0.4 分)创建对象数组时，对数组的每一个元素都将调用一次构造函数，如果没有
显式给出数组元素的初值，则调用缺省构造函数，下列程序涉及到对象数组的创建和单个对
象的创建，其输出结果是
#include
using namespace std;
class Foo
{
public:
Foo(int X){cout<<‘A’;}
Foo(){}
};
int main()
{
Foo f[3],g(3);
return 0;
}参考答案:
A
序号： 169 难度： 2 考查点：类与对象
11.(分值： 0.4 分)阅读以下程序：
#include
using namespace std;
class A
{
int a,b;
public:
A();
A(int i,int j);
void print();
};
A::A(){a=5;b=10;}
A::A(int i,int j){a=i,b=j;}
void A::print(){cout<<“a=”<
{
A a1,a2(15, 18);
a1.print( );
a2.print( );
}
写出程序运行后 a1.a 与 a2.b 的值。（答案格式： a1.a
空格 a2.b，例如： 3 5）
参考答案:
5 18 (a=5,b=10 a=15,b=18)
序号： 17 难度： 1 考查点：类与对象
12.( 分 值 ： 0.4 分 ) 分 析 以 下 程 序 的 执 行 结 果
#include
class Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
~Sample()
{
if(x==y)
cout<<“x=y”<
void disp(){cout<<“x=”<
void main()
{
Sample s1(2,3);
s1.disp();
}参考答案:
x=2,y=3 x!=y
序号： 170 难度： 2 考查点：类与对象
13.( 分 值 ： 0.4 分 ) 分 析 以 下 程 序 的 输 出 结 果
#include
class Sample
{
int x;
public:
Sample(int a)
{
x=a;
cout<<“constructing object:x=”<
};
void func(int n){static Sample obj(n);}
void main()
{
func(1);
func(10);
}参考答案:
counstructing object:x=1
序号： 171 难度： 2 考查点：类与对象
14.( 分 值 ： 0.4 分 ) 分 析 以 下 程 序 的 执 行 结 果
#include
class Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
void disp(){cout<<“x=”<
void main()
{
Sample s(2,3),*p=&s;
p->disp();
}参考答案:
x=2,y=3
序号： 172 难度： 2 考查点：类与对象
15.( 分 值 ： 0.4 分 ) 分 析 以 下 程 序 的 执 行 结 果
#include
class Sample
{
public:
Sample();
Sample(int);
~Sample();
void display();
protected:
int x;
};
Sample::Sample()
{
x=0;
cout<<“constructing normally\n”;
}
Sample::Sample(int m)
{
x=m;
cout<<“constructing with a number:”<
void Sample::display()
{cout<<“display a number:”<
{cout<<“destructing\n”;}
void main()
{
Sample obj1;
Sample obj2(20);
obj1.display();
obj2.display();
}参考答案:
constructing nomally
constructing with a number:20
display a number:0
display a
number:20
destructing
destructing
序号： 173 难度： 2 考查点：类与对象
16.( 分 值 ： 0.4 分 ) 分 析 以 下 程 序 的 执 行 结 果
#include
class Sample
{
int n;
public:
Sample(int i){n=i;}
friend int add(Sample &s1,Sample &s2);
};
int add(Sample &s1,Sample &s2){return s1.n+s2.n;}
void main()
{
Sample s1(10),s2(20);
cout<
30
序号： 174 难度： 2 考查点：类与对象
17.( 分 值 ： 0.4 分 ) 写 出 此 题 的 运 行 结 果 ：
#include
using namespace std;
class Complex
{
double re,im;
public:
Complex(double r,double i):re®,im(i){}
double real()const{return re;}
double image()const{return im;}
Complex& operator+=(Complex a)
{
re+=a.re;
im+=a.im;
return *this;
}
};
ostream& operator<<(ostream& s,const Complex& z)
{
return s<<“(”<
int main()
{
Complex x(1,2),y(2,3);
cout<<(x+=y)<
}参考答案:
(3,5)
序号： 175 难度： 2 考查点：重载
18.( 分 值 ： 0.4 分 ) #include
class Sample
{
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
~Sample()
{
if(x==y)
cout<<“x=y”<
cout<<“x!=y”<
void disp(){cout<<“x=”<
int x,y;
};
void main()
{
Sample s1(2,3);
s1.disp();
}参考答案:
x=2,y=3
x!=y
序号： 176 难度： 2 考查点：重载
19.( 分 值 ： 0.4 分 ) #include
class Sample
{
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
void disp(){cout<<“x=”<
int x,y;
};
void main()
{
Sample s1,s2(2,3);
s1.disp();
s2.disp();
}参考答案:
x=0,y=0
x=2,y=3
序号： 177 难度： 2 考查点：重载
20.( 分 值 ： 0.4 分 ) #include
class Sample
{
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
~Sample()
{
if(x==y)
cout<<“x=y”<
cout<<“x!=y”<
void disp(){cout<<“x=”<
int x,y;
};
void main()
{
Sample s1,s2(2,3);
s1.disp();
s2.disp();
}参考答案:
x=0,y=0
x=2,y=3
x!=y
x=y
序号： 178 难度： 2 考查点：重载
21.(分值： 0.4 分) #include
class Sample
{
public:
void setdata(int n)
{
i=n;
cout<<“i=”<
void setdata(double x)
{
d=x;
cout<<“d=”<
private:
int i;
double d;
};
void main()
{
Sample s;
s.setdata(10);
s.setdata(15.6);
}参考答案:
i=10
d=15.6
序号： 179 难度： 2 考查点：重载
22.(分值： 0.4 分) #include
class Sample
{
public:
Sample(){}
Sample(int i){n=i;}
Sample &operator=(Sample);
void disp(){cout<<“n=”<
int n;
};
Sample &Sample::operator=(Sample s)
{
Sample::n=s.n;
return *this;
}
void main()
{
Sample s1(10),s2;
s2=s1;
s2.disp();
}参考答案:
n=10
序号： 180 难度： 2 考查点：重载
23.( 分 值 ： 0.4 分 ) #include
class Sample
{
public:
Sample(int i){n=i;}
operator++(){n++;}
operator++(int){n+=2;}
void disp(){cout<<“n=”<
int n;
};
void main()
{
Sample A(2),B(2);
A++;
++B;
A.disp();
B.disp();
}参考答案:
n=4
n=3
序号： 181 难度： 2 考查点：重载
24.(分值： 0.4 分)请写出下题的运行结果：
#include
using namespace std;
class Publication //出版物类
{
public:
Publication(char *name=“未知名称”){strcpy(this->name,name);}
const char * getName()const{return name;}
virtual const char * getType()const{return"未知类型";}
private:
char name[30];
};
class Book:public Publication //书类
{
public:
Book(char *name):Publication(name){}
virtual const char * getType()const{return “书”;}
};
void showPublication(Publication &p){cout<
{
Book book(“精彩人生”);
showPublication(book);
return 0;
}参考答案:
书：精彩人生
序号： 182 难度： 2 考查点：多态性与虚函数
25.(分值： 0.4 分 ) 请写出下题的运行结果：
#include
using namespace std;
class A
{
public:
virtual void f(){cout<<1;}
void g(){cout<<2;}
};
class B:public A
{
public:
virtual void f(){cout<<3;}
void g(){cout<<4;}
};
void show(A &a)
{
a.f();
a.g();
}
int main()
{
B b;
show(b);
return 0;
}参考答案:
32
序号： 183 难度： 2 考查点：多态性与虚函数
26.(分值： 0.4 分 ) 请写出下题的运行结果：
#include
using namespace std;
class TestClass
{
public:
virtual void fun1(){cout<<“fun1TestClass”<
class TestClass1:public TestClass
{
void fun1(){cout<<“fun1TestClass1”<
int main()
{
TestClass obj1,*p;
TestClass1 obj2;
p=&obj2;
p->fun1();
p->fun2();
return 0;
}参考答案:
fun1TestClass1
fun2TestClass
序号： 184 难度： 2 考查点：多态性与虚函数
27.(分值： 0.4 分 ) 请写出下题的运行结果：
#include
using namespace std;
class T1
{
public:
void funl(){cout<<"T1 ";}
virtual void fun2(){cout<<“T1”;}
};
class T2:public T1
{
public:
void funl(){cout<<“T2”;}
void fun2(){cout<<“T2”;}
};
void f(T1 &b)
{
b.funl();
b.fun2();
}
void main()
{
T2 obj;
f(obj);
}参考答案:
T1 T2
序号： 185 难度： 2 考查点：多态性与虚函数
28.(分值： 0.4 分)请写出下题的运行结果：
#include
using namespace std;
class B
{
public:
void print(){cout<<“B”;}
};
class D:public B
{
public:
void print(){cout<<“D”;}
};
void main()
{
D *pd=new D();
B *pb=pd;
pb->print();
pd->print();
delete pd;
}参考答案:
BD
序号： 186 难度： 2 考查点：多态性与虚函数
29.( 分 值 ： 0.4 分 ) 请 写 出 下 题 的 运 行 结 果 ：
#include
#include
using namespace std;
class Student
{
public:
Student(int,string,float);
virtual void display();
protected:
int num;
string name;
float score;
};
Student::Student(int n,string nam,float s){num=n;name=nam;score=s;}
void Student::display(){cout<<“num:”<
{
public:
Graduate(int,string,float,float);
void display();
private:
float pay;
};
void Graduate::display(){cout<<“num:”<
int main()
{
Student stud1(1001,“Li”,87.5);
Graduate grad1(2001,“Wang”,98.5,1200);
Student *pt=&stud1;
pt=&grad1;
pt->display();
return 0;
}参考答案:
num:2001
name:Wang
score:98.5
pay=1200
序号： 187 难度： 2 考查点：多态性与虚函数
30.(分值： 0.4 分)请写出下题的运行结果：
#include
using namespace std;
class Point
{
public:
Point(){}
virtual ~Point(){cout<<“executing Point destructor”<
class Circle:public Point
{
public:
Circle(){}
~Circle(){cout<<“executing Circle destructor”<
int radus;
};
int main()
{
Point *p=new Circle;
delete p;
return 0;
}参考答案:
executing Circle destructor
executing Point destructor
序号： 188 难度： 2 考查点：多态性与虚函数
31.(分值： 0.4 分)阅读程序，写出运行后的输出结果。
#include
using namespace std;
class A
{
public:
~A(){cout<<“A”;}
};
class B :public A
{
public:
~B(){cout<<“B”;}
};
void main()
{
B b1;
}参考答案:
BA
序号： 81 难度： 1 考查点：继承与派生
32.(分值： 0.4 分)阅读程序，写出运行后输出的结果。
#include
using namespace std;
class A
{
int a;
int b;
public:
A(int i){a=i;b=0;}
void display(){cout<<“a=”<
class B : public A
{
int c;
public:
B(int i, int j):A(i){c=j;}
void display()
{
A::display();
cout<<“c=”<
};
void main()
{
B b1(1,2);
b1.display();
}参考答案:
a=1b=0c=2
序号： 82 难度： 1 考查点：继承与派生
33.(分值： 0.4 分)阅读下面的程序， 写出运行后输出的结果。
#include
using namespace std;
class A
{
public:
A(){cout<<“A”;}
};
class B :public A
{
public:
B(){cout<<“B”;}
};
void main()
{
B b1;
}参考答案:
AB
序号： 83 难度： 1 考查点：继承与派生
34.(分值： 0.4 分)阅读程序，写出运行后输出的结果。
#include
using namespace std;
class A
{
int a;
int b;
public:
A(int i){a=i;b=0;}
void display(){cout<<“a=”<
class B:public A
{
int c;
public:
B(int i):A(i){c=0;}
void display()
{
A::display();
cout<<“c=”<
};
void main()
{
B b2(1);
b2.display();
}参考答案:
a=1b=0c=0
序号： 85 难度： 1 考查点：继承与派生