面向对象程序设计综合练习题a

一、单项选择题

1-1．C++语言是从早期的C语言逐步发展演变而来的，与C语言相比，它在求解问题方法上进行的最大改进是（ B ）。

A．面向过程 B．面向对象 C．安全性 D．复用性

1-2． C++源程序文件的缺省扩展名为（ A ）。 A. cpp B. exe C. obj D. lik

1-3．由C++源程序文件编译而成的目标文件的缺省扩展名为（ C ）。

A. cpp B. exe C. obj D. lik

1-4．由C++目标文件连接而成的可执行文件的缺省扩展名为（ B ）。

A. cpp B. exe C. obj D. lik

1-5．编写C++程序一般需经过的几个步骤依次是（ B ）。 A. 编译、编辑、连接、调试 B. 编辑、编译、连接、调试

C. 编译、调试、编辑、连接 D. 编辑、调试、编辑、连接

1-6．用“>>”运算符从键盘输入多于一个数据时，各数据之间应使用（ D ）符号作为分隔符。

A．空格或逗号 B．逗号或回车 C．逗号或分号 D．空格或回车

1-7．C++中声明常量的关键字是（ A ）。 A．const B．extern C．public D．enum

1-8．以下叙述中正确的是（ B ）

A. 使用#define可以为常量定义一个名字，该名字在程序中可以再赋另外的值

B. 使用const定义的常量名有类型之分，其值在程序运行时是不可改变的

C. 在程序中使用内置函数使程序的可读性变差

D. 在定义函数时可以在形参表的任何位置给出缺省形参值 1-9．下列的符号常变量定义中，错误的定义是（ C ）。 A．const M=10; B．const int M=20;

C．const char ch; D．const bool mark=true; 1-10．函数原型语句正确的是（ B ）。

A．int Function(void a) B．void Function (int);

- 1 -

C．int Function(a); D．void int(double a);

1-11．以下正确的函数原型语句是（ C ）。 A．double fun(int x,int y)

B．double fun(int x;int y)

C．double fun(int,int);

D．double fun(int x,y);

1-12．下面有关重载函数的说法中正确的是（ C ）。 A．重载函数必须具有不同的返回值类型 B．重载函数形参个数必须不同

C．重载函数必须有不同的形参列表 D．重载函数名可以不同

1-13．函数重载是指（ A ）。

A. 两个或两个以上的函数取相同的函数名，但形参的个数或类

型不同

B. 两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同

C. 两个以上的函数名字不同，但形参的个数或类型相同

D. 两个以上的函数取相同的函数名，并且函数的返回类型相同

1-14．采用重载函数的目的是（ D ）。 A．实现共享 B．减少空间

C．提高速度 D．使用方便，提高可读性 1-15．以下关于函数模板叙述正确的是（ C ）。 A．函数模板也是一个具体类型的函数

B．函数模板的类型参数与函数的参数是同一个概念

C．通过使用不同的类型参数，函数模板可以生成不同类型的

函数定义

D．用函数模板定义的函数没有类型 1-16．以下正确的描述是（ C ）。 A. 不允许设置参数的默认值

B. 设置参数的默认值只能在定义函数时设置 C. 设置参数的默认值时，应该设置右边的参数 D. 设置参数的默认值时，应该全部参数都设置 1-17．（ B ）是给变量取一个别名，它引入了变量的同义词。 A．指针 B．引用 C．枚举 D．结构

1-18．假定变量x定义为“int x=5;”，要使rx成为x的引用（别名），rx应定义为（ D ）。

- 2 -

A. int rx=x; B. int rx=&x;

C. int *rx=&x; D. int &rx=x;

1-19．下列对引用的陈述中不正确的是（ C ）。

A. 每一个引用都是其所引用对象的别名,因此必须初始化 B. 形式上针对引用的操作实际上作用于它所引用的对象 C. 一旦定义了引用，一切针对其所引用对象的操作只能通过该引用间接进行

D. 不需要单独为引用分配存储空间

1-20．下列（ C ）的调用方式是引用调用。 A. 形参和实参都是变量

B.形参是指针，实参是地址值 C. 形参是引用，实参是变量

D.形参是变量，实参是地址值

1-21．在 （ C ）情况下适宜采用inline定义内置函数。

A．函数体含有循环语句 B．函数体含有递归语句

C．函数代码少、且频繁调用 D．函数代码多、不常调用 1-22．为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（ A ）。

A．内置函数 B．重载函数 C．递归函数 D．函数模板

1-23．一个函数功能不太复杂，但要求被频繁调用，选用（ A ）

A．内置函数 B．重载函数 C．递归函数 D．嵌套函数

1-24．说明内置函数的关键字是（ A ）。

A．inline B．virtual C．define D．static

1-37．对于动态分配内存空间描述正确的是（ D ）。 A．使用new运算符分配的内存空间的长度必须是常量

B．delete运算符可以释放动态的存储空间和静态的存储空间 C．用new分配的内存空间是不连续的

D．delete运算符只能以释放由new分配的动态存储空间

1-38．定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为（ A ）。

A. int *p=new int[30]; B. int *p=new int(30); C. int *p=new [30]; D. *p=new int[30];

- 3 -

2-1．C++对C语言作了很多改进，即从面向过程变成为面向对象的主要原因是（ D ）。

A．增加了一些新的运算符 B．允许函数重载，并允许设置缺省参数 C．规定函数说明符必须用原型 D．引进了类和对象的概念

2-2．面向对象软件开发中使用的OOA表示（ A ）。 A. 面向对象分析 B. 面向对象设计

C. 面向对象语言 D. 面向对象方法

2-3．面向对象软件开发中使用的OOD表示（ B ）。 A. 面向对象分析 B. 面向对象设计

C. 面向对象语言 D. 面向对象方法

