面向对象程序设计期末复习题及答案1

C++面向对象程序设计复习

试题类型 1、单项选择题(在每小题的四个备

选答案中，选出一个正确答案，并将正确答案的序号填在题干的括号内。15题，每小题2分，共30分) [主要从作业题目中抽出来]

2. 填空题。（10题，每小题3分，共30分）

3、阅读程序，写出程序运行结果。【也称计算题】（ 3题，每小题5分，共15分）

4、程序编制题【也称综合分析题】。 (第1、2题每题8分，第3题9分，共25分) 重点复习内

容

打*号是重点，打▲号是编程题出题范围 * 基本概念，对象，消息，类。

面向对象系统特性，封装性，继承性，多态性。 *▲ C++类的构成，类与对象，构造与析构，动态存储，类嵌套。

静态成员，对象数组，友元。 *函数重载。 运算符重载。

*引用定义与引用参数 * 基类与派生类的定义。

* 基类及派生类的访问权（含派生类对基类的访问、通过派生类对象对基类的访问）和初始化。 多继承与虚基类。 *多态性与虚函数。 纯虚函数、抽象类。 *▲函数模板。

*▲使用类来定义对象并在程序中的应用 题型样题

填空题 1. 假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为_________。 答案：10

2.可以用p.a的形式访问派生类对象P的基类成员a,其中a是_________。 答案：公有继承的公有成员

3.能作为重载函数的调用的依据是_________。 答案：参数个数 、参数类型

- 1 -

4.在进行完任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态；其中只能用于检测输入流是否结束状态的操作函数名称是_________ 答案：eof

5.函数重载是指_________。

答案：两个或两个以上的函数取相同的函数名，但形参的个数或类型不同

6.在派生类中重新定义虚函数时必须在 _________ 方面与基类保持一致。

答案：参数个数

阅读程序例题【计算题】

1．分析以下程序的执行结果 #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”<

cout<<“x!=y”<

void disp() {

cout<<“x=”<

void main() {

Sample s1,s2(2,3); s1.disp(); s2.disp(); }

解： x=0,y=0 x=2,y=3 x!=y x=y

2.分析以下程序的执行结果 #include int add(int x,int y) {

return x+y; }

int add(int x,int y,int z) {

return x+y+z; }

void main() {

int a=4,b=6,c=10;

cout<

10,20 3.分析以下程序执行结果 #include int add(int x,int y) {

return x+y; }

double add(double x,double y) {

return x+y; }

void main() {

int a=4,b=6;

double c=2.6,d=7.4;

cout<

4.分析以下程序执行的结果 #include class Sample {

int x,y; public:

Sample(){x=y=0;}

Sample(int a,int b){x=a;y=b;} void disp() {

cout<<\} };

void main() {

Sample s1,s2(1,2),s3(10,20); Sample *pa[3]={&s1,&s2,&s3}; for(int i=0;i<3;i++) pa[i]->disp(); }

解：

x=0,y=0 x=1,y=2

x=10,y=20 5. 分析以下程序的执行结果： #include class base {

int n; public: base(){}; base (int a) {

cout << \base class\<< endl; n=a;

cout << \}

~base() { cout << \base class\<< endl; } };

class subs : public base {

int m; public:

subs(int a, int b) : base(a) {

cout << \m=b;

cout << \}

~subs() { cout << \sub class \endl; } };

void main () {

subs s(1,2); }

解：

constructing base class n= 1

constructing sub class m= 2

destructing sub class destructing base class 6.分析以下程序的执行结果:

- 2 -

#include class Sample {

protected: int x; public:

Sample() { x=0; }

Sample(int val) { x=val; } void operator++() { x++; } };

class Derived:public Sample {

int y; public:

Derived():Sample(){ y=0; } Derived(int val1,int val2):Sample(val1){ y=val2; } void operator--(){ x--;y--;} void disp() {

cout<<\} };

void main () {

Derived d(3,5); d.disp(); d++;

d.disp (); d--; d--;

d.disp(); }

解： x=3,y=5 x=4,y=5 x=2,y=3

7 分析以下程序执行结果：

#include class A {

public:

A(char *s) { cout << s << endl; } ~A() {}

- 3 -

};

class B:public A {

public:

B(char *sl,char *s2) :A(sl) {

cout << s2 << endl; } };

class C:public A {

public:

C(char *sl,char *s2) :A(sl) {

cout << s2 << endl; } };

class D:public B,public C {

public: D(char *sl,char *s2,char *s3,char *s4) :B(sl,s2),C(sl,s3) {

cout << s4 << endl; } };

void main () {

D d(\A\B\C\D\}

解： class A class B class A class C

class D 补充例题

1.分析以下程序的执行结果 #include template T max(T x,T y)

{ return (x>y?x:y); } void main()

{ cout<

<

解答：5,3.5 2．分析以下程序的执行结果 #include void main() {

int a[]={10,20,30,40},*pa=a; int *&pb=pa; pb++;

cout<<*pa<

解答：

输出为:20 3.分析以下程序的执行结果 #include template T abs(T x)

{ return (x>0?x:-x); } void main()

{ cout<

解答：输出为：3，2.6

4.分析以下程序的执行结果 #include class Sample {

char c1,c2; public:

Sample(char a){c2=(c1=a)-32;} void disp()

{ cout<

void main() {

Sample a('a'),b('b'); a.disp(); b.disp(); }

解答：

a转换为A

b转换为B 5.分析以下程序的执行结果 #include void main() {

int &b=a; // 变量引用 b=10;

cout<<“a=”<

解答：

输出为：a=10 6.分析以下程序的执行结果 #include class Sample {

int x; public:

Sample(){};

Sample(int a){x=a;}

Sample(Sample &a){x=a.x++ +10;}

void disp(){cout<<“x=”<

void main()

{ Sample s1(2),s2(s1);

s1.disp(); s2.disp(); }

解答：

x=3 // ++运算的结果 x=12 // 2+10

7.分析以下程序的执行结果 #include class Sample {

int x; public:

Sample(){};

Sample(int a){x=a;}

Sample(Sample &a){x=a.x+1;}

void disp(){cout<<“x=”<

void main()

{ Sample s1(2),s2(s1);

s2.disp(); }

解答：

输出为：x=3。

程序编制题例题【综合分析题】

例1，写出一个梯形类，操作有求面积和周长

- 4 -

分析：由于要求梯形的面积和周长，那就要为梯形提供上底，下底，高，左边长，右边长等属性。因此，梯形类描述为：

Class echelon {

Int top,bottom,height,llength,rlength;

Public:

Echelon( ) { 。。。 } //构造函数 Int Area( ){ 。。。 } //求面积 Int Perimeter( ) { 。。。。} //求周长

} 2. 设计一个圆类circle和一个桌子类table，另设计一个圆桌类roundtable，它是从前两个类派生的，要求输出一个圆桌的高度、面积和颜色等数据。 解:

circle类包含私有数据成员radius和求圆面积的成员函数getarea()；

table类包含私有数据成员height和返回高度的成员函数getheight()。

roundtable类继承所有上述类的数据成员和成员函数，添加了私有数据成员color和相应的成员函数。

本题程序如下： #include #include class circle {

double radius; public:

circle(double r) { radius=r; }

double getarea() { return radius*radius*3.14; } };

class table {

double height; public:

table(double h) { height=h; }

double getheight() { return height; } };

class roundtable : public table,public circle {

char *color; public:

roundtable(double h, double r, char c[]) : circle (r) , table (h) {

color=new char[strlen(c)+1]; strcpy (color, c); }

char *getcolor() { return color; }

- 5 -

};

void main() {

roundtable rt(0.8,1.2,黑色);

cout << 圆桌属性数据: << endl; cout << 高度： <

cout << 颜色： <

3.编写程序，定义一个类test,其成员数据及函数要求如下：

(1)私有数据成员int data

(2)构造函数两个test () 及test(int d),前者将（１）中的数据成员data值设为0；后者将（１）中的数据成员data设定为指定值d

(3)成员函数int setdate()能在键盘读入一个数值，然后将该数值赋给data 4.定义一个抽象类tea代表茶叶，它有１个double类型的保护数据成员cost代表种植成本，它还有一个纯虚函数price用来计算售价：double price(void)函数返回值为茶叶的售价。由tea派生出具体类blacktea(红茶)，要求如下：

(1)类中定义保护成员数据double o_cost,表示红茶的经营成本

(2)定义构造函数blacktea(double btc,double bto_c),将cost 和o_cost,数据成员设定为指定值 (3)重载price计算出blacktea 的售价。（假设：blacktea 售价 =(cost + o_cost)*1.2）

5.编写一个程序，输入N个学生数据，包括学号、姓名、成绩，要求输出这些学生数据并计算平均分。

分析：

设计一个学生类Stud，除了包括no(学号)、name(姓名)和deg(成绩)数据成员外，有两个静态变量sum和num，分别存放总分和人数，另有两个普通成员函数setdata()和disp()，分别用于给数据成员赋值和输出数据成员的值，另有一个静态成员函数avg()，它用于计算平均分。在main()函数中定义了一个对象数组用于存储输入的学生数据。

本题程序如下： #include #include #define N 3 class Stud {

int no;

char name[10]; int deg;

static int num; static int sum; public:

void setdata(int n,char na[],int d) {

no=n; deg=d; strcpy(name,na); sum+=d; num++; }

static double avg() {

return sum/num; }

void disp() {

printf( %-5d%-8s=\\n,no,name,deg); } };

int Stud::sum=0; int Stud::num=0;

void main() {

Stud st[N]; int i,n,d; char na[10]; for(i=0;i

printf(输入学号 姓名 成绩：); scanf(%d%s%d,&n,na,&d); st[i].setdata(n,na,d); }

printf(输出数据\\n);

printf( 学号 姓名 成绩\\n); for(i=0;i

printf( 平均分=%g\\n\\n,Stud::avg()); }

本程序的执行结果如下：

输入学号 姓名 成绩： 1 stud1 89 输入学号 姓名 成绩： 2 stud2 78

输入学号 姓名 成绩： 3 stud 84 输出数据

学号 姓名 成绩 1 stud1 89 2 stud2 78 3 stud3 84 平均分=83

6．请编写一个程序，以实现在屏幕上显示如下的乘法表。 1) 1 2) 2 4 3) 3 6 9 4)4 8 12 16 5)5 10 15 20 25 6)6 12 18 24 30 36 7) 7 14 21 28 35 42 49 8)8 16 24 32 40 48 56 64

