一、单项选择题
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); 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 ）。
- 1 -
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 ）。 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];
2-1．C++对C语言作了很多改进，即从面向过程变成为面向对象的主要原因是（ D ）。 A．增加了一些新的运算符 B．允许函数重载，并允许设置缺省参数 C．规定函数说明符必须用原型 D．引进了类和对象的概念
2-2．面向对象软件开发中使用的OOA表示（ A ）。
- 2 -
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为该类的一个对象，则访问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．构造函数名字和类名相同
- 3 -
B．构造函数在创建对象时自动执行
C．构造函数无任何函数返回类型 D．构造函数有且只有一个
3-2．类的构造函数是在定义该类的一个( )时被自动调用执行的。 A. 成员函数 B. 数据成员 C. 对象 D. 友元函数 3-3．一个类的构造函数通常被定义为该类的( A )成员。 A. 公用 B. 保护 C. 私有 D. 友元
3-4．关于构造函数特点描述中，错误的是（ A ）。 A．定义构造函数必须指出类型 B．构造函数的名字与该类的类名相同 C．一个类中可以定义0个至多个构造函数 D．构造函数是一个成员函数
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
3-15．假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为( C )。
- 4 -
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是该类的一个成员函数，则参数表中隐含的第一个参数的类型为（ 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．对象创建时产生
- 5 -
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 ）中进行的。 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 ）。
A. 只能是公有成员 B. 只能是保护成员
C. 只能是除私有成员之外的任何成员 D. 具有任何权限的成员
- 6 -
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．在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（ 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 ）。
- 7 -
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．用转换构造函数
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. 私有继承的公有成员
- 8 -
5-5．基类和派生类可以分别称为（ B ）。
A．“大类”和“小类” B．“父类”和“子类” C．“小类”和“大类” 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. 保护成员和私有成员 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．假设定义了以下的类：
- 9 -
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() 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;
- 10 -
public:
B(int m,int n,int u):A(m,n),k(u){} void Make(){k=i*j;} };
int main() {
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．继承 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．通过指针或引用调用一虚函数
- 11 -
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++的输入输出不包括（ ）。
A．标准的输入输出 B．文件的输入输出
C．字符串输入输出 D．显示屏和打印机的输入输出 7-2．下面的类中，（ ）不是由抽象基类ios直接派生出来的。 A．istream B．ostream C．iostream D．fstreambase 7-3．在C++中，抽象基类ios直接派生出（ ）。 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 ）类中的一个对象。
- 12 -
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') 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 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++语言的函数参数传递方式有 传值 和 传址 。
- 13 -
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 ;;
Cout<
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．静态成员函数是类的成员， 友元 函数不是类的成员。
- 14 -
3-13．C++类的组成包括数据成员和 成员函数 ，友元 不是 （是、不是）该类的成员函数。
3-14．友元函数是用关键字 friend 修饰的非成员函数。
3-15．使用友元函数是为了提高程序效率。且节约了 调用类的成员函数 的开销。 3-16．假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为 10 。
3-17．复制构造函数用它所在的类的 引用 作为参数。
4-1．运算符重载应保持原来的 优先级 、 结合性 和 运算顺序 。 4-2．重载运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是 类对象（或类对象的引用） 。
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．采用公用继承时，基类的公用成员在派生类中是 公用 成员，基类的保护成员在派生类中是 保护 成员，基类的私有成员在派生类中是 不可访问的 成员。
5-7．采用私有继承时，基类的公用成员在派生类中是 私有 成员，基类的保护成员在派生类中是 私有 成员，基类的私有成员在派生类中是 不可访问的 成员。
- 15 -
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流类库 。
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．引用和指针都可作函数参数。（ √ ）
- 16 -
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．在设计类时一般把数据成员设置为私有的，把函数成员设置为公用的，从而实现了公用接口和私有实现的分离。（ √ ）
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．使用虚函数可以避免多重继承产生的二义性。（ √ ）
- 17 -
6-1．C++中设置虚基类的目的是实现运算时的多态性。（ √ ）
6-2．在类的继承层次结构中，在不同的层次中不能出现名字相同、参数个数和类型都相同而功能不同的函数。（ × ）
6-3．当一个成员函数被声明为虚函数后，其派生类中的具有相同参数类型和相同参数个数类型的相同类型的同名函数也是虚函数。（ √ ）
6-4．纯虚函数是在基类中说明的虚函数，它在该基类中必须定义具体的操作内容。（ × ）
6-5．不可以定义抽象类的对象。（ √ ）
7-1．C++中的字符串输入输出通常指定一个字符数组作为存储空间，它只能输入输出string类数据。（ × ）
7-2．Iostream是抽象基类ios的直接派生类.。（ × ）
7-3．打开一个二进制文件时可以同时指定它既是输入文件又是输出文件。（ √ ） 7-4．使用字符串流时必须打开文件。（ × ）
8-1．程序运行过程出现异常是由于语法错误引起的。（ × ）
8-2．在C++的异常处理方法中，try块和catch块必须作为一个整体出现。（ √ ） 8-3．在C++中，在文件中只能用“#include
四、程序改错题
3-1．下面程序中有一错误，请指出错误的行，说明错误原因，并加以改正。 #include 第5行应为形参增加默认值，例如改为 Test(int m=0):a(m){} 3-2．使用VC6打开考生文件夹下的工程proj1，此工程包含一个源程序文件main.cpp， - 18 - 但该程序运行有问题，请改正main函数中的错误（指出行号及改正后的语句），使程序的输出结果为： member=0 member=5 member=10 源程序文件main.cpp清单如下： #include MyClass obj2(3) ; //16 obj1.member=5 ; //17 MyClass.SetMember(10); //18 obj1.print(); //19 obj2.print(); //20 } //21 答案： 14行更正为：MyClass obj1(0); 17行更正为：obj1.SetMenber(5); 18行更正为：obj2.SetMenber(10); 3-3．下面程序中类的定义中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include {return m_iSize;} //8 int &operator[](int iIndex) //9 {return m_pArray[iIndex-1];} //10 private: //11 - 19 - int m_pArray[]; //12 int *m_pArray; //指向一个数组空间 //13 int m_iSize; //数组元素个数 //14 }; //15 //16 int main(void) //17 { //18 int s[]={3,7,2,1,5}; //19 CArray oArray(s,5); //20 oArray[1]=9; //21 for(int i=1;i<=5;i++) //22 {cout< 第6行错误 原因：构造函数不能有返回值类型 改正：去掉void 3-4．下面程序中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include 第7、14行有错，常对象只能调用常成员函数。 改正：将第7行改为：void Print() const 或将第14行改为 ：// CTest oTest(12,16); 4-1．下面的程序是定义一个类型转换函数进行数据类型转换。程序中类的定义有一处错误，请指出出错的行，说明错误原因，并加以改正。 - 20 - #include CInteger(int iNum=0) //6 {m_iNum=iNum;} //7 int operator int() //8 {return m_iNum;} //9 void Print() const //10 {cout< 第8行有错误。原因：类型转换函数没有返回值类型。 改正：去掉返回值类型int 6-1．下面程序中有一处错误，请指出出错的行，说明错误原因，并加以改正。 #include CBase(int iBase=0):m_iBase(iBase){} //5 virtual void Show() const=0; //6 int Get() const //7 { return m_iBase; } //8 private: //9 int m_iBase; //10 }; //11 class CDerive:public CBase //12 { public: //13 CDerive(int iBase=0,int iDerive=0):CBase(iBase) //14 { m_iDerive=iDerive;} //15 void Show() const //16 { cout< - 21 - int m_iDerive; //19 }; //20 //21 void Print(const CBase obj) //22 { obj.Show();} //23 //24 int main(void) //25 { CDerive obj(10); //26 Print(obj); //27 return 0; //28 } //29 答案： 第22行出错 原因：抽象类不能用来直接作函数参数，但可以使用抽象类的引用作参数 改正：将第22行改为： void Print(const Cbase &obj) 6-2．要求用下面的程序实现动态多态性，但程序有错，请指出错误并改正之（指出行号，说明错误原因，写出改正后的语句）。 #include public: //4 void f(){cout<<\ //5 }; //6 //7 class CC:public AA //8 { //9 public: //10 virtual void f(){cout<<\ //11 }; //12 //13 int main() //14 { //15 AA aa,*p; //16 CC cc; //17 p=&cc; //18 p.f(); //19 return 0; //20 } //21 答案： 第5行中基类中虚函数f()前应加关键字virtual修饰，应改为： virtual void f(){cout<<\第19行p.f();应改为：p->f(); - 22 - 五、程序填空题 1-1．下面程序的功能是：输入三角形的三条边放在变量a，b和c中，判断它们能否构成三角形，若能，则判断是等边、等腰、还是其他三角形，在横线上填上适当内容。 #include cout<<\ 【1】 ; //输入三角形的三条边 if(a+b>c&&b+c>a&&c+a>b) { if( 【2】 ) //判断是否为等边三角形 cout<<\等边三角形!\\n\ else if( 【3】 ) //判断是否为等腰三角形 cout<<\等腰三角形!\\n\ else cout<<\其它三角形!\\n\ } else cout<<\不能构成三角形!\\n\} 答案：【1】 cin>>a>>b>>c 【2】 a==b&&b==c 【3】 a==b||a==c||b==c 1-2．以下程序功能是输出1000以内个位数为6且能被3整除的所有数。请填空。 #include { int i,j; for(i=0; 【1】 ;i++) //i的终值，即结束循环的条件 { j=i*10+6; if( 【2】 ) continue; //如果j是否不能给3整除 // j%3 cout< } } 答案：【1】 i<100 【2】 j%3 1-3．求n（n≥6）内的所有偶数表示为两个素数之和，图1为输入12的运行结果。补充完整以下程序。【提示：一个偶数n（n≥6）可以表示为1+(n-1), 2+(n-2),3+(n-3),?】 - 23 - 图1 #include { int num; cout<<\请输入一个整数N(N>=6):\\n\ cin>>num; for(int n=6; 【1】 ;n+=2) //n的终值，即结束循环的条件 // n<=num for(int i=3;i<=n/2;i+=2) if( 【2】 ) //判断i和n-i是否素数 } { { cout< } int isprime(int n) int i,sqrtm=(int)sqrt(n); for(i=2; 【3】 ;i++) //i的终值，即结束循环的条件 if( 【4】 )return 0; //如果n为素数，返回0 【5】 ; //否则返回1 } 答案：【1】 n<=num 【2】 isprime(i)&&isprime(n-i) 【3】 i<=sqrtm 【4】 n%i==0 【5】 return 1 3-1．完成下面类中成员函数的定义。 #include { public: Test(int,float); //声明构造函数 test(test&); //声明成员函数text，将test引用对象的值向num和x赋值 private: int num; float x; }; test::Test(int n,float f) //定义构造函数 { num=n; - 24 - 【1】 ; } test::test(test& t) { 【2】 ; x=t.x; } 答案：【1】 x=f; 【2】 num=t.num; 3-2．根据下面的主程序，完成类说明的最小形式（不要求实现成员函数的定义）。 #include private: 【1】 ; //定义数据成员num public: 【2】 ; //构造函数声明 }; void main() { Base base1(8) ; } 答案：【1】 int num 【2】 Base(int n) 3-3．一个类的头文件如下所示，程序产生对象T，且T.num=10，并使用P()函数输出这个对象的值。 #include private: int num; public: }; test::test(int n){num=n;} void test::P(){cout< void main() { 【1】 ; //定义类对象 - 25 - test(int); void P(); 【2】 ; //输出对象的值 } 答案：【1】 test T(10) 【2】 T.P() 4-1．填上合适的语句，使程序的最终结果为200。 #include 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 return x+y+1; } double add(double x,double y) { return x+y-1; } void main() { - 26 - //声明类型转换函数 //定义类型转换函数 int a=2,b=4 ; double c=2.7,d=7.4 ; cout<<\ \ } 执行结果是： 答案：add(a,b)=7 add(c,d)=10.1 1-2． #include int func(int a) { int b=0; static int c=4; b++;c--; return (a+b+c); } void main() { int i=2; for(int j=0;j<2;j++) cout< 运行结果： 答案：6 6 1-3． #include for(i=1;i<=3;i++) {j=1; while(j 输出结果： 答案： 2 1 3 1 3 2 - 27 - { cout< } } 1-4． #include func(x,y,&z); cout< void func(int a,int b,int *c) { } 输出结果： 答案： 0 -6 -6 3-1． #include 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 3-2． - 28 - b-=a; *c=b-a; #include 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 3 3 3-3． #include 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); - 29 - 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():50,called 3-4． #include public: CPosition(int iPositionX=0,int iPositionY=0):m_iPositionX(iPositionX),m_iPositionY(iPositionY){} int GetPositionX() const {return m_iPositionX;} }; int main(void) { CPosition oPosition1; - 30 - int GetPositionY() const {return m_iPositionY;} void SetPositionX(int iPositionX) {m_iPositionX=iPositionX;} void SetPositionY(int iPositionY) {m_iPositionY=iPositionY;} private: int m_iPositionX; //X坐标 int m_iPositionY; //Y坐标 CPosition oPosition2(6,8); cout< cout< cout< cout< 输出结果： 答案： 0 16 18 6 8 3-5．阅读下面的类模板程序，写出输出结果。 #include public: CTest(Type m_tArray[],int iSize):m_pArray(m_tArray),m_iSize(iSize){} void Print() const {for(int i=0;i {cout< private: Type *m_pArray; }; int main(void) { int a[]={1,0,8}; double b[]={1.6,1.8}; CTest CTest - 31 - int m_iSize; oTest2. Print(); cout< 输出结果： 答案：1 0 8 1.6 1.8 3-6．阅读下面程序，写出输出结果。 #include public: CGoods(int iWeight) { m_iWeight=iWeight; m_iTotalWeight=m_iTotalWeight+iWeight; } CGoods(const CGoods &oGood) { m_iWeight=oGood.m_iWeight; m_iTotalWeight=m_iTotalWeight+m_iWeight; } ~CGoods() { m_iTotalWeight=m_iTotalWeight-m_iWeight; } void Print() const; static int GetTotalWeight() { return m_iTotalWeight; } private: int m_iWeight; static int m_iTotalWeight; }; int CGoods::m_iTotalWeight=8; //初始化静态数据成员 void CGoods::Print() const { cout< - 32 - \ int main(void) { CGoods oGood1(6); oGood1.Print(); CGoods oGood2(oGood1); oGood2.Print(); cout< return 0; } 输出结果： 答案：6 14 6 20 20 3-7．阅读下面程序，写出输出结果。 #include public: CTest(Type tA=0,Type tB=0,Type tC=0):m_tC(tC) { m_tA=tA; m_tB=tB; } void Print() { cout< void Print() const { cout< Type m_tA,m_tB; const Type m_tC; }; int main(void) { CTest - 33 - oTest1.Print(); CTest const CTest cout< 输出结果： 答案： 0 0 1 9 1.8 3-8．分析下列程序可能的输出结果。 #include private: int num; public: }; test(); int TEST(){return num;} ~test(); test::test(){num=0;} test::~test(){cout<<\ void main() { test x[3]; cout<<\} 输出结果： 答案： Exiting main Destructor is active Destructor is active - 34 - Destructor is active 3-9．若有以下程序： #include class Point { int x,y; public: Point(int m=0,int n=0){x=m;y=n;} void Show(){cout<<\}; int main() { } 输出结果为： 答案：x=1,y=68 3-10．若有以下程序： #include public: Sample(int i){n=i;s+=n;} static int s; void Show(){cout< int Sample::s=0; int main() { } 输出结果为： 答案：15 - 35 - Point *p=new Point(1,68); p->Show(); delete p; return 0; Sample a(2),b(5),c(8); c.Show(); return 0; 5-1．若有以下程序： #include { a=aa; cout<<\ } }; class B:public A { int b; public: B(int aa=0,int bb=0):A(aa) { b=bb; cout<<\ } }; int main() { B x(5),y(6,7); return 0; } 输出结果为： 答案： A():5 B():0 A():6 B():7 5-2．若有以下程序： #include public: Base(int x){a=x;} void Show(){cout< - 36 - }; class Derived:public Base { public: Derived(int i):Base(i+1),b(i){} void Show(){cout< private: int b; }; int main() { Base b(5),*pb; Derived d(1); pb=&d; pb->Show(); return 0; } 输出结果为： 答案：2 5-3．若有以下程序： #include void Fun(){cout<<\ private: int a; }; class Derived:public Base { public: Fun(){cout<<\}; int main() { Derived a; Base *p; p=&a; (*p).Fun(); - 37 - a.Fun(); return 0; } 输出结果为： 答案： 1 2 七、编程题 1-1．输入一组数据，以-1作为结束标志，要求删除其它数据，只保留能被2整除的数据并输出结果。 参考答案： #include int b[50],x,n=0; cin>>x; while(x!=-1) { b[++n]=x; cin>>x; } for(int i=1,j=0;i<=n;i++) if(b[i]%2==0)b[++j]=b[i]; for(i=1;i<=j;i++) cout< } 1-2．编写一个函数模板，用于求数组中各元素之和，并编写过程进行测试。 函数模板声明如下： template Type Sum(Type tArray[],int iSize) 参考答案： #include template Type Sum(Type tArray[],int iSize) { Type tSum=0; for(int i=0;i - 38 - int main(void) { int a[]={1,2,3}; double b[]={1.5,2.8,8.9,8}; cout< 2-1．下面是一个类的测试程序，设计出能使用如下测试程序的类： void main() { Test x; x.initx(300,200); x.printx(); } 输出结果：300-200=100 参考答案：参考程序 #include private: int x,y; public: void initx(int initx,int inity){x=initx;y=inity;} void printx(){cout< void main() { Test x; x.initx(300,200); x.printx(); } 3-1．定义一个名为rectangle的矩形类，其属性为矩形的左上角与右下角两个点的坐标，根据这两个点的坐标可计算矩形的面积。 参考答案： #include { private: int x1,y1,x2,y2; - 39 - public: rectangle(int xx1,int yy1,int xx2,int yy2) { x1=xx1;y1=yy1;x2=xx2,y2=yy2; } int getarea() { return abs((x2-x1)*(y2-y1)); } }; void main() { rectangle rect1(3,7,8,5); cout< } 3-2．定义一个boat类与一个car类，二者都有weight属性，定义二者的一个友元函数totalweight()，计算二者的重量和。 参考答案： #include private: int weight; public: boat(int w):weight(w){} friend int totalweight(boat b1,car c1); }; class car { private: int weight; public: car(int w):weight(w){}; friend int totalweight(boat b1,car c1); }; int totalweight(boat b1,car c1) { return b1.weight+c1.weight; } void main() - 40 - { car c1(1000); boat b1(2000); cout< 3-3．定义一个日期类Date，包含年、月、日三个数据成员，以及一个求第二天的成员函数和输出日期的成员函数。 参考答案： #include private: int year,month,day; public: Date(int y,int m,int d) { year=y; month=m; day=d; } void nextday(); void display() { cout< void Date::nextday() { int totaldays[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},{31,29,31,30,31,30,31,31,30,31,30,31}}; day++; int leap=(year@0==0||year%4==0&&year0!=0); if(day>totaldays[leap][month-1]) { day=1;month++; if(month>12) { } month=1;year++; } } void main() - 41 - { int d,m,y; cout<<\请输入年、月、日：\\n\cin>>y>>m>>d; Date d1(y,m,d); cout<<\今天是：\d1.display(); d1.nextday(); cout<<\明天是：\d1.display(); } 4-1．定义一个二维坐标类Vector2d，2个数据成员x，y为double型，设为private属性。定义带两个参数的构造函数，再定义一个Show（）函数用以输出x，y的值，另外作为成员函数重载的运算符“+”的功能是将此类二个对象的数据成员x和y对应相加。这些成员函数的属性均为Public。请用C++编写此程序，并编写测试程序进行测试。 参考答案：参考程序： #include private: double x,y; public: Vector2d(double a,double b):x(a),y(b){} void Show(){cout< Vector2d Vector2d::operator+(Vector2d &obj) {return Vector2d(x+obj.x,y+obj.y);} int main() { Vector2d d1(3.5,4.5),d2(2.5,5.5),d3(0.0,0.0); } 5-1．设计一个汽车类vehicle，包含的数据成员有车轮个数wheels和车重weight。小车类car是它的派生类，其中包含载人数passenger_load。每个类都有相关数据的输出方法。在主程序中定义一个car类对象，对其车轮个数、车重、载人数进行设置并显示。 d3=d1+d2; d3.Show(); return 0; - 42 - 参考答案： #include class vehicle //定义汽车类 { protected: int wheels; //车轮数 float weight; //重量 public: vehicle(int wheels,float weight); int get_wheels(); float get_weight(); void show(); }; class car:public vehicle { int passenger_load; public: car(int wheels,float weight,int passengers=4); int get_passengers(); void show(); }; vehicle::vehicle(int wheels1,float weight1) { wheels=wheels1; weight=weight1; } int vehicle::get_wheels() { return wheels; } float vehicle::get_weight() { return weight; } void vehicle::show() { cout<<\车轮\个\ cout<<\重量\公斤\ } car::car(int wheels,float weight,int passengers):vehicle(wheels,weight) { passenger_load=passengers; - 43 - } int car::get_passengers() { return passenger_load; } void car::show() { cout<<\车型:小车\ vehicle::show(); cout<<\载人\人\ cout< car car1(4,2000,5); cout<< \输出结果\ car1.show(); } 6-1．定义一个抽象类CShape，它有一个纯虚函数GetLength(); 派生出四边型类CSquare和圆类CCircle，在派生类中重载函数GetLength()，用于求图形的周长，编写测试程序进行测试。 参考答案： #include class CShape { public: virtual double GetLength() const=0; }; class CSquare:public CShape { public: CSquare(double dWidth,double dHeight) { m_dWidth=dWidth; m_dHeight=dHeight; } double GetLength() const { return 2*(m_dWidth+m_dHeight); } private: double m_dWidth,m_dHeight; }; - 44 - class CCircle:public CShape { public: CCircle(double dRadius) { m_dRadius=dRadius; double GetLength() const { return 2*3.1415926*m_dRadius; } private: double m_dRadius; }; int main(void) { CSquare oSquare(2,3); cout< CCircle oCircle(10); cout< return 0; }; 8-1．设计一个类Rect，要求如下： （1）该类中的私有数据成员length，width存放它的长和宽，并且设置它们的默认值是0； （2）通过成员函数GetPerimeter求周长。要求确保长和宽都在（0，50）范围之内，否则进行异常处理。 答案：参考程序： #include private: double length,width; public: Rect(double l=0,double w=0):length(l),width(w){} double GetPerimeter() { if(length<=0||length>=50||width<=0||width>=50) throw length; //抛出异常 } return 2*(length+width); - 45 - } }; int main() { try //检查异常 } { Rect obj(20,30); cout<<\周长\ } catch(double) //捕捉异常 { //处理异常 cout<<\异常信息：数据不在指定的范围(0,50)\ } return 0; - 46 -