2-4．关于面向对象系统分析，下列说法中不正确的是（ B ）。 A. 术语“面向对象分析”可以用缩写OOA表示

B. 面向对象分析阶段对问题域的描述比设计阶段更详细 C. 面向对象分析包括问题域分析和应用分析两个步骤 D. 面向对象分析需要识别对象的内部和外部特征 2-5．下列关于成员函数特征的描述中，（ A ）是错误的。

A．成员函数一定是内置函数 B．成员函数可以重载

C．成员函数可以设置参数的默认值 D．成员函数可以是静态的

2-6．在关键字private后面定义的成员为类的（ A ）成员。 A. 私有 B. 公用 C. 保护 D. 任何

2-7．在一个类的定义中，包含有（ C ）成员的定义。 A. 数据 B. 函数

C. 数据和函数 D. 数据或函数

2-8．在类作用域中能够通过直接使用该类的（ D ）成员名进行访问。

A. 私有 B. 公用 C. 保护 D. 任何

2-9．在关键字public后面定义的成员为类的（ B ）成员。 A. 私有 B. 公用 C. 保护 D. 任何 2-10．类中定义的成员默认为（ B ）访问属性。 A. public B. private C. protected D. friend

2-11．假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（ D ）。 A. x(a) B. x[a] C. x->a D. x.a

2-12．假定AA为一个类，a()为该类公有的函数成员，x为该类

- 4 -

的一个对象，则访问x对象中函数成员a()的格式为（ B ）。 A. x.a B. x.a() C. x->a D. x->a()

2-13．假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（ C ）。

A. px(a) B. px[a] C. px->a D. px.a

2-14．假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ D ）。 A. x.a B. x.a()

C. x->GetValue() D. x.GetValue()

2-14．假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（ A ）。 A. int AA::a() B. int AA:a()

C. AA::a() D. AA::int a()

2-15．若需要把一个类外定义的成员函数指明为内联函数，则必须把关键字（ B ）放在函数原型或函数头的前面。 A. in B. inline C. inLine D. InLiner

2-16．下列特性不是面向对象程序设计语言所特有的是（ D ）。 A．数据封装 B．继承 C．多态性 D．模板

3-1．关于构造函数，下列说法不正确的是（ D ）。 A．构造函数名字和类名相同

B．构造函数在创建对象时自动执行 C．构造函数无任何函数返回类型 D．构造函数有且只有一个

3-2．类的构造函数是在定义该类的一个( C )时被自动调用执行的。

A. 成员函数 B. 数据成员 C. 对象 D. 友元函数

3-3．一个类的构造函数通常被定义为该类的( A )成员。 A. 公用 B. 保护 C. 私有 D. 友元

3-4．关于构造函数特点描述中，错误的是（ A ）。 A．定义构造函数必须指出类型

B．构造函数的名字与该类的类名相同

C．一个类中可以定义0个至多个构造函数 D．构造函数是一个成员函数

- 5 -

3-5．对于一个类的构造函数，其函数名与类名（ A ）。 A．完全相同 B．基本相同 C．不相同 D．无关系 3-6．每个类（ C ）构造函数。

A．只能有一个 B．可以有公用的 C．可以有多个 D．只可有缺省的

3-7．对类对象成员的初始化是通过构造函数中给出的（ B ）实现的。

A．函数体 B．参数初始化表 C．参数表 D．参数初始化表或函数体

3-8．假定AB为一个类，则执行“AB x;”语句时将自动调用该类的 ( B ).。

A．有参构造函数 B．无参构造函数 C．复制构造函数 D．赋值重载函数 3-9．假定AB为一个类，则执行 “AB x(a,5);”语句时将自动调用该类的 ( A )。

A. 带参构造函数 B. 无参构造函数 C. 复制构造函数 D. 赋值重载函数

3-10．假定CTest为一个类，并且有一无默认值的的有参构造函数和一无参构造函数，则执行“CTest objTest;”语句时将自动调用该类的（ B ）。

A．有参构造函数 B．无参构造函数 C．复制构造函数 D．赋值构造函数

3-11．构造函数不具备的特征是（ D ）。

A．构造函数的函数名与类名相同 B．构造函数可以重载

C．构造函数可以设置默认参数 D．构造函数必须指定类型说明

3-12．假定一个类的构造函数为 “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

3-13．假定一个类的构造函数为 “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

3-14．假定一个类的构造函数为 “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

- 6 -

3-15．假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为( C )。

A. AB() {} B. AB(): a(0){} C. AB(int aa=0) {a=aa;} D. AB(int aa) {}

3-16．类的析构函数是一个对象被( B )时自动调用的。 A. 建立 B. 撤消 C. 赋值 D. 引用 3-17．能够释放对象所占资源的是（ A ）。 A. 析构函数 B. 数据成员 C. 构造函数 D. 静态成员函数 3-18．类的析构函数的作用是( D ).。

A．一般成员函数 B．类的初始化 C．对象的初始化 D．对象释放后的操作 3-19．对于一个类的析构函数，其函数名与类名( C )。 A. 完全相同 B. 完全不同

C. 只相差一个字符 D. 无关系

3-20．一个类的析构函数通常被定义为该类的( C )成员。 A. 私有 B. 保护 C. 公用 D. 友元 3-21．定义析构函数时，应该注意（ C ）。 A．其名与类名完全相同 B．返回类型是void类型 C．无形参，也不可重载 D．函数体中必须有delete语句

3-22．类的析构函数可以带有( A )个参数。 A. 0 B. 1 C. 2 D. 任意

3-23．类的析构函数是在（ C ）调用的。

A．类创建时 B．创建对象时 C．对象生命期结束时 D．不自动调用

3-24．当一个类对象离开它的作用域时，系统自动调用该类的( D )。