9) 9 18 27 36 45 54 63 72 81 7. P463-P464 函数模板

需要掌握的内容

面向对象程序设计的三大特征

类和对象

类: C++的一种数据类型，使用类的变量则称为对象。C++的类是对象的抽象，是进行封装和数据隐藏的工具，包括：数据成员和成员函数。一个类可以声明多个对象，对象之间代码共享，数据独立。

C++类的说明

public ：可被本类以外的函数访问，是类与外部的接口；

private ：只能被该类成员函数和友元函数存取和调用；

protected：可被本类和本类的派生类的成员函数访问，用于类的继承。

成员函数

- 6 -

默认时在类中定义的项都是私有的，类成员函数的外部实现：

使用对象名引用对象的公有成员函数。方法如下： 对象名.成员函数名（参数列表）

内联函数的概念;定义内联函数的两种格式 1)函数体放在类体内

2)函数体放在类体外，使用inline关键字

构造函数

构造函数的作用是在对象被创建时为对象分配内存空间，对类的数据成员初始化并执行对象的其他内部管理操作。 构造函数与类同名

构造函数可接收参数但不能有返回值，允许重载。 当创建一个类的对象时，系统会自动调用类的构造函数。

若未给类定义构造函数，则编译系统将为该类生成一个默认的构造函数，它没有参数，只简单地把对象中的每个实例变量初始化为0。

析构函数 一、 C++语言概述

1. 了解C++语言的基本符号。

2. 了解C++语言的词汇（保留字、标识符、常量、运算符、标点符号等）。

3. 掌握C++程序的基本框架（结构程序设计框架、面向对象程序设计框架等）。

4. 能够使用Visual C++ 6.0集成开发环境编辑、编译、运行与调度程序。

二、 数据类型、表达式和基本运算 1. 掌握C++数据类型（基本类型，指针类型）及其定义方法。

2. 了解C++的常量定义（整型常量，字符常量，逻辑常量，实型常量，地址常量，符号常量）。 3. 掌握变量的定义与使用方法（变量的定义及初始化，全局变量，局部变量）。

4. 掌握C++运算符的种类、运算优先级和结合性。

5. 熟练掌握C++表达式类型及求值规则（赋值运算，算术运算符和算术表达式，关系运算符和关系表达式，逻辑运算符和逻辑表达式，条件运算，指针运算，逗号表达式）。

- 7 -

三、 C++的基本语句

1. 掌握C++的基本语句，例如赋值语句、表达式语句、复合语句、输入、输出语句和空格语句等。

2. 用if语句实现分支结构。

3. 用switch语句实现多分支选择结构。 4. 用for语句实现循环结构。 5. 用while语句实现循环结构。 6. 用do…while语句实现循环结构。 7. 转向语句（goto，continue,break和return）。 8. 掌握分支语句和循环语句的各种嵌套使用。

四、 数组、指针与引用

1. 掌握一维数组的定义、初始化和访问，了解多维数组的定义、初始化和访问。 2. 了解字符串与字符数组。

3. 熟练掌握常用字符串函数（strlen,strcpy,streat,strcmp,strstr等）。

4. 指针与指针变量的概念，指针与地址运算符，指针与数组。

5. 引用的基本概念，引用的定义与使用。

注意事项： 搞清楚指针与地址运算符的区别，指针与引用的区别。

五、 掌握函数的有关使用

1. 函数的定义方法和调用方法。 2. 函数的类型和返回值。

3. 形式参数与实在参数，参数值的传递。 4. 变量的作用域、生存周期和存储类别（自动、静态、寄存器，外部）。 5. 递归函数。 6. 内联函数。

7. 带有缺省参数值的函数。

注意事项：C++中，函数之间传递参数有传值和传地址两种传递方式。

六、 熟练掌握类与对象的相关知识

1. 类的定义方式、数据成员、成员函数及访问权限（public,private,protected）。

2. 对象和对象指针的定义与使用。 3. 构造函数与析构函数。

4. 静态数据成员与静态成员函数的定义与

使用方式。

5. 常数据成员与常成员函数。 6. This指针的使用。 7. 友元函数和友元类。 8. 对象数组与成员对象。

七、 掌握类的继承与派生知识 1. 派生类的定义和访问权限。

2. 继承基类的数据成员与成员函数。 3. 基类指针与派生类指针的使用。 4. 虚基类。

八、 了解多态性概念

1. 虚函数机制的要点。

2. 纯虚函数与抽象基类，虚函数。 3. 了解运算符重载。

九、 模板

1. 掌握简单了解函数模板的定义和使用方式。

2. 掌握类模板的定义和使用方式，能够写出模板类呈现。

十、 输入输出流

1. 掌握C++流的概念。

2. 能够使用格式控制数据的输入输出。 3. 掌握文件的I/O操作。

详细的复习内容

一、C++语言语法基础

1、标识符

是以字母或下划线开头，由字母、数字、下划线组成的用来标识变量、函数、自定义类型的符号，它不能是C或C++的保留字。

2、变量声明与数据类型

变量的声明如右： 类型名称 变量名，变量名=初值；

指针变量的声明： 类型名称 *变量名； 数组的声明： 类型名称 数组名[数组元素个数]={初值，初值，初值……}；

标准数据类型： bool char int long unsigned float double

标准类型可以强制类型转换 例如：float x；int y=(int)x；

自定义数据类型： 结构struct 联合union 类class

定义方式： struct 自定义类型名

- 8 -

{ 成员变量类型 成员变量名； ………… }； 类类型除外

3、运算符与表达式

运算符：一元运算符： ++、--、*、& 等

二元运算符： +、-、*、/、+=、||、&& 等

三元运算符： ？： 分量运算符： ->、. 下标运算符： [ ] 括弧运算符： （ ）

动态存储运算符：new、delete

注意在一个表达式中运算符的优先级。其中尤其要注意++、--、->、.、*、&、=运算符。

4、C或C++语句

五种语句： 表达式语句： 例如： y=x*3+4；

空语句： ； 控制语句： 例如： break； if ( ***** ) ……else

函数调用语句： 例如： printf( ***** )；

复合语句： 例如： { x=9+y*5； cout<

除了复合语句以 } 号结束外，其余的语句全是用 ；结束。

语句可以混合使用： 例如 if (x!=3) { y=7；printf(“%d”,x*y)；} 其中有复合、控制、表达式、函数调用语句。

5、三种程序结构 1）顺序结构

2）分支结构 用if else switch…… case……default break 等控制。 3）循环结构 用 for while do……while break continue 控制

6、函数

函数在C或C++中就是子程序

函数的声明 返回类型 函数名（参数类型 形式参数名，………） { 函数体 return 返回值； } 其中void型函数无return 语句。

如果不立即写出函数的实现，只是一个函数原形的声明，可以省略形式参数，如下：

返回类型 函数名（参数类型，………）；

函数的参数可以缺省，例如： int f2 (int x, int y=8) { ……… }

同名函数如果参数的个数或类型不同，编译器能自动识别该调用那一个函数，这叫函数重载，例如： void f2 ( ){……} 与 void f2 (int x) {……}

7、指针

指针就是地址，指针声明见变量声明一节，指针指向同类变量： 指针名=&变量名； 取得指针指向的地址中的内容：*指针名

指针可以运算和赋值，但不能直接赋值数字，赋零除外，这时零表示空指针。

数组名就是固定指向数组开头的常数指针。

8、结构

结构的声明见变量声明，用结构类型定义变量： C中 struct 结构名 变量名； C++中 结构名 变量名；

结构成员变量的访问： 通过结构变量： 结构变量.成员变量 通过结构指针： 指针名->成员变量

在C++中结构是类的一种特例，也可以有成员函数，但它与类不同，它的成员缺省时是公有的。

二、面向对象的程序设计

1、类与对象的概念

类是一种自定义类型，是对一类对象的抽象，是对象的模板。

对象是一个实体，是类的实例，对象由类建立，对象封装了数据和对数据操作的函数，有一个边界，从外部对对象私有部分的访问是被禁止的，对对象的操作要通过它对外的公共接口（公有区）进行。

同类对象有相同的成员函数，相同的数据成员集合，但名字不同，数据成员的值也不一定相同（即对象的状态不同）。

对象的数据成员又叫对象的属性，对象的成员函数又叫对象的方法，调用对象的方法叫向对象发送消息。对象之间靠消息联系。

面向对象的程序设计就是向未知对象发送消息的程序设计，面向对象的程序就是一组通信的对象。

2、类的声明

class 类名：[public] 基类1名，[public] 基类2名，……

{ private：

类的私有成员，从对象外部不能访问，它的派生类也不能访问，只能它自己访问。 protected：

- 9 -

类的保护成员，从对象外部不能访问，它的

派生类和它自己可以访问。 public：

类的公有成员，对外公开的、可以任意访问的成员。 }；

成员变量的声明：在类的{}中象普通变量一样进行声明，但不能赋初值。

成员变量在对象中是这个对象的所有成员函数的全局变量。

成员函数的声明：在类的{}中先声明函数的原形，再在类的{}之外：

返回类型 类名：：函数名（参数类型 形式参数名，………） { 函数体 }

3、对象定义与使用

直接定义对象： 类名 对象名（构造函数实际参数）；

通过定义类指针定义对象： 类名 *指针名； 指针名=new 类名（构造函数实际参数）；