A. 无参构造函数 B. 带参构造函数 C. 拷贝构造函数 D. 析构函数

3-25．假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为( C )。 A. 0 B. 1 C. n D. n-1

3-26．假定AB为一个类，则执行 “AB a[10];”语句时调用该类无参构造函数的次数为( D )。 A. 0 B. 1 C. 9 D. 10

3-27．假定AA是一个类，abc是该类的一个成员函数，则参数

- 7 -

表中隐含的第一个参数的类型为（ D ）。 A. int B. char C. AA D. AA*

3-28．假定AA是一个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数为（ C ）。

A. abc B. *this C. this D. this&

3-29．假定AB为一个类，则执行 “AB *px=new AB[n];”语句时将( A )。

A. 动态分配一个数组 B. 动态分配一个对象 C. 静态分配一个数组 D. 静态分配一个对象

3-30．设px是指向一个类对象的指针变量，则执行 “delete px;”语句时，将自动调用该类的( C )

A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 复制构造函数

3-31．对于在类中定义的静态数据成员，下面正确的说法是（ C ）。

A．该类的每一个对象中都有一个静态数据成员 B．对象创建时产生 C．在类外进行初始化

D．既可以在类外初始化，也可以在类内初始化 3-32．一个类的静态数据成员所表示属性 ( C )。 A. 是类的或对象的属性 B. 只是对象的属性 C. 只是类的属性 D. 类和友元的属性 3-33．类的静态成员的访问控制（ D ）。 A. 只允许被定义为private

B. 只允许被定义为private或protected C. 只允许被定义为public

D. 可允许被定义为private、protected或public 3-34．静态成员函数对类的数据成员访问（ B ）。 A. 是不允许的 B. 只允许是静态数据成员

C. 只允许是非静态数据成员

D. 可允许是静态数据成员或非静态数据成员

3-35．被非静态成员函数访问的类的数据成员( A )。 A. 可以是非静态数据成员或静态数据成员 B. 不可能是类的静态数据成员

C. 只能是类的非静态数据成员

D. 只能是类的静态数据成员

3-36．静态数据成员的初始化是在（ D ）中进行的。

- 8 -

A. 构造函数 B. 任何成员函数 C. 所属类 D. 全局区 3-37．由于数据隐藏的需要，静态数据成员通常被说明为（ A ）。

A．私有的 B．公用的 C．保护的 D．不可访问的

3-38．复制构造函数的参数通常是（ C ）。

A．无特殊要求 B．指向对象的指针

C．自己类对象的常引用 D．对象

3-39．通常，复制构造函数的参数是（ C ）。

A．某个对象名 B．某个对象的成员

C．某个对象的引用名 D．某个对象的引用名

3-40．关于常成员的描述中，错误的是（ B ）。 A．常成员包括常数据成员和常成员函数两种 B．常数据成员必须是公用的

C．常数据成员要使用构造函数成员初始化列表进行初始化 D．常对象只能调用它的常成员函数，不能调用其它的成员函

数

3-41．引入友元的主要目的是为了（ C ）。 A. 增强数据安全性 B. 提高程序的可靠性

C. 提高程序的效率和灵活性 D. 保证类的封装性

3-42．一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（ A ）。

A. 需加上类域的限定 B. 不需加上类域的限定

C. 类域的限定可加可不加 D. 不需要任何限定

3-43．类成员的访问权限中，（ C ）只能被本类的成员函数和其友元函数访问。

A．share B．public C．private D．protected

3-44．当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的（ D ）。

- 9 -

A. 只能是公有成员 B. 只能是保护成员

C. 只能是除私有成员之外的任何成员 D. 具有任何权限的成员

3-45．下面不是描述类的成员函数的是（ C ）。

A．构造函数 B．析构函数 C．友元函数 D．复制构造函数 3-46． 下列函数中，（ C ）不是类的成员函数。

A．构造函数 B．析构函数 C．友元函数 D．复制构造函数

3-47．如果类A被说明成类B的友元，则（ D ）。

A．类A的成员即类B的成员 B．类B的成员即类A的成员

C．类A的成员函数不得访问类B的成员 D．类B不一定是类A的友元

4-1．关于运算符重载，下列说法正确的是（ C ）。 A. 重载时，运算符的优先级可以改变。 B. 重载时，运算符的结合性可以改变。 C. 重载时，运算符的功能可以改变。

D. 重载时，运算符的操作数个数可以改变。

4-2．下列关于运算符重载的描述中，错误的是（ B ）。 A．运算符重载不可以改变操作数的个数 B．运算符重载不可以改变运算符的功能 C．运算符重载不可以改变结合方向 D．运算符重载不可以改变运算优先级

4-3．关于运算符重载，下列说法正确的是（ B ）。

A．所有运算符都可以重载

B．通过重载，可以使运算符应用于自定义的数据类型 C．通过重载，可以创建原来没有的运算符号 D．通过重载，可以改变运算符的优先级

4-4．在一个类中可以对一个运算符进行（ D ）重载。 A．1种 B．2种以下 C．3种以上 D．多种

4-5．不能参与重载的运算符是（ A ）。

A．类 B．函数 C．函数模板 D．运算符

4-6．在重载一个运算符时，其参数表中没有任何参数，这表明该

- 10 -

运算符是（ B ）。

A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符

C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符

4-7．在成员函数中进行双目运算符重载时，其参数表中应带有（ B ）个参数。

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

4-8．双目运算符重载为普通函数时，其参数表中应带有（ C ）个参数。

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

4-9．如果表达式a+b中的“+”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ A ）。

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

4-10．如果表达式a==b中的“==”是作为普通函数重载的运算符，若采用运算符函数调用格式，则可表示为（ C ）。 A. a.operator==(b) B. b.operator==(a) C. operator==(a,b) D. operator==(b,a)