通过定义类指针定义的对象需要用删除： delete 指针名； 直接定义对象数组： 类名 数组名[数组元素个数]；

在定义对象数组时初始化数组：类名 数组名[数组元素个数]={类名（构造参数），……}； 通过类指针定义数组： 指针名=new 类名[数组元素个数]；

通过类指针定义对象数组不能调用带参数的构造函数对数组进行初始化。

通过类指针定义的数组的删除： deltet [ ]指针名；

使用对象成员：

直接定义的对象： 对象名.成员名

通过指针定义的对象： 指针名->成员名 一维对象数组元素的访问： 数组名[下标].成员名 或 （*（数组名+下标））.成员名 指针名[下标].成员名 或 （*（指针名+下标））.成员名

每个对象都有一个指向自己的常数指针，即this指针。在计算机中所有同类对象有不同的数据成员，但是只有共同的一组成员函数，成员函数靠this指针来识别是来自哪一个对象的调用。

同类对象可以相互赋值。对象间赋值缺省是对应成员的赋值，成员中有指针时通常需要重载赋值号 = 。普通类型变量向对象赋值时会自动调用相应的构造函数建立一个隐藏的临时对象，再进行对象间赋值。

4、构造与析构函数

构造函数是在用类定义对象时对对象进行初始化的函数，在定义对象时自动被调用。构造函数与类同名，无返回类型，可以有参数，可以重载，可以缺省参数。

析构函数是在对象撤消时自动被调用的，作用是用来清除对象动态申请的资源，析构函数与类同名，但前加一个~，无参数，不能重载。

构造函数和析构函数一般不能显式调用，构造函数在下面三种情况是例外：

对象数组初始化，在赋值号右边建立临时隐藏对象供对象赋值用，return 返回对象。

拷贝构造函数的参数是同类对象或同类对象的引用，缺省的拷贝构造函数是将样板对象的数据成员对应赋值给新建对象。当数据成员中有指针时，一般需要编写自己的拷贝构造函数。

5、静态成员

静态成员是同类对象的公共成员，静态成员函数没有this指针，不能直接访问类的普通成员，只能访问静态成员，普通成员函数可以访问静态成员，任何一个对象改变了静态成员变量的值，将改变所有对象的该成员。

在类外对静态成员变量的初始化： 类型 类：：成员变量=初始值；

6、友元

友元就是让类外的函数或别的类访问私有区，友元不是该类的成员，它破坏封装。 友元有三种：

友元函数。是类外的一般函数。声明：friend 返回类型 函数名(类 形式参数，…… )； 友元成员。是其它类的成员函数。声明：

friend 返回类型 其它类名：：函数名(类 形式参数，…… )；

友元类。别的类。声明：friend class 其它类名； 友元可以在类的任何区声明，友元声明是单向的，没有传递性。

由于友元没有this指针，所以友元的形式参数是对象或对象的引用。

7、类的继承和访问权限

派生类继承了基类的成员，可以有公有派生和私有派生。 继承关系如下：

有的部分被舍弃，反之不能赋值。

8、 多继承问题

一个类可以有多个基类，如果都是公有继承，在不同继承路径上继承的公共基类，由于在派生类中存在多个副本，会出现访问的二义性问题，要将这些副本合成一个，可以在派生时将这个基类声明为虚基类。

9、构造函数和析构函数的调用次序

在一个派生类中如果有对象成员，则基类、对象成员和派生类的构造次序如下：

先 基类 后 对象成员 最后 派生类对象自身 析构的次序与构造次序相反。

构造函数和析构函数的调用次序与构造和析构次序相同。

构造函数的实现如下：

派生类名：：构造函数名（参数表）：基类1构造函数（参数），基类1构造函数（参数），…… 对象成员1（构造参数表），对象成员2（构造参数表），…… { 派生类对象的构造函数体 }

10、流与流类库 流运算符：<< 、>>

流类库：iostream、istream、ostream、ios，ios是istream、ostream的基类，istream和ostream又是iostream的基类，ios是抽象类。 使用流类库要在程序前加上：#include “iostream.h”

标准输出流：cout 是流向屏幕，它是一个ostream类的对象。标准输入流：cin 是由键盘流入，它是一个istream类的对象。

11、函数重载

重载是指一个符号可以有多重意义。 函数重载参看前面所述。

一般函数、普通成员函数、构造函数可以重载，析构函数不能重载。

12、操作符重载

对于对象与对象、对象与标准类型变量之间的运算，需要对运算符重载。一般可以有成员函数重载和友元函数重载。函数名： operator运算符（参与运算的参数）

要注意++、--、<<、>> 运算符的重载，其中<<、>>运算符重载要流类（istream和ostream类）对象或引用作参数和返回值。

其中=、（）、[]、->只能用成员函数重载。 将类类型转换成普通类型与运算符重载类似。

普通类型转换成类类型用构造函数实现。

13、多态性

分为静态的多态性和动态的多态性。 静态的多态性用重载实现。

动态的多态性是指：同一个消息发给不同对象，对象的反应不同。它是在运行过程中进行连接的，所以由叫动态联编。它的基础是虚函数。

14、虚函数与纯虚函数

- 10 -

虚函数的声明： virtual 返回类型 函数名（参数表）；

当用基类指针指向派生类对象时，通过这个指针调用虚函数将首先调用派生类中的实现，如果派生类中没有写这个函数的实现，则调用基类中的实现。

虚函数的虚特性可以传递。如果派生类不写虚函数自己的实现，它又要在它的派生类中使用基类虚函数的虚特性，可以编写一个空的虚函数。 纯虚函数的声明： virtual 返回类型 函数名（参数表）=0；

纯虚函数不需要写它的实现，含有纯虚函数的类叫抽象类，不能建立对象，可以作基类和定义指针。

在抽象类的派生类中要写出纯虚函数的实现，否则需要再次声明这个函数是虚函数，这样这个派生类也是抽象类。

虚函数实现了动态连接，但在构造和析构函数中调用虚函数时是静态连接，即没有虚特性。

15、模板

函数模板与模板函数，定义、实例化，模板函数的重载。

类模板与模板类，定义、实例化，类模板的派生。

一、单选题

第1题 如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是( ) A、一元运算符 B、二元运算符

C、选项A)和选项B)都可能 D、重载错误 答案：D

第2题 C++ 类体系中，不能被派生类继承的有（ ）。

A、转换函数 B、构造函数 C、虚函数

D、静态成员函数 答案：B

第3题 以下叙述中正确的是( )

A、构成C++语言程序的基本单位是类 B、可以在一个函数中定义另一个函数 C、 main()函数必须放在其他函数之前

D、所有被调用的函数一定要在调用之前进行定义

答案：A

第4题 设int a=10，b=11，c=12;，表达式(a+b) 的值为( ) A、2 B、0 C、-2 D、1 答案：B

第5题 下列关于构造函数说法不正确的是( ) A、 构造函数必须与类同名 B、构造函数可以省略不写 C、构造函数必须有返回值

D、在构造函数中可以对类中的成员进行初始化

答案：C

第6题 设有数组定义：char array[]=”China\，则数组array所占的空间为( ) A、4个字节 B、5个字节 C、6个字节 D、7个字节 答案：C

第7题 若已定义：int a[]={0，1，2，3,4,5，6，7，8，9}，*P=a，i;其中O≤i≤9，则对a数组元素不正确的引用是( ) A、a[p-a] B、*(& a[i]) C、p[i] D、a[10] 答案：D

第8题 如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是( ) A、一元运算符 B、二元运算符

C、选项A)和选项B)都可能 D、重载错误 答案：D

- 11 -

第9题 表示在输出时显示小数位，和在文件输入时判断文件尾的函数分别是( ) A、showbase()和eof() B、showpoint()和eof() C、showpoint()和bad() D、showpoint()和good() 答案：B

第10题

下面程序的运行结果为( ) 以下是引用片段：#include void main() { for(int a=0,x=0;!x&&a<=10;a++) { a++; } cout < < a ； }

A、10 B、11 C、12 D、0 答案：C

第11题 以下各选项组中，均是C++语言关键字的组是( )

A、 public operator this B、 shod string static C、 it while〉=

D、 private cout printf 答案：A

第12题 在位运算中，操作数每右移一位，其结果相当于( )

A、操作数乘以2 B、操作数除以2 C、操作数乘以4 D、操作数除以4 答案：B

第13题 若定义int k=7,x=12;，则值为3的表达式是( )

A、x%=(k%=5) B、x%=(k-k%5) C、 x%=k-k%5 D、(x%=k)-(k%=5) 答案：D

第14题 一个类的友元函数能够访问该类的( )

A、 私有成员 B、保护成员 C、公有成员

D、所有成员 答案：D

第15题 设有数组定义：char array[]=”China\，则数组array所占的空间为( ) A、4个字节 B、5个字节 C、6个字节 D、7个字节 答案：C

第16题 下面关于数组的描述错误的是( ) A、在C++语言中数组的名字就是指向该数组第一个元素的指针

B、长度为n的数组，下标的范围是0-n-1 C、数组的大小必须在编译时确定

D、数组只能通过值参数和引用参数两种方式传递给函数 答案：D

第17题 下列关于模板的说法正确的是( ) A、 模板的实参在任何时候都可以省略 B、类模板与模板类所指的是同一概念 C、类模板的参数必须是虚拟类型的

D、类模板中的成员函数全部都是模板函数 答案：D

第18题 下列描述正确的是( )

A、表示m〉n为true或mn& & m

B、switch语句结构中必须有default语句 C、if语句结构中必须有else语句

D、如果至少有一个操作数为true，则包含“‖”运算符的表达式为true 答案：D

第19题 在进行完任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态；其中只能用于检测输入流状态的操作函数名称是（）

A、fail B、eof C、bad D、good 答案：B

第20题 下列描述中哪个是正确的( )。 A、私有派生的子类无法访问父类的成员 B、类A的私有派生子类的派生类,C无法初始化其祖先类A对象的属性，因为类A的成员对类C是不可访问的

- 12 -

C、私有派生类不能作为基类派生子类

D、私有派生类的所有子孙类将无法继续继承该类的成员 答案：B

第21题 在重载一个运算符时，如果其参数表中有一个参数，则说明该运算符是( ) A、一元成员运算符 B、二元成员运算符 C、一元友元运算符

D、选项B)和选项C)都可能 答案：D

第22题 下列关于构造函数的描述中，错误的是（）

A、构造函数可以设置默认参数

B、构造函数在定义类对象时自动执行 C、构造函数可以是内联函数 D、构造函数不可以重载 答案：D

第23题 函数fun的返回值是( ) 以下是引用片段：fun(char*a，char*b) { int num=0，n=0; while(*(a+num)!=‘\\0’)num++; while(b[n]){*(a+num)=b[n];num++;n++;} return num; } A、字符串a的长度 B、字符串b的长度

C、字符串a和b的长度之差 D、字符串a和b的长度之和 答案：D

第24题 下面关于类和对象的描述中，错误的是( )

A、类就是C语言中的结构体类型，对象就是C语言中的结构体变量

B、类和对象之间的关系是抽象和具体的关系 C、对象是类的实例，一个对象必须属于一个已知的类

D、 类是具有共同行为的若干对象的统一描述体

答案：A

第25题 下列描述正确的是( )

A、表示m> n为true或mn& & m

B、switch语句结构中必须有default语句 C、if语句结构中必须有else语句

D、如果至少有一个操作数为true，则包含“‖”运算符的表达式为true 答案：D

第26题 下列关于模板的说法正确的是( ) A、 模板的实参在任何时候都可以省略 B、类模板与模板类所指的是同一概念 C、类模板的参数必须是虚拟类型的

D、类模板中的成员函数全部都是模板函数 答案：D

第27题 在位运算中，操作数每右移一位，其结果相当于( )

A、操作数乘以2 B、操作数除以2 C、操作数乘以4 D、操作数除以4 答案：B

第28题

下列程序的运行结果为( )以下是引用片段： #includevoid print(double a){cout < < ++a;} void print(int a,int b) { cout < < a < < b；} void main() { print(1.2)； cout < < \ \; print(3,4)； }

A、1.2 34 B、2.2 34 C、1.2 43 D、2.2 43 答案：B

第29题 下列虚基类的声明中正确的是（ ） A、class virtual B: public A B、class B: virtual public A C、class B: public A virtual D、virtual class B: public A 答案：B

第30题 以下各选项组中，均是C++语言关键字的组是( )

A、 public operator this B、 shod string static C、 it while> =

D、 private cout printf 答案：A

- 13 -

第31题 下面程序的结果为( ),以下是引用片段：void main() { int i; int a[3][3]={1，2，3，4，5，6，7，8，9}; for(i=0;i〈3;i++) cout《a[i][2-i]; } A、1 5 9 B、7 5 3 C、3 5 7 D、5 9 1 答案：C

第32题 C++语言是从早期的C语言逐渐发展演变而来的.与C语言相比，它在求解问题方法上进行的最大改进是（ ） A、面向过程 B、面向对象 C、安全性 D、复用性 答案：B

第33题 下列关于C++语言类的描述中错误的是( )

A、类用于描述事物的属性和对事物的操作 B、类与类之间通过封装而具有明确的独立性 C、类与类之间必须是平等的关系，而不能组成层次结构

D、 类与类之间可以通过一些方法进行通信和联络 答案：C

第34题 下列关于构造函数说法不正确的是( )

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

D、在构造函数中可以对类中的成员进行初始化

答案：C

第35题 下面关于类和对象的描述中，错误的是( )

A、类就是C语言中的结构体类型，对象就是C语言中的结构体变量

B、类和对象之间的关系是抽象和具体的关系 C、对象是类的实例，一个对象必须属于一个已知的类

D、 类是具有共同行为的若干对象的统一描述体

答案：A

第36题 有以下结构体说明和变量的定义，且指针p指向变量a,指针q指向变量b。则不能把节点b连接到节点a 之后的语句是( ), 以下是引用片段：struct node { char data; struct node*next; }a，b，*p=&a，*q=&b; A、a. next=q B、p. next=& b C、p-> next=& b D、(*p).next=q 答案：B

第37题 以下叙述中正确的是( )

A、构成C++语言程序的基本单位是类 B、可以在一个函数中定义另一个函数 C、 main()函数必须放在其他函数之前

D、所有被调用的函数一定要在调用之前进行定义

答案：A

第38题 下列关于C++语言类的描述中错误的是( )

A、类用于描述事物的属性和对事物的操作 B、类与类之间通过封装而具有明确的独立性 C、类与类之间必须是平等的关系，而不能组成层次结构

D、 类与类之间可以通过一些方法进行通信和联络 答案：C

第39题 在C++语言中，数据封装要解决的问题是( )

A、数据的规范化 B、便于数据转换 C、避免数据丢失

D、防止不同模块之间数据的非法访问 答案：D