4-11．如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ D ）。

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

4-12．在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（ D ）

A. 该运算符是一个单目运算符。

B. 该运算符函数有一个隐含的参数this。 C. 该运算符函数是类的成员函数。 D. 该运算符函数是类的友元函数。

4-13．关于插入运算符<<的重载，下列说法不正确的是（ B ）。 A. 运算符函数的返回值类型是ostream & 。 B. 重载的运算符必须定义为类的成员函数。 C. 运算符函数的第一个参数的类型是ostream & D. 运算符函数有两个参数。 4-14．C++提供了几种方法以实现不同类型间的转换。以下（ C ）不能用来进行不同类型数据间的转换的。 A．用隐式类型转换或显式类型转换

B．用转换构造函数

- 11 -

C．用复制构造函数 D．用类型转换函数

4-15．用类型转换函数进行类型转换，在定义类型转换函数时，以下（ D ）是正确的。

A．要指定函数类型，要给定函数参数

B．要指定函数类型，不用给定函数参数 C．不用指定函数类型，要给定函数参数 D．不用指定函数类型，不用给定函数参数

4-16．将运算符“+”重载，要求在进行两个负数相加时可以使用交换律，必须（ A ）。

A．将运算符“+”重载为友元函数

B．将运算符“+”重载为成员函数 C．将运算符“+”重载为构造函数 D．将运算符“+”重载为析构函数

5-1．继承机制的作用是（ C ）。

A．信息隐藏 B．数据封装 C．定义新类 D．数据抽象

5-2．C++的继承性允许派生类继承基类的（ C ）。

A. 部分特性，并允许增加新的特性或重定义基类的特性 B. 部分特性，但不允许增加新的特性或重定义基类的特性 C. 所有特性，并允许增加新的特性或重定义基类的特性 D. 所有特性，但不允许增加新的特性或重定义基类的特性 5-3．下列对派生类的描述中，（ D ）是错误的。

A．一个派生类可以作为另一个类的基类 B．派生类至少有一个基类

C．派生类的成员除了它自己的成员外，还包含它的基类的成

员

D．派生类中继承的基类成员的访问权限到派生类中保持不变

5-4．派生类的对象对其基类中（ A ）可直接访问。

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

C. 公有继承的保护成员 D. 私有继承的公有成员

5-5．基类和派生类可以分别称为（ B ）。 A．“大类”和“小类” B．“父类”和“子类” C．“小类”和“大类”

- 12 -

D．“子类”和“父类”

5-6．派生类的成员函数可以直接访问基类的（ B ）成员。 A. 所有 B. 公有和保护 C. 保护和私有 D. 私有

5-7．派生类可以访问其基类的（ D ）。 A．公用成员 B．保护成员 C．私有派生 D．公用和保护成员

5-8．对于类中定义的成员，其隐含访问权限为（ C ）。 A．public B．ptotected C．private D．static

5-9．在定义一个派生类时，若不使用保留字显式地规定采用何种继承方式，则默认为（ A ）方式。

A. 私有继承 B. 非私有继承 C. 保护继承 D. 公用继承

5-10． 在公用继承的情况下，基类成员在派生类中的访问权限（ B ）

A．受限制 B．保持不变 C．受保护 D．不受保护 5-11．对于公用继承，基类的公有和保护成员在派生类中将( D )成员。

A. 全部变成公有 B. 全部变成保护

C. 全部变成私有 D. 仍然相应保持为公有和保护

5-14．在公用继承的情况下，基类非私有成员在派生类中的访问权限（ B ）。

A．受限制 B．保持不变 C．受保护 D．不受保护

5-15．对于公有继承，基类中的私有成员在派生类中将 ( C )。 A. 能够直接使用成员名访问 B. 能够通过成员运算符访问

C. 仍然是基类的私有成员 D. 变为派生类的私有成员

5-16．当保护继承时，基类的（ B ）在派生类中成为保护成员，在类作用域外不能够通过派生类的对象来直接访问该成员。

A. 任何成员 B.公有成员和保护成员

C. 保护成员和私有成员

- 13 -

D.私有成员

5-17．下面描述中，表达错误的是（ B ）。

A．公用继承时基类中的public成员在派生类中仍是public的 B．公用继承时基类中的private成员在派生类中仍是private的

C．公用继承时基类中的protected成员在派生类中仍是

protected的

D．私有继承时基类中的public成员在派生类中是private的 5-18．从一个基类派生出的各个类的对象之间（ C ）。 A．共享所有数据成员，每个对象还包含基类的所有属性 B．共享部分数据成员，每个对象还包含基类的所有属性

C．不共享任何数据成员，但每个对象还包含基类的所有属性 D．共享部分数据成员和函数成员

5-19．建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为（ C ）的构造函数。

A. 自己所属类、对象成员所属类、基类 B. 对象成员所属类、基类、自己所属类 C. 基类、对象成员所属类、自己所属类 D. 基类、自己所属类、对象成员所属类 5-20．假设定义了以下的类： Class A {public: int a;

viod display(); }; Class B {public: int a;

viod display(); };

Class C: Class A, Class b {public: int b;

viod show(); };

如果在main函数中定义了C类对象c1，并调用基类A的数据成员a并对其赋初值3，然后成员函数display，应使用（ C ）语句。 A．c1.a=3; c1.display()

- 14 -

B．c1::a=3; c1::display() C．c1.A::a=3; c1.A::display() D．c1.A->a=3; c1.A->display()

5-21．当派生类中有和基类一样名字的成员时，一般来说，（ B ）

A. 将产生二义性

B. 派生类的同名成员将覆盖基类的成员 C. 是不能允许的

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

5-22．C++中的虚基类机制可以保证：（ D ）。

A. 限定基类只通过一条路径派生出派生类 B. 允许基类通过多条路径派生出派生类，派生类也就能多次继

承该基类

C. 当一个类多次间接从基类派生以后，派生类对象能保留多份

间接基类的成员

D. 当一个类多次间接从基类派生以后，其基类只被一次继承 5-23．下列虚基类的声明中正确的是（ D ）。

A．class virtual B:public A B．virtual class B:public A

C．class B:public A virtual D．class B: virtual public A 5-24．若类A和类B的定义如下：

class A {

int i,j; public:

A(int m,int n):i(m),j(n){} int Geti(){return i;} };

class B:public A {

int k; public:

B(int m,int n,int u):A(m,n),k(u){} void Make(){k=i*j;} };

int main()

- 15 -

{

B b(1,2,3); return 0; }

则上述定义中，（ A ）是非法的表达式。 A．k=i*j; B．int k; C．return i; D．void Make() 5-25．以下说法中，错误的是（ D ） A．派生类对象可以向基类对象赋值

B．派生类对象可以替代基类对象向基类对象的引用进行赋

值或初始化

C．如果函数的参数是基类对象或基类对象的引用，实参可

以用子对象的实参

D．可以用基类对象的指针指向派生类对象，并访问派生类

中的全部成员

6-1．面向对象方法的多态性是指（ C ）。 A. 一个类可以派生出多个特殊类

B. 一个对象在不同的运行环境中可以有不同的变体

C. 针对一消息，不同的对象可以以适合自身的方式加以响应 D. 一个对象可以是由多个其他对象组合而成的 6-2．从系统实现的角度看，多态性分为静态多态性和动态多态性。以下说法错误的是（ C ）。

A．静态多态性是编译时的多态性

B．函数重载实现的多态性是静态多态性 C．通过虚函数实现的多态性是静态多态性 D．动态多态性是运行时的多态性

6-3．关于消息，下列说法中不正确的是（ B ）。

A. 发送消息的对象请求服务，接受消息的对象提供服务 B. 消息的发送者必须了解消息的接收者如何响应消息

C. 在C++中，消息的发送具体体现为对接收消息的对象的某个函数的调用

D. 每个对象只能接收某些特定格式的消息 6-4．编译时的多态性使用什么获得？（ A ）

A．重载函数 B．继承 C．虚函数 D．B和C

6-5．运行时的多态性使用什么获得？（ C ）

A．重载函数 B．继承

- 16 -

C．虚函数 D．B和C

6-6．虚函数的定义是在基类中进行的，定义时需要冠以关键字（ C ）。

A. static B. friend C. virtual D. public

6-7．C++编译系统确定调用是具体对象的过程称为关联。C++有（ B ）关联。

A．1种 B．2种 C．3种 D．4种

6-8． 调用一个成员函数时，使用动态关联的情况是（ B ）。

A．通过对象调用一虚函数 B．通过指针或引用调用一虚函数 C．通过对象调用一静态函数 D．通过指针或引用调用一静态函数

6-9．C++类体系中，不能被派生继承的有（ C ）。

A．转换函数 B．构造函数 C．虚函数 D．静态成员函数 6-10．C++语言建立类族是通过（ B ）。

A．类的嵌套 B．类的继承 C．虚函数 D．抽象类 6-11．在下面的4个关键字中，（ A ）是用来说明虚函数的。

A．virtual B．public C．protected D．private

6-12．实现运行时的多态性要使用（ D ）。

A．重载函数 B．析构函数 C．构造函数 D．虚函数

6-13．关于纯虚函数，下列说法不正确的是（ C ）。 A．纯虚函数是在声明虚函数时被初始化为0的函数 B．纯虚函数没有函数体 C．纯虚函数可以被调用

D．如果在一个类中声明了纯虚函数，该虚函数中在派生类中仍有可能为虚函数

6-14．如果一个类至少有一个纯虚函数，那么该类称为( A ).。 A．抽象类 B．虚基类 C．派生类 D．以上都不对

7-1．C++的输入输出不包括（ D ）。 A．标准的输入输出 B．文件的输入输出

C．字符串输入输出

- 17 -

D．显示屏和打印机的输入输出 7-2．下面的类中，（ C ）不是由抽象基类ios直接派生出来的。 A．istream B．ostream C．iostream D．fstreambase

7-3．在C++中，抽象基类ios直接派生出（ D ）。 A．istrean, ostream, ifstream,ofstream

B．istrean, ostream, istrstream,ostrstream C．istrean, ostream, iostream

D．istrean, ostream, fstreambase,strstreambase 7-4．cin是某个类的标准对象，该类是（ B ）。

A．ostream B．istream C．stdout D．stdin

7-5．cout是某个类的标准对象，该类是（ A ）。

A．ostream B．istream C．stdout D．stdin

7-6．关于cout流对象，以下说法不正确的是（ D ）。 A．cout是ostream流类对象

B．用“cout<<”输出数据时，不须考虑数据是什么类型 C．当向cout流插入一个endl时，输出换行

D．用“cout<<”可以直接输出用户声明的类型的数据。 7-7．在iostream文件中定义了4种流对象，它们是（ A ）。 A．cin, cout, cerr, clog B．cin, cout, cerr, put

C．cin, cout, put, get D．cin, cout, cerr, get

7-8．在C++中串流类是在头文件strstream.h中定义的,下列不属于串流类的是( C )。

A. strstream B. ostrstream C. ofstream D. istrstream

7-9．在C++程序中使用的cin标识符是系统类库中定义的（ A ）类中的一个对象。

A. istream B. ostream

C. iostream D. fstream

7-10．在C++程序中使用的cout标识符是系统类库中定义的（ B ）类中的一个对象。

A. istream B. ostream C. iostream D. fstream 7-11．以下的函数中，（ A ）不是用于字符输入的。 A．cout.put('a') B．cin.get()