第40题 考虑函数原型void test(int a,int b=7,char=\下面的函数调用中，属于不合法调用的是（）

A、test(5) B、test(5,8) C、test(6,\#\) D、test(0,0.\*\) 答案：C

- 14 -

第41题 下面描述中，表达错误的是（） A、公有继承时基类中的public成员在派生类中仍是public的 B、公有继承是基类中的private成员在派生类中仍是private的 C、公有继承时基类中的protected成员在派生类中仍是protected的

D、私有继承时基类中的public成员在派生类中是private的 答案：B 第42题

下面程序的运行结果为( ) 以下是引用片段： #include class A { public: A(){cout<<\~A(){cout<<\}; class B:public A { public: B(){cout<<\~B(){cout<<\}; void main() { B b; }

A、1234 B、1324 C、1342 D、3142 答案：C

第43题 for(int x=0,y=0;!x& &y〈=5;y++)语句执行循环的次数是（） A、0 B、5 C、6

D、无次数 答案：C

第44题 下面程序的功能是把316表示为两个加数的和，使两个加数分别能被13和11整除，在划线处应填入的选项是( ),以下是引用片段：void main() { int i=0，j，k; do{i++;k=316-13*i;}while( ); j=k/11; cout《\《i《\《\1*\《j; } A、k/11 B、k% 11 C、k/11==0 D、k==0 答案：B

第45题 表示在输出时显示小数位，和在文件输入时判断文件尾的函数分别是( ) A、showbase()和eof() B、showpoint()和eof()

C、showpoint()和bad() D、showpoint()和good() 答案：B

二、填空题

第1题 假定x是一个逻辑量，则x & & true的值为__________。 答案：x

第2题 C++头文件和源程序文件的扩展名分别为______和______。 答案：.h .cpp

第3题 假定x=5，y=6，则表达式x++*++y的值为__________。

答案：35 第4题 假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为__________。 答案：AB::bb

第5题 字符串”\\nThis\\’s a pen\\n\\n”的长度为__________。 答案：15

第6题 变量分为全局和局部两种，________变量没有赋初值时，其值是不确定的。 答案：局部

第7题 一个函数的函数体就是一条_________语句。

答案：复合

第8题 变量分为全局和局部两种，________变量没有赋初值时，其值是不确定的。 答案：局部

第9题 假定x和y为整型，其值分别为16和5，则x/y和double(x)/y的值分别为__________和__________。 答案：3 3.2

第10题 对一个类中的数据成员的初始化可以通过构造函数中的______实现，也可以通过构造函数中的_________实现。 答案：初始化表 函数体

- 15 -

结束。

68. 当在程序中执行到___ break __语句时，将结束本层循环类语句或switch语句的执行。

69.当在程序中执行到_ continue _语句时，将结束所在循环语句中循环体的一次执行。 70. 在程序中执行到____ return ____语句时，将结束所在函数的执行过程，返回到调用该函数的位置。

71．在程序执行完___main_____函数调用后，将结束整个程序的执行过程，返回到C++集成开发窗口。

72. 元素类型为int的数组a[10]共占用____40____字节的存储空间。

73. 元素类型为double的二维数组a[4][6]共占用__192__字节的存储空间。

74. 元素类型为char的二维数组a[10][30]共占用___300___字节的存储空间。

75. 存储字符’a’和字符串”a”分别需要占用___1___和___2___个字节。

76. 空串的长度为____0____，存储它需要占用___1_____个字节。

77. 字符串”\\’a\\’xy=4\\n”的长度为___8_____。

78. 字符串”a:\\\\xxk\\\\数据”的长度为____11____。

79. 用于存储一个长度为n的字符串的字符数组的长度至少为___n+1_____。 80.若a是一个字符数组，则从键盘上向该数组输入一个字符串的表达式为_ cin>>a _。

81. 若a是一个字符数组，则向屏幕输出a中所存字符串的表达式为___ cout<

82. 一个二维字符数组a[10][20]能够存储___10_____个字符串，每个字符串的长度至多为____19____。

83. 对一个二维字符数组a进行初始化的数据为{”123”,”456”,”789”}，则a[1]元素对应的字符串为___”456”___。

84. strlen(”apple”)的值为____5____，strcmp(”a”,”A”)的值为___1___。

85. 假定对数组a[]进行初始化的数据为{2,7,9,6,5,7,10}，则a[2]和a[5]分别被初始化为___9_____和_____7___。

86. 假定对二维数组a[3][4]进行初始化的数据为{{3,5,6},{2,8},{7}}，则a[1][1]和a[2][3]分别被初始化为___8____和___0___。

87. 在C++语言中，一个函数由函数头和_____函数体_____组成。

88. 重载一个函数的条件是：该函数必须在参数的个数或参数的___类型__上与其它同名函数有所不同。

89. 如果一个函数只允许同一程序中的函数调用，则应在该函数定义前加上__ static ___C++保留字。

90. 若“double x=100;”是文件F1.CPP中的一个全局变量定义语句，若文件F2.CPP中的某个函数需要访问此x , 则应在文件F2.CPP中添加对x的声明语句为___ extern double x;___。

91. 定义一个函数模板要用到的第一个修饰符是__ template ___。

92. 在函数模板的参数中，用class修饰的参数称为____虚拟类型(或类型)___参数。

93. 如果一个函数直接或间接地调用自身，这样的调用称为___递归___调用。

94. 已知int cubin(int n){return n*n*n;}和double cubin(double n){return n*n*n;}是一个函数模板的两个实例，假定类型参数用T表示，则该函数模板的定义是___ template T cubin(T n){return n*n*n ; }____。

95. 对于无返回值函数，定义函数时要用_____ void _____修饰函数类型。

96. 如果一个函数定义中使用了___ static __修饰，则该函数不允许被其它文件中的函数调用。

97. 如果一个函数中有多个默认参数，则默认参数必须全部处在形参表的____右边（或后面）____部分。

98. 定义外部变量时，不用存储类说明符___ extern___，而声明外部变量时用它。

99．调用系统函数时，要先使用#include命令包含该系统函数的原型语句所在的___头文件___。

100. 函数形参的作用域是该函数的___函数体___。

101. C++提供的预处理命令有宏定义命令，条件编译命令和___文件包含命令___。

102. 程序的编译是以___文件___为单位进行的。

103.C++程序运行时的内存空间可以分成全

- 21 -

局数据区，堆区，栈区和__代码区__。

104. 全局变量和静态局部变量具有静态生存期，存放在内存的___全局数据___区中。

105. 局部变量具有局部生存期，存放在内存的___栈__区中。

106. 若二维数组a有m列，设a[0][0]位于数组的第一个位置上，则计算任一元素a[i][j]在数组中位置序号的公式为___ i*m+j+1___。

107. 若有定义“double a[3][5];”，则a 数组中行下标和列下标的最大值分别为____2__和___4__。

108. 若有定义“struct AA {int a; char b; double c;}x;”,则x占用空间大小为__13__字节。

109. 当定义一个结构体变量时，系统分配给该变量的内存大小等于各成员所需内存大小的___总和__。

110. 一个指针类型的对象占用内存的__4__个字节的存储空间。

111. 一个指针指向一个数据对象，它保存着该数据对象的__地址__，若数据对象为DataType类型，则相应的指针类型为__ DataType*__。

112.若要把一个整型指p转换为字符指针，则采用的强制转换表达式为__(char*)p __。

113. 假定一个数据对象为int*类型，则指向该对象的指针类型为__ int**__。

114. 假定p是一个指向整数对象的指针，则用__*p __表示该整数对象，用__p__表示指针变量p的地址。

115. 假定p是一个指针，则*p++运算首先访问__*p __，然后使_____p___的值增1。

116. 假定p是一个指针，则(*p)++运算首先访问__*p __，然后使__*p __的值增1。

117. 假定p所指对象的值为25，p+1所指对象的值为42，则*p++的值为____25____。

118．假定p所指对象的值为25，p+1所指对象的值为42，则*++p的值为____42____。

119. 假定p所指对象的值为25，p+1所指对象的值为42，则执行(*p)++运算后，p所指对象的值为___26_____。

120．假定p所指对象的值为25，p+1所指对象的值为42，则执行*(p++)或*p++运算后，p所指对象的值为____42____。

121．假定a是一个一维指针数组，则a+i所指对象的地址比a大___4*i __字节。

122. 假定a是一个一维数组，则a[i]的指针访问方式为__*(a+i)__。

123. 假定a是一个一维数组，则a[i]对应的存储地址（以字节为单位）为__ a+i*sizeof(a[i])__。

124. 一个数组的数组名实际上是指向该数组____第一个____元素的指针，并且在任何时候都不允许___修改__它。

125. 假定指向一维数组b[10]中元素b[4]的指针为p，则p+3所指向的元素为____ b[7]___，p-2所指向的元素为__ b[2]__。

126．若要定义整型指针p并初始指向x，则所使用的定义语句为__ int *p=x;__。

127. 若p指向x，则__*p __与x的表示是等价的。

128. 在一个二维数组int a[m][n]中，包含的一维元素a[i]的类型为_ int[n]__，访问a[i]时返回值的类型为__ int *__。

129. 假定一个二维数组为c[5][8]，则c[3]的值为二维元素___ c[3][0]__的地址，c[3]+2的值为二维元素__ c[3][2]___的地址。

130. 假定p为指向二维数组int d[4][6]的指针，则p的类型为__ int(*)[6]__。

131. 假定a是一个二维数组，则a[i][j]的指针访问方式为__*(a[i]+j)__。

132. 若要把整型变量y定义为x的引用，则所使用的定义语句为__ int y=x;__。

133. 若y是x的引用，则对y的操作就是对____x___的操作。

134. 若y是x的引用，则y和x的值____相等____，即为变量__x_的地址。

135. 执行int p=new int操作得到的一个动态分配的整型对象为__*p ___。

136. 执行int *p=new int[10]操作，使p指向动态分配的数组中下标为0的元素，该元素可表示为__ p[0]__或__*P __。

137. 执行char *p=new char(’a’)操作后，p所指向的数据对象的值为_’a’_。

138. 执行new char[m][n]操作时的返回值的类型为__ char(*)[n]__。

139. 执行__ delete p ___操作将释放由p所指向的动态分配的数据空间。

177. 假定AA是一个类，“AA* abc();”是该类中一个成员函数的原型，则在类外定义时的函数头为___ AA* AA::abc()___。

178. 成员函数的参数表在类作用域中，成

- 22 -

员函数的返回值类型__不在__类作用域中。

179. 为了避免在调用成员函数时修改对象中的任何数据成员，则应在定义该成员函数时，在函数头的后面加上_ const __关键字。

180. 若只需要通过一个成员函数读取数据成员的值，而不需要修改它，则应在函数头的后面加上__ const __关键字。

181. 若采用x.abc(y)表达式调用一个成员函数，在成员函数中使用的__*this__就代表了类外的x对象。

182. 若采用p->abc(y)表达式调用一个成员函数，在成员函数中使用的__ this __就代表了类外的p指针。

183. 内联函数的定义模块与__类定义__模块必须放在同一个文件中。

184．假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，在该函数体中（能够/不能够）___不能够__向*this或其成员赋值。

185．在一个用数组实现的队列类中，包含有两个数据成员，一个指明队首元素位置，另一个指明__队列长度___。

186. 在一个用数组实现的队列类中，包含有两个数据成员，一个指明队列长度，另一个指明__队首__元素的位置。

187. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则插入一个新元素的位置为__(first+length)MS ___。

188. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则删除一个元素后队首的位置为__(first+1)MS__。

189. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队列为空的条件为__ length==0___。

190. 在一个用数组实现的队列类中，假定数组长度为MS，队首元素位置为first，队列长度为length，则队列为满的条件为__ length==MS ___。

191. 当一个队列为空时，不能对其做__删除___元素的操作。

192. 当一个队列为满时，不能对其做___插入__元素的操作。

193．从一个队列中删除元素就是删除__队首

__位置上的元素。

194．向一个队列中插入元素就是把该元素放到__队尾__元素的后一位置上。

195．在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，当链队非空时，__ ElemHead->next __指向队首结点的后继（即下一个）结点。

196. 在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，当链队非空时，新插入结点的地址应当赋给__ ElemTail ___所指结点的next域。

197. 在一个用链表实现的队列类中，队尾结点的指针域的值为__ NULL ___。

198. 在一个用链表实现的队列类中，若链队中只含有一个结点，则队首指针的值与队尾指针的值__相同__。

199. 在一个用链表实现的队列类中，若链队为空或只含有一个结点，则队首指针的值与队尾指针的值__相同___。

200. 在一个用链表实现的队列类中，若队首指针与队尾指针的值不同，则说明链队中至少包含有__2__个结点。

201．一个类的__构造__函数实现对该类对象的初始化功能。

202．一个类的___析构__函数通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。

203．当用户为一个类定义有___构造函数___时，则系统不会为该类再自动生成一个默认构造函数。

204．假定用户没有给一个名为AB的类定义构造函数，则系统为其定义的构造函数为__ AB() {}__。

205．假定用户没有给一个名为AB的类定义析构函数，则系统为其定义的析构函数为___~AB() {}__。

206．定义类动态对象数组时，其元素只能靠自动调用该类的__无参构造函数__来进行初始化。

207．在一个类中定义拷贝构造函数的目的，是为了当利用该类的一个对象初始化另一个对象时，能够避免这两个对象的同一指针同时指向同

- 23 -

一块__动态存储空间__。

208．为了释放类对象中指针成员所指向的动态存储空间，则需要为该类定义__析构函数__。

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

210．假定一个类对象数组为A[N]，当离开它的作用域时，系统自动调用该类析构函数的次数为__N___。

211．对类中对象成员的初始化是通过在构造函数中给出的___初始化表___来实现的。

213．对类中引用成员的初始化只能通过在构造函数中给出的__初始化表___来实现。

214．对类中一般数据成员的初始化既可以通过在构造函数中给出的初始化表来实现，也可以通过构造函数中的_函数体___来实现。

215. 假定要把aa定义为AB类中的一个常量整数型数据成员，则定义语句为__ const int aa;__。

216. 假定要把aa定义为AB类中的一个引用整数型数据成员，则定义语句为__ int aa;__。

217. 假定AB类中只包含一个整型数据成员a，并且它是一个常量成员，若利用参数aa对其进行初始化，则该类的构造函数的定义为___ AB(int aa):a(aa){};___。

218. 假定AB类中只包含一个整型数据成员a，并且它是一个引用成员，若利用引用参数aa对其进行初始化，则该类的构造函数的定义为__ AB(int aa):a(aa){};___。

219．假定指针p指向一个动态分配的类对象，则当执行“delete p;”语句时，在释放p所指向的动态存储空间之前将自动调用该类的__析构函数__。

220．假定用户为类AB定义了一个构造函数“AB(int aa) {a=aa;}”，则系统 __不会__为该类自动定义一个无参构造函数\{}\。

221. 假定用户为类AB定义了一个构造函数

“AB(int aa, char *bb=NULL):a(aa),b(bb){}”，则该类中至少包含有__2__个数据成员。

222．假定用户为类AB定义了一个构造函数“AB(int aa) {a=aa;}”，该构造函数实现对数据成员__a__的初始化。

223．假定用户为类AB定义了一个构造函数“AB(int aa=0):a(aa){}”，则定义该类的对象

时，可以有___2__种不同的定义格式。

224．假定用户为类AB定义了一个构造函数“AB(int aa):a(aa){}”，则定义该类的对象时，有__1_种定义格式。

225．假定用户只为类AB定义了一个构造函数

“AB(int aa, int bb=0) {a=aa; b=bb;}”，则定义该类的对象时，其实参表中至多带有__2__个实参。

226．假定用户只为类AB定义了一个构造函数

“AB(int aa, int bb=0) {a=aa; b=bb;}”，则定义该类的对象时，其实参表中至少带有__1__个实参。

227．假定用户为类AB定义了一个构造函数“AB(int aa=0, int bb=0) {a=aa; b=bb;}”，则定义该类的对象时，可以有_3___种不同的定义格式。

228．假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则定义该类对象x的定义语句“AB x();”是__错误__的。

229．假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则定义该类对象x的定义语句“AB x;”是_正确___的。

230．假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则定义该类对象x的定义语句“AB x(5);”是__/错误_(正确/错误)的。

231．假定AB为一个类，则类定义体中的“AB(AB x);”语句为该类__拷贝构造函数__的原型语句。

232．假定AB为一个类，则该类的拷贝构造函数的函数头为__ AB(AB)__。

233．假定AB为一个类，该类中含有一个指向动态数组空间的指针成员pa，则在该类的析构函数中应该包含有一条__ delete []pa;__语句。

234.静态成员函数__只能_访问类的静态数据成员，__不能__访问类的非静态数据成员。

235. 静态数据成员必须在所有函数的定义体外进行__初始化__。

236. 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明必须在函数名前加上__类域__的限定。

237. 重载运算符时，该运算符的__优先级__、结合性以及操作符的个数不允许改变。

- 24 -

238. 一个单目运算符作为类的成员函数重载时有__0__个参数；如果作为独立函数重载，则有__1__个参数。

239. 一个双单目运算符作为类的成员函数重载时有___1_个参数；如果作为独立函数重载，则有__2__个参数。

240. 除了__赋值__运算符外，其他重载的运算符都可以被派生类继承。

241. 作为类的成员函数重载一个运算符时，参数表中只有一个参数，说明该运算符有__2__个操作数。

242. 在重载一个单目运算符时，参数表中没有参数，说明该运算符函数只能是类的__成员函数__。

243. 重载插入运算符<<时，其运算符函数的返回值类型应当是__ ostream __。

244. 重载抽取运算符>>时，其运算符函数的返回值类型应当是__ istream __。

245. 重载插入运算符<<或抽取运算符>>时，其运算符函数的参数有__2___个。

246. 重载插入运算符<<或抽取运算符>>时，其运算符函数不能被定义为类的__成员__函数。

247. 类型转换函数没有___返回值___类型，而且参数表为__空___。

248. 在一个或若干个类的基础上构造一个新类，被称为___继承___。

249. 派生类的成员函数可以直接访问基类的___公有和保护__成员，不能直接访问基类的 ___私有__成员。

250. 当保护继承时，基类的___公有和保护___成员在派生类中成为保护成员，派生类对象不能直接访问基类的__任何___成员。

251. 在定义一个派生类时，使用__ private __关键字或者不显式地使用它则表示为___私有__继承。

252. 若多个基类及其派生类中都定义了同名函数成员，要访问相应函数时，就需要在函数名前加上__类名__和类区分符。

253. 若要保证一个公共的基类在派生类中只产生一个基类子对象，则必须都以___虚基类___的方式直接继承它。

254. 引进虚基类的根本目的是为了消除___二义性___。

255. 在每个成员函数中，隐含的第一个参数的参数名为__ this __。

四、程序填充

1. 斐波那契数列的第1和第2个数分别为0和1 ，从第三个数开始，每个数等于其前两个数之和。求斐波那契数列中的前20个数，要求每行输出5个数。

#include void main() {

int f,f1,f2,i;

cout<<” 斐波那契数列：\\n”; f1=0; f2=1;

cout<

cout<

if(_____(2)______) cout<

f2=____(3)_______;

}

cout<

(1) f1+f2 (2) i%5==0 (3) f

2. 计算?(?1)i?110i?1xi的值。 i! #include void main() {

double x,p1=1,p2=1,s=0; int i,j=1;

cout<<\输入x的值:\ cin>>x;

for(i=1;i<=10;i++) { p1*=___(1)_____; p2*=____(2)____;

s+=j*p1/p2; //j的值为

i+1

(-1)

j=____(3)____; }

cout<

(1) x (2) i (3) -j

- 25 -

3. 打印出2至99之间的所有素数(即不能被任何数整除的数)。

#include #include void main() {

int i,n;

for(n=2; ___(1)___; n++) { int temp=int(sqrt(n)); //求出n的平方根并取整

for(i=2; ___(2)___; i++) if(n%i==0) ___(3)___; if(i>temp) cout<

cout<<'\\n'; }

(1) n<=99 (2) i<=temp (3) break

4. 采用辗转相除法求出两个整数的最大公约数。

#include void main() {

int a,b;

cout<<\请输入两个正整数:\ cin>>a>>b; while(a<=0 || __(1)___) {cout<<\重新输入:\ while(b) { int r; r=a%b;

___(2)___; ___(3)___; //分别修改a和b的值 }

cout<

}

(1) b<=0 (2) a=b (3) b=r

5. 把从键盘上输入的一个大于等于3的整数分解为质因子的乘积。如输入24时得到的输出结果为“2 2 2 3”，输入50时得到的输出结果为

“2 5 5”，输入37时得到的输出结果为“37”。

#include void main() {

int x;

cout<<\请输入一个整数，若小于3则重输:\

do cin>>x; while(___(1)___); int i=2; do{

while(___(2)___) { cout<

___(3)___; }while(i

if(x!=1) cout<

(1) x<3 (或x<=2) (2) x%i==0 (3) i++

6. 下面函数是求两个整型参数a和b的最小公倍数。

int f2(int a, int b) {

int i=2, p=1; do {

while(a%i==0 && ___(1)___) { p*=i; a/=i; b/=i; }

___(2)___;

}while(a>=i && ___(3)___); return p*a*b; }

(1) b%i==0 (2) i++ (或++i) (3) b>=i

7. 在输出屏幕上打印出一个由字符’*’组成的等腰三角形，该三角形的高为5行，从上到下每行的字符数依次为1,3,5,7,9。 #include void main() {

int i,j;

for(i=1;___(1)___;i++) {

- 26 -

for(j=1;j<=9;j++)

if(j<=5-i || ___(2)___) cout<<’ ’;

else ___(3)___; cout<

(1) i<=5 (2) j>=5+I (3) cout<<’*’

8. 统计字符串中英文字母个数的程序。 #include int count (char str[]); void main(){ char s1[80];

cout <<”Enter a line:”; cin >>s1; cout

<<”count=”<

int count(char str[]){

int num=0; //给统计变量赋初值 for(int i=0;str[i];i++)

if (str[i]>=’a’ && str[i]<=’z’ ||___(1)___ )

___(2)___; ___(3)___; }

(1) str[i]>=’A ’&& str[i]<=’Z’

(2) num++ (3) return num

9. 主函数调用一个fun函数将字符串逆序。

#include #include

___(1)___; void main( ) { char s[80]; cin>>s; ___(2)___;

cout<<”逆序后的字符串:”<

}

void fun(char ss[]) { int n=strlen(ss);

for(int i=0; ___(3)____; i++) {

char c=ss[i];

ss[i]=ss[n–1–i]; ss[n–1–i]=c; } }

(1) void fun(char ss[]) (2) fun(s) (3) i

10. 从一个字符串中删除所有同一个给定字符后得到一个新字符串并输出。 #include const int len=20;

void delstr(char a[],char b[],char c);

void main() {

char str1[len],str2[len]; char ch;

cout<<\输入一个字符串:\ cin>>str1;

cout<<\输入一个待删除的字符:\ cin>>ch;

delstr(str1,str2,ch); cout<

int j=0;

for(int i=0; ___(1)___; i++) if(___(2)___) b[j++]=a[i]; b[j]=___(2)___; } (1) a[i] (或a[i]!=’\\0’) (2) a[i]!=c (3) '\\0'

11. 采用指针访问方式从键盘给数组a[N]输入数据，然后对元素值重新按逆序存放并输出。 #include const int N=8; void main() {

int a[N],*p,*q;

for(p=a; p

int r=*p; *p=*q; *q=r;

- 27 -

___(2)___; ___(3)___; }

for(p=a;p

(1) cin>>*p (2) p++ (或++p) (3) q-- (或--q)

12. 从键盘上输入一个正整数，然后把它转换成的二进制数的每一位存放到一维数组中，最后输出该二进制数。注意二进制数的存放是按照从低位到高位的次序进行的。 #include void main() {

int x;

cout<<\输入一个整数:\ cin>>x;

int a[20],k=0,r; do {

r=x%2; a[k++]=r; x=___(1)___; } while(___(2)___);

for(--k;k>=0;k--) ___(3)___; cout<

(1) x/2 (2) x!=0 (3) cout<

13. 对数组a[n]按升序进行的选择排序算法

void SelectSort(int a[], ___(1)___) {

int i,j,k;

for(i=1;i

k=i-1;

for(j=i;j int x=a[i-1]; a[i-1]=a[k]; ___(3)___; } }

(1) int n (2) k=j (3) a[k]=x

14. 对数组a[n]按升序进行的插入排序算法

void InsertSort(___(1)___, int n) {

int i,j,x;

for(i=1;i

x=a[i];

for(j=i-1;j>=0;j--) //为x顺序向前寻找合适的插入位置

if(x

(1) int a[] (或int* a)

(2) a[j+1]=a[j] (3) break

15. 对按从小到大排列的有序数组a[n]进行二分查找x的算法，若查找成功返回该元素下标，否则返回-1。

int BinarySearch(int a[],int x) {

int low=0, high=N-1; //定义并初始化区间下界和上界变量

int mid; //定义保存中点元素下标的变量

while(low<=high) { mid=___(1)___;

if(x==a[mid]) ___(2)___; else if(x

else ___(3)___; }

return -1; }

(1) (low+high)/2 (2) return mid (3) low=mid+1

16. 用插入排序方法对table指针数组中

- 28 -

size个指针所指向的字符串进行按升序排序的算法。

void sort(char *table[], int size){ for(int i=1,___(1)___; i++){ char *p=table[i];

for(int j=i-1; j>=0 ; j--) if(strcmp(p,table[j])<0) ___(2)___;

else break;

table[j+1]=___(3)___; } }

(1) i

17. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法根据table数组中的n个元素建立一个表头指针为L的链表，链表中结点值的顺序与数组元素值的顺序相同。 void f5(NODE*& L, int table[], int n) {

if(n<=0) {L=NULL; return;}

L=new NODE; //生成附加的头结点 int i=0; NODE* p=L;

while(___(1)___) {

p=p->next=___(2)___; p->data=___(3)___; i++; }

p->next=NULL; //把最后一个结点的指针域置空 p=L;

L=L->next; //使L指向链表的第一个带值的结点

delete p; }

(1) i

18. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法根据table数组中的n个元素建立一个表头指针为L的链表，链表中结点值的顺序与数组元素值的顺序正好相反。

void f6(NODE*& L, int table[], int n) {

L=NULL;

if(n<=0) return; int i=0; NODE* p;

while(___(1)___) { p=new NODE;

p->data=___(2)___; p->next=L; ___(3)___; i++; } }

(1) i

19. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法是依次显示输出以L为表头指针的链表中各结点的值。 void f7(NODE* L) {

for(___(1)___; p!=NULL; ___(2)___) cout<<___(3)___ <<' '; cout<

(1) NODE* p=L (2) p=p->next (3) p->data 20. 假定有定义为“struct NODE{int data; NODE* next;};”，下面算法是把以L为表头指针的链表中各结点依次按相反次序链接并返回新链表的表头指针。 NODE* f8(NODE* L) {

if(L==NULL) return NULL; NODE *p=NULL, *q=L, *t; while(q!=NULL) { t=q;

q=___(1)___;

t->next=___(2)___; p=t; }

___(3)___; }

- 29 -

(1) q->next (2) p (3) return p

21. 已知一维数组类ARRAY的定义如下，ARRAY与普通一维数组区别是：其重载的运算符[ ]要对下标是否越界进行检查。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator[](int n); };

___(1)___ operator[](int n) //[ ]的运算符成员函数定义 {

if(n<0 || ___(2)___) {cerr<<\下标越界！\

return ___(3)___; } (1) int& ARRAY:: (2) n>=s (3) v[n] (或*(v+n))

22. 已知一维数组类ARRAY的定义如下，构造函数的作用是把参数n的值赋给s，给v动态分配长度为n的数组空间，接着利用数组参数a初始化v所指向的数组。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator[](int n); };

___(1)___ ARRAY(int a[], int n) {

if(n<=0) {v=NULL;s=0;return;} s=n;

v=___(2)___;

for(int i=0; i

(1) ARRAY:: (2) new int[n] (3) v[i]=a[i]

23. 下面是一维数组类ARRAY的定义，ARRAY与普通一维数组区别是：(a)用()而不是[]进行下标访问，(2)下标从1而不是从0开始，(c)要对下标是否越界进行检查。 class ARRAY{

int *v; //指向存放数组数据的空间 int s; //数组大小 public:

ARRAY(int a[], int n); ~ ARRAY(){delete []v;} int size(){ return s;} int& operator()(int n); }; ___(1)___ operator()(int n) { // ()的运算符函数定义

if(___(2)___) {cerr<<\下标越界！\exit(1);}

return ___(3)___; }

(1) int& ARRAY:: (2) n<1 || n>s (3) v[n-1] (或*(v+n-1))

24. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a，

//用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素

//进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序

void PrintA(); //依次输出数组a中的前n个元素 };

该类中MaxA()函数的实现如下，请在标号位

- 30 -

置补充适当的内容。 int ____(1)_____ {

int x=a[0];

for(int i=1; ix) ___(2)___; ___(3)___; }

(1) AA::MaxA() (2) x=a[i] (3) return x

25. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a，

//用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素

//进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序

void PrintA(); //依次输出数组a中的前n个元素 };

void AA::SortA() {

int i,j;

for(i=0; ___(1)___; i++) { int x=a[i], k=i; for(j=i+1; j

(1) i

26. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a，

//用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素

//进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序

void PrintA(); //依次输出数组a中的前n个元素 };

void ___(1)___ {

int i,j;

for(i=1; i

for(j=i-1; j>=0; j--) if(x

(1) AA::InsertA() (2) a[j+1]=a[j] (3) break

27. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a，

//用nn初始化数据成员n

- 31 -

int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素

//进行从小到大排序

void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序

void PrintA(); //依次输出数组a中的前n个元素

//最后输出一个换行 };

使用该类的主函数如下： void main() {

int

a[10]={23,78,46,55,62,76,90,25,38,42}; AA x; ___(1)___;

int m=___(2)___; ___(3)___; cout<

该程序运行结果为: 23 78 46 55 62 76 78

(1) x.SetA(a,6) (2) x.MaxA() (3) x.PrintA()

28. 已知一个类的定义如下： #include class AA { int a[10]; int n; public:

void SetA(int aa[], int nn); //用数组aa初始化数据成员a，

//用nn初始化数据成员n int MaxA(); //从数组a中前n个元素中查找最大值

void SortA(); //采用选择排序的方法对数组a中前n个元素

//进行从小到大排序

void PrintA(); //依次输出数组a中的前n个元素，

//最后输出一个换行 };

使用该类的主函数如下： void main() {

int

a[10]={23,78,46,55,62,76,90,25,38,42}; ___(1)___; x.SetA(a,8); int ___(2)___; ___(3)___; x.PrintA(); cout<

该程序运行结果为: 23 25 46 55 62 76 78 90 90

(1) AA x (2) m=x.MaxA() (3) x.SortA()

29. 已知一个利用数组实现栈的类定义如下：

const int ARRAY_SIZE=10; class Stack { public:

void Init() {top=-1;} //初始化栈为空

void Push(int newElem); //向栈中压入一个元素

int Pop(); //从栈顶弹出一个元素

bool Empty() { //判栈空

if(top==-1) return true;else return false;}

int Depth() {return top+1;} //返回栈的深度

void Print();

//按照后进先出原则依次输出栈中每个元素，直到栈空为止 private:

int elem[ARRAY_SIZE]; //用于保存栈元素的数组

int top; //指明栈顶元素

- 32 -

位置的指针 };

void Stack::Push(int newElem) { if(___(1)___) {

cout<<\栈满!\ exit(1); //中止运行 }

___(2)___;

elem[top]=___(3)___; }

(1) top==ARRAY_SIZE-1 (2) top++（或++top） (3) newElem

30. 已知一个利用数组实现栈的类定义如下：

const int ARRAY_SIZE=10; class Stack { public:

void Init() {top=-1;} //初始化栈为空

void Push(int newElem); //向栈中压入一个元素

int Pop(); //从栈顶弹出一个元素

bool Empty() { //判栈空

if(top==-1) return true;else return false;}

int Depth() {return top+1;} //返回栈的深度

void Print();

//按照后进先出原则依次输出栈中每个元素，直到栈空为止 private:

int elem[ARRAY_SIZE]; //用于保存堆栈元素的数组

int top; //指明栈顶元素位置的指针 };

该类的Pop和Print函数的实现分别如下： ___(1)___ {

if(top==-1) {

cout<<\栈空!\ exit(1); //中止运行

}

return ___(2)___; }

void Stack::Print() { while(!Empty())

cout<<___(3)___ <<' '; }

(1) int Stack::Pop() (2) elem[top--]

(3) Pop()

31．class A { int a; public:

A() {a=0;}

___(1)___{} //定义构造函数，用参数aa初始化数据成员a };

main() {

___(2)___; //定义类A的指针对象p ___(3)__; //用p指向动态对象并初始化为整数5 }

(1) A(int aa):a(aa) (2) A *p

(3) p=new A(5)

32．class A { char *a; public:

___(1)___ //定义无参构造函数，使a的值为空

A(char *aa) { a=___(2)___;

strcpy(a,aa); //用aa所指字符串初始化a所指向的动态存储空间 }

___(3)___ //定义析构函数，删除a所指向的动态存储空间 };

(1) A() {a=0;} 或A():a(0){}

(2) new char[strlen(aa)+1] (3) ~A() {delete []a;} 33．class A {

- 33 -

int a,b; public:

A(int aa=0, int bb=0) ___(1)___ {} //分别用aa和bb对应初始化a和b };

main() {

___(2)___ ; //定义类A的对象x并用5初始化，同时定义y并用x初始化

___(3)___ ; //定义p指针，使之指向对象x

}

(1) :a(aa),b(bb) (2) A x(5),y(x) (3) A *p=&x

34．class A { int a,b; public:

___(1)___ //定义构造函数，使参数aa和bb的默认值为0，

//在函数体中用aa初始化a，用bb初始化b };

main() {

A *p1, *p2;

___(2)___ ; //调用无参构造函数生成由p1指向的动态对象

___(3)___ ; //调用带参构造函数生成由p2指向的动态对象，

//使a和b成员分别被初始化为4和5

}

(1) A(int aa=0, int bb=0){a=aa; b=bb;} (2) p1=new A

(3) p2= new A(4,5) 35. #include #include class A {

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1);

___(1)___; //由a指向长度为MaxLen

的动态数组

for(int i=0; i

~A() {delete []a;}

int GetValue(int i) ___(2)___ //函数体返回a[i]的值 };

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10); int i,s=0;

for(i=0; i<10; i++); ___(3)___ //把r对象的a数据成员中的每个

//元素值依次累加到s中

cout<<\ }

(1) a=new int[MaxLen]

(b) {return a[i];} (c) s+=r.GetValue(i)

36. #include #include class A {

int *a; int n; int MaxLen; public:

A(): a(0), n(0), MaxLen(0) {} A(int *aa, int nn, int MM) { n=nn;

MaxLen=MM;

if(n>MaxLen) exit(1); a=new int[MaxLen];

___(1)___; //以i为循环变量把aa数组中每个元素值

//传送给a数组的对应元素中

} ~A();

int GetValue(int i) {return a[i];} //函数体返回a[i]的值

};

___(2)___ //析构函数的类外定义

- 34 -

void main() {

int b[10]={1,2,3,4,5,6,7,8,9,10}; A r(b,10,10); int i,s=0;

___(3)___ ; //以i为循环变量，把r对象的a数据成员中的

//每个元素值依次累加到s中

cout<<\ }

(1) for(int i=0; i

37. 一种类定义如下: class Goods {

private:

char gd_name[20]; //商品名称 int weight; //商品重量 static int totalweight; //同类商品总重量 public:

Goods (char*str,int w){ //构造函数 strcpy(gd_name,str); weight=w;

totalweight+=weight; }

~ Goods (){totalweight -= weight;} char* GetN(){___(1)___;} //返回商品名称

int GetW(){return weight;}

___(2)___ GetTotal_Weight() { //定义静态成员函数返回总重量

___(3)___; } }

(1) return gd_name (2) static int (3) return totalweight 38. class Point {

private: int x, y; public:

Point(){x=y=0;}

Point(int x0,int y0) {x=x0;y=y0;} int GetX() { return x; } int GetY() { return y; } void

Print(){cout<<\dl;}

___(1)___; //友元函数声明 ___(2)___; //友元函数声明 };

Point operator+(Point& pt,int dd)

//加号操作符重载函数，实现Point类对象与整数加法 {

Point temp=pt; temp.x+=dd; temp.y+=dd; return temp; }

Point operator+(Point& pt1,Point& pt2) //加号操作符重载函数，实现两个Point类对象的加法 {

Point temp=pt1; temp.x+=pt2.x; ___(3)___; return temp; }

(1) friend Point operator+(Point& pt,int dd)

(2) friend Point operator+(Point& pt1,Point& pt2)

(3) temp.y+=pt2.y

39. 在下面一段类定义中， Derived类是由直接基类Base 1和Base 2所派生的，Derived类包含有两个间接基类BaseBase，在初始化函数Init中，需要把x1和x2的值分别赋给属于基类Base1的x成员和属于基类Base2的x成员。 class BaseBase { protected:

- 35 -

int x; public:

BaseBase(){ x = 1;} };

class Base1: public BaseBase { public: Base1(){} };

class Base2: public BaseBase { public: Base2(){} };

class Derived: ___(1)___ {

public:

Derived() {}

void Init(int x1, int x2) { ___(2)___; ___(3)___; }

void output() {cout<

(1) public Base1, public Base2

(2) Base1::x=x1 (3) Base2::x=x2

40. 在下面一段类定义中， Derived类公有继承了基类Base。需要填充的函数由注释内容给出了功能。 class Base {

private:

int mem1,mem2; //基类的数据成员 public:

Base(int m1,int m2) { mem1=m1; mem2=m2; } void output(){cout<

class Derived: public Base {

private:

int mem3; //派生类本身的数据成员

public:

//构造函数,由m1和m2分别初始化mem1和mem2，由m3初始化mem3

Derived(int m1,int m2, int m3); //输出mem1,mem2和mem3数据成员的值 void output(){

___(1)___; cout<

Derived::Derived(int m1,int m2, int m3): ___(2)___ {___(3)___;}

(1) Base::output() (2) Base(m1,m2) (3) mem3=m3

41. 在下面一段类的定义中，需要填充的函数由注释内容给出了功能。 class Point //定义坐标点类 {

public:

int x,y; //点的横坐标和纵坐标 Point(){x=0;y=0;}

Point(int x0,int y0) {x=x0; y=y0;} int X(){return x;} int Y(){return y;} void

PrintP(){cout<<\endl;} };

class Line: public Point //利用坐标点类定义直线类 {

private:

class Point pt1,pt2; //直线的两个端点 public:

Line(Point pts, Point pte); //构造函数，分别用参数初始化对应的端点

double Dx(){return pt2.x-pt1.x;} double Dy(){return pt2.y-pt1.y;}

- 36 -

double Length(){ //计算直线的长度 return sqrt(___(1)___); };

void PrintL(); //输出直线的两个端点和直线长度 };

Line::Line(Point pts, Point pte) ___(2)___ void Line::PrintL() {

cout<<\ pt1.PrintP(); cout<<\ pt2.PrintP();

cout<<\Length of Line: \<

(1) Dx()*Dx()+Dy()*Dy()

(2) {pt1=pts;pt2=pte;} (或 :pt1(pts),pt2(pte){})

(3) Length()

42. 在下面一段类的定义中，自行车类的虚基类为车辆类，机动车类的虚基类也为车辆类，摩托车类的基类为自行车类和机动车类，类之间均为公有继承。

class vehicle //车辆类 {

private:

int MaxSpeed; //最大车速 int Weight; //车重 public:

vehicle(){MaxSpeed=0; Weight=0;};

virtual void Run() {cout<<\running!\};

class bicycle : ___(1)___ //自行车类 {

private:

int Height; //车高 public:

bicycle(){};

void Run() {cout<<\bicycle is running!\};

class motorcar : ___(2)___ //机动车类 {

private:

int SeatNum; //乘人数 public:

motorcar(){};

void Run() {cout << \motorcar is running!\};

class motorcycle: ___(3)___ //摩托车类 {

public:

motorcycle (){};

void Run() {cout<<\motorcycle is running!\};

(1) virtual public vehicle

(2) virtual public vehicle

(3) public bicycle, public motorcar

五、读程序写出运行结果

1. #include #include void main() {

int

a[8]={25,48,32,85,64,18,48,29}; int max,min; max=min=a[0];

for(int i=0; i<8; i++) { if(x>a[i]) max=a[i]; if(x

cout<<\ cout<<\ }

max:85 min:18

2. #include void main() {

- 37 -

int a,b;

for(a=1,b=2; b<50;) { cout<

cout<

cout<

1 2 3 5 8 13 21 34 55 89

3. #include const int M=3, N=4; void main() {

int i,j,s=0;

for(i=1;i<=M;i++) for(j=1;j<=N;j++) s+=i*j;

cout<<”s=”<

4. #include void main() {

int a=2,b=5,c=0;

if(a+b>10) c=a*b; else c=3*a+b; if(c<=20) cout<

cout<

a=a+b; b=a+b;c+=a+b;

cout<<\ } 121

a,b,c=7,12,30

5. #include void main() {

int x=5;

switch(2*x-3) {

case 4: cout<

break;

default: cout<<\ }

cout<<\ }

11 14 switch end.

6. #include #include

int a[4]={36,-5,73,8}; void main() {

int i,y;

for(i=0; i<4; i++) { if(a[i]<0) y=1;

else if(a[i]<10) y= a[i]* a[i]+3;

else if(a[i]<60) y=4*a[i]-5; else y=int(sqrt(a[i])); // sqrt(x)为取x的平方根函数

cout<36 139 -5 1 73 8 8 67

7. #include

int a[8]={36,25,20,43,12,70,66,35}; void main() {

int s0,s1,s2; s0=s1=s2=0;

for(int i=0; i<8; i++) { switch(a[i]%3) {

case 0: s0+=a[i];break; case 1: s1+=a[i];break; case 2: s2+=a[i];break; } }

cout<

8. #include

- 38 -

const int N=5; void main() {

int i,p=1,s=0;

for(i=1;i

cout<

cout<

2 2 3 3 6 9 4 24 33

9. #include const int M=20; void main() {

int c2,c3,c5; c2=c3=c5=0;

for(int i=1; i<=M; i++) { if(i%2==0) c2++; if(i%3==0) c3++; if(i%5==0) c5++; }

cout<

10. #include void main() {

int i,j;

for(i=0;i<5;i++) { for(j=i;j<5;j++) cout<<’*’;

cout<

*****

**** ***

** *

11. #include void main() {

for(int i=1,s=0;i<20;i++) { if(i%2==0 || i%3==0) continue;

cout<

cout<

1 5 7 11 13 37

12. #include const int T=6; void main() {

int i,j;

for(i=1;i<=T;i+=2)

for(j=2;j<=T;j+=2) {

if(i+j

13. #include void main() {

int a,b,c=0; for(a=1;a<4;a++)

for(b=6;b>1;b-=2) {

if((a+b)%2==0) c+=a+b; else c+=a*b;

if(b==2)

cout<

1 2 12

2 2 30 3 2 66

14. #include

- 39 -

const int B=2; void main() {

int p=1,s=1; while(s<50) { p*=B; s+=p; }

cout<<\ } s=63

15. #include void main() {

int x=24,y=88; int i=2,p=1; do {

while(x%i==0 && y%i==0) { p*=i; x/=i; y/=i; } i++;

}while(x>=i && y>=i); cout<

- 40 -

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