C．cin.get(ch) D．cin.get(ch,10, '\\n')

- 18 -

7-12．关于文件，以下说法不正确的是（ C ）。 A．用户常用的文件有程序文件和数据文件两大类

B．根据数据的组织形式，文件可分为ASCII文件和二进制文件

C．对于字符信息，用ASCII文件输出和用二进制文件输出，

其形式是不同的

D．对于数值数据，用ASCII文件和用二进制文件所占内存空

间是不同的

8-1．以下说法中，正确的是（ C ）。

A．编译系统能发现语法错误，也能发现运行错误

B．程序能通过编译，也能运行，就能得到正确的运行结果 C．程序能通过编译，也能运行，不一定能得到正确的运行结

果

D．发现运行错误比发现编译错误较容易

8-2．C++处理异常的机制有3部分组成，即（ B ）。 A．检查（try）、捕捉（catch）和纠错（error correction） B．检查（try）、抛出（throy）和捕捉（catch） C．检查（try）、捕捉（catch）和处理（heandl） D．检查（try）、抛出（throy）和处理（heandl） 8-3．关于异常处理，以下说法不正确的是（ C ）。 A．被检测的函数必须放在try块中 B． try块和catch块作为一个整体出现

C．catch既要检查所捕获的异常信息的类型，也检查它们的值 D．如果throw抛出的异常信息找不到与之匹配的catch块，

程序终止运行

8-4．关于命名空间，以下说法不正确的是（ D ）。

A．命名空间实际上是一个由程序设计者命名的内存区域 B．命名空间的作用是建立一些互相分隔的作用域，以免产生

名字冲突

C．全局变量独立于所有有名的命名空间之外，不需声明命名

空间

D．不能在一个命名空间内再定义一个命名空间

二、填空题

1-1．C++预定义的标准流包括 cin 、 cout 、cerr和clog。

1-2．要把PI=3.14159定义为常变量，定义语句是 const float

- 19 -

PI=3.14259 。

1-3．重载函数在函数类型或参数个数上不同，但 函数名 相同。

1-4．函数重载时，编译系统会根据 形参的类型 或 形参的个数 来区分，与返回类型无关。 1-5．所有的函数模板都是以 template 关键字和一个形参表开头的。 1-6．设函数max是由函数模板实现的，并且max(3.5,5)和max(2,5)都是正确的函数调用，则此函数模板具有 2 个类型参数。 1-7．如果一个函数既作为重载函数，又作为有默认值的函数，当调用函数时如果少写了一个参数，会出现 二义性 。 1-8．引用通常用作函数的 参数 和返回值。

1-9、C++语言的函数参数传递方式有 传值 和 传址 。 1-10要把一个函数指定为一个内置函数，有在函数首行的左端加一个关键字 inline 。 1-11．在C++中，用动态分配/撤消内存运算符 new 和 delete 分别取代C中的malloc和free函数。

1-12．New的功能是 动态申请 内存空间，delete的功能是 释放由new申请的 内存空间。

1-13．使用函数模板的方法是先说明函数模板，然后实例化成相应的 模板函数 进行调用、执行。

2-1．对象的三大特征是 封装 、 继承 和 多态 。 2-2．对象的三大基本特性是多态性、 继承 、封装性。 2-3．在C++类中可以包含 公共 、 保护 和 私有 三种具有不同访问控制权的成员。

2-4．如果在类的定义中既不指定private，也不指定public，则系统默认为是 私有的（private） 。

2-5．如果在类外定义成员函数，必须在函数名前加上类名和 作用域限定符“::” 。

2-6．在以下程序段的空白处填上合适的语句： Class Time {public: Int hour; Int minute; } ;

Time t,*p P=&t ;;

- 20 -

Cout<hour ; //输出p指向的对象中的成员hour 2-7．类的具体表现是通过创建 对象 来操作的。

3-1．构造函数的作用是 处理对象的初始化 。

3-2．析构函数的作用是 在撤消对象占用的内存之前完成一些清理工作 。

3-3．如果一个类的名称是Student，则它的析构函数名为 ~Student() 。

3-4．一个类可以有 多 个构造函数，有 一 个析构函数。

3-5．每一个成员函数都包含一个特殊的指针，这个指针称为 this ，它是指向本类对象的指针，它的值是当前被调用的成员函数所在对象的的 起始地址 。

3-6．如果要在定义对象时指定对象为常对象，应在对象名之前加上关键字 const 。

3-7．一个const对象只能访问 const 成员函数。

3-8．常成员函数 可以 访问常对象中的数据成员， 不允许 修改常对象中成员函数的值。

3-9． 若希望用一个已有对象构造另一个同类型的对象，可以使用 复制构造函数 来实现。

3-10．静态成员（static）属于 类 ，而不属于 任何一个对象 ，它被同一个类的所有对象共享。

3-11．由static修饰的数据成员为该类的所有对象 共享 。 3-12．静态成员函数是类的成员， 友元 函数不是类的成员。

3-13．C++类的组成包括数据成员和 成员函数 ，友元 不是 （是、不是）该类的成员函数。

3-14．友元函数是用关键字 friend 修饰的非成员函数。

3-15．使用友元函数是为了提高程序效率。且节约了 调用类的成员函数 的开销。

3-16．假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为 10 。

3-17．复制构造函数用它所在的类的 引用 作为参数。

4-1．运算符重载应保持原来的 优先级 、 结合性 和 运算顺序 。

4-2．重载运算符必须和用户定义的自定义类型的对象一起使用，

- 21 -

其参数至少应有一个是 类对象（或类对象的引用） 。

4-3．重载双目运算符“+”，如果作为类成员函数，它应有 1 个参数；如果作为友元函数，它应有 2 个参数。

4-4．在C++中，一般将单目运算符重载为 成员 函数，将双目运算符重载为 友元 函数。

4-6．重载运算符的含义必须清楚，不能有 二义性 。 4-7．重载运算符“<<”的函数名为 operator<< 。

4-8．重载流插入运算符“>>”的函数的第一个参数和函数的类型必须是 istream& 类型，第二个参数是 是要进行输入操作的类 。因此只能将它作为 友元 函数，不能把它定义为 成员 函数。

4-9．重载流提取运算符“<<”的函数的第一个参数和函数的类型必须是 ostream& 类型，第二个参数是 是要进行输出操作的类 。因此只能将它作为 友元 函数，不能把它定义为 成员 函数。

4-10．在C++中，实现标准类型之间的转换有 隐式 类型转换和 显式 类型转换。要将89.5转换为整数89，应写语句 int(89.5) 。

4-11．转换构造函数的作用是 将一个其他类型的数据转换成指定类的对象 。用转换构造函数将double型的参数r转换为复数Complex类的对象，定义函数的语句为：

Complex(double r) {real=r;imag=0;} 4-12．类型转换函数的作用是 将一个类的对象转换成另一类型的数据 。类型转换函数不能指定函数类型，也没有参数，只能作为 成员 函数，不能作为 友元 函数。

5-1．面向对象程序设计有4个主要特点： 抽象 、 封装 、 继承 和 多态性 。

5-2．在C++中，可重用性是通过 继承 机制来实现的。 5-3．类的继承方式有 public（或公用） 继承、 private（或私有） 继承和 protected（或保护） 继承。

5-4．在声明派生类时，如果不指定继承方式，则默认为 private(私有的) 。

5-5．派生类对基类继承控制访问有三种。派生类可以定义其基类中不具备的 数据和操作 。

5-6．基类的公用成员在私有派生类中是 私有 成员，基类的保护成员在公用派生类中是 保护 成员。 5-7．采用公用继承时，基类的公用成员在派生类中是 公用 成

- 22 -

员，基类的保护成员在派生类中是 保护 成员，基类的私有成员在派生类中是 不可访问的 成员。 5-7．采用私有继承时，基类的公用成员在派生类中是 私有 成员，基类的保护成员在派生类中是 私有 成员，基类的私有成员在派生类中是 不可访问的 成员。 5-8．采用保护继承时，基类的公用成员在派生类中是 保护 成员，基类的保护成员在派生类中是 保护 成员，基类的私有成员在派生类中是 不可访问的 成员。

5-9．如果在多级派生时都采用公用继承方式，直到最后一级派生类都能访问基类的 公用 成员和 保护 成员。如果采用私有的继承方式，经过若干次派生后，基类的 所有 成员会变得不可访问的。 5-10．在一个基类只有一级派生时，执行构造函数的顺序是：派生类构造函数先调用 基类 的构造函数，再执行 派生类的构造函数本身 。 在派生类的对象释放时，先执行 派生类 的析构函数，在执行 基类 的析构函数。

5-11．声明虚基类的一般形式为：

Class 派生类名: virtual 继承方式 基类名

6-1．在C++中，函数重载与虚函数帮助实现了类的 多态 性。 6-2．从系统实现的角度看，多态性分为两类： 静态多态性 和 动态多态性 。函数重载和运算符重载实现的是多态性属于 静态多态性 ，通过虚函数实现的多态性属于 动态多态性 。

6-3．确定调用的具体对象的过程称为关联。按照关联所处阶段的不同（如编译阶段、运行阶段），关联分为 静态关联 和 动态关联 。

6-4．当基类中的某个成员函数被声明为虚函数后，此虚函数就可以在一个或多个派生类中被重新定义，在派生类中重新定义时，其函数原型，包括返回类型、 函数名 、 参数个数 、参数类型以及参数的顺序都必须与基类中的原型完全相同。

6-5．如果一个类中至少有一个纯虚函数，则该类称为 抽象类 。

7-1．C++的输入输出包括3方面的内容： 标准的输入输出 、 文件的输入输出 和 字符串输入输出 。

7-2．C++的I/O是以 字节流 的形式实现的，每个C++编译相同都带有一个面向对象的输入/输出软件包，这就是 I/O流类库 。

- 23 -

7-3．C++的的抽象基类ios派生出四个类，它们是 istream 、 ostream 、 fstreambase 和 strstreanbase 。

7-4．Iostream文件中定义的4种流对象是 cin 、 cout 、 cerr 和 clog 。

7-5．读入一个字符可以用 cin.get 函数，读入一行字符可以用 cin.getline 函数；输出一个字符可以用 cout.put 函数。

7-6．常用的文件有两大类： 程序文件 和 数据文件 。 7-7．根据文件的组织形式，文件可分为 ASCII文件 和 二进制文件 。

8-1．程序中常见的错误有两大类： 语法错误 和 运行错误 。

8-2．C++处理异常的机制是由3个部分组成的，即 检查（try） 、 抛出（throw） 和 捕捉（catch） 。

8-3．可以利用命名空间来解决 名字冲突 问题。标准C++库是所有标识符都是在一个名为 std 的命名空间中定义的。

三、是非判断题

1-1．C++只能用于面向对象程序设计，不适用于面向过程程序设计。（ × ）

1-2．引用和指针都可作函数参数。（ √ ） 1-3．引用可以不初始化。（ × ）

1-4．内置函数的定义必须出现在第一次调用内置函数之前。（ √ ）

1-5．字符串\sdfgh\的长度是5。（ √ ）

1-6．将字符串常量存放到字符串变量时，包含字符串本身和结束符“\\0”。（ × ）

1-7．关系运算符可以用来比较两个字符的大小，也可用来比较两个字符串的大小。（ √ ）

1-8．使用new运算符创建数组时，可以为该数组指定初始值（ × ）。

2-1．C++语言支持封装性和继承性，不支持多态性。（ × ）。 2-2．在用class定义一个类时，如果不加声明，数据成员和成员函数默认的访问权限是public。（ × ）

2-3．在设计类时一般把数据成员设置为私有的，把函数成员设置为公用的，从而实现了公用接口和私有实现的分离。（ √ ）

- 24 -

3-1．构造函数可以重载。（ √ ）

3-2．在调用构造函数时不必给出实参的构造函数称为默认构造函数。一个类只能有一个默认构造函数。（ √ ）

3-3．对使用默认参数的构造函数，如果在类外定义构造函数，应该在定义构造函数时指定默认值（ × ）。

3-4．析构函数不能被继承。（ √ ）

3-5．析构函数必须指定返回类型以及函数参数。（ × ） 3-6．如果定义了一个类的对象数组，该数组有10个元素，则要调用10次构造函数来对每个元素初始化。（ √ ）。

3-7．友元函数说明在类体内，它是一种成员函数。（ × ） 3-8．友元类必须被说明为公用成员。（ × ）

4-1．C++允许用户可以定义新的运算符。例如，可将“**”定义为幂运算符。（ × ）

4-2．C++中的所有运算符都允许重载。（ × ） 4-3．重载函数不能改变运算符运算对象的个数。（ √ ） 4-4．运算符重载以后，其优先级和结合性都不能改变。（ √ ） 4-5．重载单目运算符作为类的成员函数，函数没有参数。（ √ ）

4-6．将运算符“+”函数重载为类的成员函数，交换律不适用。（ √ ）

5-1．不能通过派生类对象引用从私有基类继承过来的任何成员。（ √ ）

5-2．若类Y是类X的私有派生类，类Z是类Y的公用派生类，则类Z不能访问类X 的公用成员和保护成员。（ √ ）

5-3．私有继承的派生类不能访问基类中的私有成员，但公用继承的派生类可以访问基类中的私有成员。（ × ）

5-4．若类B是类A的私有派生类，类C是类B的私有派生类，则类C可访问类A的公用成员。（ × ）

5-5．在声明派生类时，派生类把基类的的构造函数也一起继承过来。（ × ）

5-6．派生类能够继承基类的析构函数。（ × ）

5-7．使用虚函数可以避免多重继承产生的二义性。（ √ ）

6-1．C++中设置虚基类的目的是实现运算时的多态性。（ √ ） 6-2．在类的继承层次结构中，在不同的层次中不能出现名字相同、

- 25 -

class number {

private: int val; public:

number(int i){val=i;}

【1】 int(); //声明类型转换函数 };

number::operator int(){ 【2】 } 数

class num:public number {

public:

num(int i):number(i){} };

void main() {

num n(100); int i=n;

cout<

答案：【1】 operator 【2】 return val;

六、阅读程序，写出程序的输出结果 1-1．

#include int add(int x,int y) {

return x+y+1; }

double add(double x,double y) {

return x+y-1; }

void main()

- 36 -

//定义类型转换函

{

int a=2,b=4 ;

double c=2.7,d=7.4 ;

cout<<\ \

}

执行结果是： 答案：add(a,b)=7 add(c,d)=9.1 1-2．

#include int func(int a) {

int b=0;

static int c=4; 第1次循环： b++;c--;

i=2,j=0,i+j=2,a=2,b=0,c=4,a+b+c=6 return (a+b+c);

}

第2次循环： void main()

{ i=2,j=1,i+j=3,a=3,b=0,c=3,a+b+c=6 int i=2;

for(int j=0;j<2;j++)

cout<

运行结果： 答案：6 6 1-3．

#include

i=1时，j=1, j不小于 i，不执行whilevoid main()

循环，没有输出； { int i,j;

for(i=1;i<=3;i++) i=2时，j=1, j小于 i，执行while循环， {j=1; 执行cout<

i=3时，j=1, j小于 i，执行while循环， }

执行cout<

} 1； 然后j=2，j小于 i，执行while循环，- 37 -

执行cout<

#include void func(int,int,int *); void main() { int x,y,z;

func(1,2,&x); //a=1,b=2,c指向

x,b=b-a=2-1=1,x=*c=b-a=1-1=0

func(3,x,&y); //a=3,b=x=0,c指向

y,b=b-a=0-3=-3,y=*c=b-a=-3-3=-6

func(x,y,&z); //a=0,b=-6,c指向

z,b=b-a=-6-0=-6,z=*c=-6-0=-6

cout<

void func(int a,int b,int *c) {

b-=a; *c=b-a; }

输出结果：

答案： 0 -6 -6 3-1．

#include class Sample { int n; public:

Sample(int i){n=i;}

friend int add(Sample &s1,Sample &s2);

- 38 -

};

int add(Sample &s1,Sample &s2) {

return s1.n+s2.n; }

void main() {

Sample s1(10),s2(20); cout<

执行结果是： 答案：30

3-2．

#include class myclass {

int a,b; static int s; public:

myclass(int x,int y) {a=x;b=y;s++;} void print()

{cout<

int myclass::s=0; void main() {

myclass m1(1,2),m2(4,5),m3(6,7); m1.print(); m2.print(); m3.print(); }

执行结果是： 答案：

3

- 39 -

3 3 3-3．

#include class X {

public: X(int i)

{x=i;cout<<\ X(double i)

{x=(int)i*2;cout<<\ ~X()

{cout<<\ ~X(): \ private: int x; };

void main() {

int a=8;

double b=11.0; X x1(55),x2(a*5); X x3=X(2*a); X x4=X(b); }

输出结果为： 答案：

Int:55,called Int:40,called Int:16,called double:11,called ~X():22,called ~X():16,called ~X():40,called ~X():55,called

3-4．

- 40 -

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