2025年面向对象编程全方位攻略考前复习资料

面向对象程序设计总复习(夏)

复习之一、对照书本(或上课课件)上，搞懂有关概念

【第0・1章】

1.面向对象程序设计是不一样于老式程序设计的一种新的程序设计范型。它对减少软件的复杂性，

改善其重用性和维护性，提高软件的生产效率，有着十分重要的意义。因此面向对象的程序设计被认

为是程序设计措施学的一场实质怦的革命(在导学中)C

2.面向对象(O・O)程序设计是一种新的程序设计范型。这种范型的重要特性是：

程序:对象+消息

面向对象程序的重要构造特点是：

第一，程序一般由类的定义和类的使用两部分构成：

第二，程序中的一切操作都是通过向对象发送消息来实现的，对象接受到后，启动有关措施完毕对

应操作。

3.现实世界中，对象一般可以表达为：属性+行为

现实世界中的对象，具有如下特性：

(1)每一种必须有一种名字以区别于其他对象；

(2)用属性来描述对象的某些特性；

(3)有一组操作，每组操作决定对象的一种行为；

(4)对象的行为可以分为两类：一类是作用于自身的行为，另一类是作用于其他对象的行为。

4.在现实世界中，类是一组具有相似属性和行为的对象的抽象。

类与对象的关系是抽象和详细的关系。

在C++面向对象的程序设计中，把类中的属性称为数据(数据组员)，类中的操作是用函数

(函数组员)来实现的。

5.面向对象程序设计的基本特性：抽象性、封装性、继承性和多态性

(1).抽象是通过特定的实例(对象)抽取共同性质后形成概念的过程。

(2).在面向对象程序设计中，封装是指把数据和实现操作的代码集中起来放在对象内部，并尽量

隐蔽对象的内部细节。

(3),继承机制容许派生类继承基类的数据和操作(即数据组员和组员函数)，也就是说，容许派生

类使用基类的数据和操作。同步派生类还可以增长新的操作和数据。

从继承源上分，维承分为单继承和多继承。

(4),面向对象系统的多态性是指不一样的对象收到相似的消息时产生多种不一样的行为方式。如

可以有同名函数

【第2章】

6,简朴的C++程序

例2.1计算两个整数之和sum.cpp

#include<iostream>//系统头文献1J-~4独山"~~"

卜这两行也可用一仃替代：#includeviostream.h>

usingnamespacestd;------------------------------------------------------

intmain()//主函数

{intx,v，sum;//定义三个整型变量

coutcv”输入二个数:"vv'n://界面:提醒顾客输入二个数

cin>>x;//从键盘输入变量x的值

cin>>y;//从键盘输入变量y的值

sum=x+y;

cout<<''x+y=,,<<sum<<'\n,;〃输出

return0;

}

C++新行（回车换行）'\nr或endl（ENDL的小写）

新的输入/输出：

老：scanf

新：cin是原则输入流，在程序中用于代表原则输入设备，即键盘，运算符表达向右

老：printf

新：cout是原则输出流，在程序中用于代表原则输出设备，即屏幕。运算符、、vv〃表达向左

使用cin或cout进行I/O操作时，在程序头中头文献#include<iostream.h>

7.函数原型（函数申明）（重点）

返回值类型函数名（参数表）；

例2・7

Intadd（inta,Intb）;

intadd（intzint）;

使用在前，定义在后，要先申明。

若定义在前，使用在后，就可不必申明。

8.函数重载：C++中，只要函数的蓼数的类型不一样，或者篓数个数不一样，或者二兼有之，几

种函数可以用相似的函数名。称为函数重载

9.C语言用函数malloc。和free。动态分派内存和释放动态分派的内存。C++使用运算符new

和delete能更好、更简朴地进行内存的分派和释放。

10.引用（重点）

引用可为变量起别名，它重要用作函数参数以及函数的返回类型。引用有三种：（工）有变量的引用、

（2）参数引用和（3）返回值引用。

11.1、&取地址运算符取西瓜皮

2、*指针运算符（间接访问运算符）挖西瓜爆

【第3章】

12.C++中阐明（类的定义）类的一般形式为

clsaa类名{

[private:]（可省略）

私有段数据组员和组员函数

protected:

保护段数据组员和组员函数

public:

公有段数据组员和组员函数

?；

组员函数的定义方式：

第一种方式是在类定义中只给出组员函数的原形，而组员函数体在类的外部定义。

第二种方式是将组员函数定义在类的内部，即定义为内置函数。

(1)隐式定义

(2)显式定义

13.类对象中组员的引用(使用、访问都是同一种意思)不管是数据组员，还是组员函数，只要是

公有的，就可以被外部函数直接引用，引用的一般格式是：

对象名.数据组员名和对象名.组员函数名(实参表)

外部函数不能引用对象的私有组员

总之：类组员的访问属性：

类的公有组员不仅可以被类中组员函数访问，还可以在类的外部通过类的对象进行访问。类的私有

组员只能被类中组员函数访问，不能在类的外部通过类的对象进行访问。

14.构造函数的特点：

(1)构造函数的名字必须与类名相似，否则编译程序将把它当作一般的组员函数来处理。

(2)构造函数没有返回值，在申明和定义构造函数时，是不能阐明它的类型的的，甚至阐明为void

类型也不行。

(3)构造函数也是组员函数，与一般的组员函数同样，构造函数的函数体可写在类体内，也可写

在类体外。

(4)一般不倡导在构造函数中加入与初始化无关的内容

(5)构造函数一般申明为公有组员。它不需要顾客来调用，而是在建立对象时自动执行的。

(6)在实际应用中，一般需要给每个类定义构造函数。假如没有给类定义构造函数，则编译系统

自动地生成一种缺省的构造函数。

complex::complex()<}//不能带任何参数。

(7)定义构造函数时，也可以是不带参数的。

15.C++容许重载构造函数，这些构造函数之间名字相似，而以它们所带参数的个类或类型的不

一样而辨别。带默认参数的构造函数。

16.对象的赋值和拷贝构造函数，其作用是，在建立新对象时，使用一种已经存在的对象去初始化

这个新对象。piontp2(pl);

17.析构函数也是特殊组员函数，用于释放对象。

(1)析构函数与构造函数名字相似，但它前面必须加一种波浪号(~)。

(2)析构函数没有参数，也没有返回值，并且不能重载，因此在一种类中只能有一种析构函数。

(3)当撤销对象时，编译系统会自动地调用析构函数。

18.可以用类定义对象数组：

类名数组名［元素个数］;

19.当需要时，可以用类定义对象指针。对象指针就是用于寄存对象地址的变量

类名*对象指针名；

20.类的封装性，使类只能通过组员函数来访问私有组员.这是好事但也有一定的限制太死的感觉.

能否开个小孔口，必要时作个破例，使外界函数、别的类的个别组员函数、甚致别的类的所有组员

函数可访问某个类的私有组员。这个措施称为友元。

21.友元包括友元函数和友元类

(1)友元函数分为：非组员函数作友元和别的类的组员函数作友元

(2)友元类：在类定义时，在类内阐明一种类(该类前面己定义)，前加上friend表达该整个的

一种类是本类的友元类。友元类的所有组员函数可以访问它自己类私有组员又可本类的私有组员。

【第4章】

22.派生类的定义

基类：

class基类名

<

类的内容

?；

申明派生类：

class派生类名：继承方式基类名

<

//派生类新增的数据组员和函数组员

?；

继承方式可为公有继承(用public),私有继承(用private或缺省)和保护继承(用protected)

23.基类组员在派生类中的访问属性(重点)

基类中的组员在公有派生类中的访问属性在私有派生类中的访问属性在保护派生类中的访问属性

私有组员不可直接访问不可直接访问不可直接访问

公有组员公有私有保护

保护组员保护私有保护

24.派生类对基类组员的访问规则(重点)

(1)私有继承的访问规则

基类中的组员私有组员公有组员保护组员

访问方式内部访问不可访问可访问可访问

对象访问不可访问不可访问不可访问

(2)公有继承的访问规则

基类中的组员私有组员公有组员保护组员

访问方式内部访问不可访问可访问可访问

对象访问不可访问可访问不可访问

(3)保护继承的访问规则

基类中的组员私有组员公有组员保护组员

访问方式内部访问不可访问可访问可访问

对象访问不可访问不可访问不可访问

25.派生类的构造函数和析构函数

(1)派生类的构造函数和析构函数执行次序

无论何中派生，当创立派生类对象时，首先执行基类的构造函数，随即再执行派生类的构造函数;

当撤销派生类对象时，则先执行派生类的析构函数，随即再执行基类的析构函数。

(2).派生类的构造函数和析构函数的构造规则

简朴的派生类的构造函数一般格式为：

派生类名（参数总表）:基类名（参数表）

<

派生类新增组员的初始化语句

}

其中基类构造函数参数，来源于派生类的构造函数的参数总表，也可以用常数值。

26.从多种类，派生出一种类，也即一种类从多种基类继承称为多重继承。

多重继承的申明格式如下：

class派生类名：继承方式1基类名1,・・•，继承方式n基类名n

{

派生类新增的数据组员和组员函数

?；

派生类继承了基类］到基类n的所有数据组员和函数组员，其访问属性规则与单继承状况同样，

多继承可当作单一继承的扩展。

27.假如一种派生类有多种直接基类，而这些直接基类又有一种相似的基类，则在最低层的派生类

中会保留这个间接的共同基类数据组员的多份同名组员。在访问这些同名组员时会产生二义性，才

考虑虚基类，虚基类在派生类中申明的形式：

class派生类名：virtual继承方式基类名《

//........

}；

通过这样的申明后，当基类通过多条派生途径被一种派生类继承时，该派生类只继承该基类一次，

也就是说，基类组员无、、副本〃

【第5章】

28.编译时的多态性与运行时的多态性

静态联编（前期联编）静态联编规定在程序编译时就懂得调用哪个函数，就决定怎样实现某一动作。

动态联编（后期联编、滞后联编）

一直要到程序运行时才能确定调用哪个函数。系统在运行时才动态完毕的联编。

静态联编支持的多态性称为编译时多态性，也称静态多态性。在C++中，编译时多态性是通过函

数重载和运算符重载实现的。

动态联编支持的多态性称为运行时多态性，也称动态多态性。在C++中，运行时多态性是通过继

承和虚函数来实现的。

29.运算符重载：C++除了可以对函数重载外，还可以对大多数运算符实行重载。

外部一般函数类的友元函数是类的组员函数组员运算符函数定义的语法形式

组员运算符函数的原型在类的内部申明格式为：

classX<

//...

返回类型operator运算符（形参表）：

//...

?；

30.虚函数的引入，基类的指针可以指向它的公有派生类的对象，用''指针〃才有虚函数的问题。

引入派生类后，由于派生类是由基类派生出来的，因此指向基类的指针和指向派生类的指针是有关

的：

（1）基类的指针可以指向它的公有派生类的对象。但不容许指向它的私有派生类的对象。

（2）派生类的指针不容许指向它的基类的对象。

（3）基类的指针指向它的公有派生类的对象时，只能用它来直接访问派生类中从基类继承来的组

员，而不能直接访问公有派生类中定义的新组员。

31.有时在程序设计时，使用对象指针的目的是为了动态和灵活，即当指针指向不一样对象（基类

对象或派生类对象）时.能分别调用不一样类的绢员函数C

假如将函数阐明为虚函数，就能实现这种动态调用的功能。

虚函数的定义是在基类中进行的：

virtual函数类型函数名（形参表）

{

函数体

}

32.纯虚函数的一般形式如下：

virtual函数类型函数名（参数表）二0；

假如一种类至少有一种纯虚函数，那么就称该类为抽象类

【第6章】

33.模板的概念

模板是C++语言的一种重要特性。模板是实现代码重用机制的一种工具，它可以实现类型参数化,

即把类型定义为参数，从而实现了代码重用，使得一段程序可以用于处理多种不一样类型的对象，

大幅度地提高程序设计的效率。

34.函数模板和类模板

（工）.函数模板与模板函数

所谓函数模板，就是写一种函数模子，用这个模子套印出许多功能相似，参数类型和返回类型

不一样的函数。模板函数：函数模板实例化后的详细函数。

（2）类模板和模板类类模板（也称为类属类或类生成类）是：容许顾客为类定义一种模子，使得

类中的某些数据组员，某些组员函数的参数或者返回值，能取任意数据类型

【第7章】

35.C++流概念：cin>>对象；

coutvv对象；

整型、实型、字符、字符串等有格式的输入输出

36.文献的输入输出：在具有文献操作的程序中，必须有如下的预处理命令：#include

<fstream.h>

open、close函数

文本文献、二进制文献读写。

复习思索题、即考试的A、B、C、D选择题和填空题

一、分清下面的概念，那些是对的的，那些是错误的

1.面向对象程序的重要构造特点之一

/程序一般由类的定义和类的使用两部分构成。V程序中的一切操作都是通过向对象发送消息来

实现的。X程序中的一切操作都是通过调用函数来实现的。X程序一般由函数定义和函数的使用

两部分构成。X程序一般由变量的定义和变量的使用两部分构成。X程序一般由对象的定义和对

象的使用两部分构成。X程序中的一切操作都是通过定义函数来实现的。X程序中的一切操作都

是通过定义类来实现的。

2.对象是现实世界中的一种实体.其特性

V每个对象必须有一种名字，以示区别。V有属性描述。V有一组操作。V创立对象时会自动调

用构造函数。X必须有一种关健字。X一定要自定义一种构造函数。X要有二个以上数据。

3.面向对象系统的特性是

V抽象性V封装性V继承性V多态性X完整性X唯一性X二义性X安全性

4.类的概念是

V对一组具有共同的属性特性和行为特性的对象的抽象。V同一类数据的集合。X类即是对象数

组。X多种对象的集合。X同一记录的集合。X同类函数的集合，X现实世界中所有对象的集合。

5.类和对象之间的关系是

V抽象和详细的关系。V类型和变量之间的关系。＞/构造类型和构造体的关系。X定义和被定义

的关系。X调用和被调用的关系。X类即是对象数组。X型和值的关系。X指针和所指的对象的

关系。

6.构造函数的特性

V构造函数的函数名与类名完全相似。V构造函数可以有形式参数。V构造函数可以重载。V在

创立对象时被执行。X在程序编译时被执行。X在创立类时被执行。X在程序装入内存时被执行。

X构造函数必须阐明返回类型。X程序中要有调用构造函数的语句。

7.析构函数的特性

V一种类中只能定义一种析构函数。/析构函数名与类名相似并加~。/系统会自动调用析构函

数。x析构函数的定义只能在类体内。x析构函数可以有多种参数。x一种类中能定义多种析构

函数。

8.有关组员函数特性的下述描述

”组员函数可以重载。V组员函数可以设置参数的缺省值。，组员函数可以是静态的。V类定义

中只给出组员函数的原型，而组员函数在类外定义。V类定义中只给出组员函数的原型，而组员

函数在类外定义并在之前加inline。V可在类内定义。x组员函数一定要在类内定义。x组员函

数一定是内置函数。

9.下列的多种函数中，是本类的组员函数

V构造函数V析构函数/拷贝构造函数V缺省参数的构造函数x友元函数x主函数

X一般函数X原则函数

10.在友元函数的下面说法中，对的的是：

，友元函数是独立于目前类的外部函数.x一种友元函数不能同步定义为两个类的友元函数

x友元函数必须在类的外部定义。x在外部定义友元函数时，必须加friend

11.友元的作用是什么，一种类的友元可以访问该类的什么

V提高程序的运行效率。X加强类的封装性。X实现数据的隐藏性。X增长组员函数的种类

V所有组员X只能是私有组员X只能是公有组员X组员函数

12.对基类和派生类的关系描述中

V派生类（如公共汽车）是基类（汽车）的子集。V派生类是基类定义的扩延。V无论哪种派生，基

类的私有组员不容许派生类的组员函数访问。V无论哪种派生，基类的公有组员容许派生类的组

员函数访问。V无论哪种派生，基类的保护组员容许派生类的组员函数访问。X派生类是基类的

详细化。X派生类是基类的组合。X无论哪种派生，基类的保护组员不容许派生类的组员函数

访问。

13.派牛类的对象对它的基类绢员中,可以访问的是

“公有继承的公有组员。X公有继承的保护组员。X公有继承的私有组员。X公有继承的所有组

员。X私有继承的公有组员。X私有继承的私有组员。X私有继承的所有组员。X私有继承的保

护组员。

14.对虚基类对的的论述

7定义派生类时，在基类名前加virtuaLx定义基类时加virtuaLx组员函数前加virtual。

x在派生类名前加virtuaL

15.一种派生类有多种父类，而这多种父类又有一种共同基类，这种状况，才考虑设置虚基类，其

目的是：

V消除二义性。简化程序。提高运行效率。减少目的代码。

16.C++中函数可以重载：（P31）

/只要函数参数的类型不一样，/或者参数的个数不一样，”或者两者兼有之，两个以上函数可

以同名。

17.不可重载的函数的是：V析构函数。（可以：）一般的组员函数。友元函数。外部函数。

18.可定义作运算符重载函数的是

，组员函数。V友元函数。V类以外的函数。X析构函数。X无返回值的函数。X构造函数。

19.不能重载运算符

V：：V?:&&[]new++（）delete

20.有关动态联编的描述，动态联编称为运行时的多态性是通过什么来实现的。

V动态联编是以虚函数为基础的。V动态联编是在运行时确定所调用的函数的。V动态联编调用

的函数，是用基类对象的指针或对象引用所指的函数。V继承和虚函数。动态联编是在编译时确

定操作函数的。函数重载和运算符重载。运算符重载。函数重载。

21.说白了，通过基类指针或引用来访问基类和派生类中的同名函数，才考虑虚函数。其描述：

V虚函数是在基类中用virtual阐明，派生类中重新定义的函数。x虚函数是一种static类型

的组员函数。x虚函数是一种非组员函数。x派生类的虚函数与基类的虚函数具有不一样的参

数个数和类型。

22.抽象类论述：

V假如一种类至少有一种纯虚函数，那么该类为抽象类。V抽象类只能用作其他类的基类，不能

建立抽象类对象。。抽象类可以用来定义指针。X抽象类可以作为某个函数的返回类型。

23.进行文献操作时需要包括的文献，C++用cout和cin进行输出/输入操作时需要包括文献.

Vfstream.hViostream.hstdio.hstdlib.hstring.hmath.h

24.面向对象程序设计是不一样于老式程序设计的一种新的程序设计范型。面向对象的程序设计被

认为是程序设计措施学的一场实质性的革命（在导学中）。

25.面向对象（0-0）程序设计是一种新的程序设计范型。这种范型的重要特性是：

程序=对象+消息

26.现实世界中，对象一般可以表达为：属性+行为

27.在定义类时，第一种保留字。（class）

28.将数据构造和作用于数据构造上的操作构成一种实体，数据的表达方式和对数据的操作细节被

隐藏起来，这是面向对象程序设计的（封装性）。而函数重载是（多态性）。

29.C++中类的定义内部，英文private段，protected段，public段（私有段保护段公

有段）

30.定义了类A,在主函数中如出现：A*p,obj,ob[10];的语句。（则p是对象指针、。主

是对象、ob是对象数组。）

31.C++的运算符：«>>newdelete（输入输出申请释放）

32.在C++定义的类中，组员可分为二类，有三个段。（数据组员函数组员私有公有保

把）

33.在一种类定义中，可以申明友元，友元可以是三种友元。（友元函数友元组员友元类）

34.C++中，函数阐明为voidfun（int&i）的引用叫，（参数引用）,函数阐明为void

&fun（inti）的引用叫。（返回值引用）

35.继承机制容许派生类继承基类的什么，（数据和操隹）同步，派生类还可以增长新的什么“数

据和操作）

36.类外的函数作运算符重载时，只能访问类的（公有）组员,而用类的友元运算符函数或组员运

算符函数重载可以访问类的（所有）组员。

37.一种类模板容许顾客为类定义什么？（一种模式（子））使得类中的某些数据组员、某些组员

函数的参数或返回值，能取什么类型？（任意数据类型）

38.模板是实现代码重用机制的一种工具，函数模板的实例化、类模板的实例化分别称为（模板函

数、模板类）

复习之二、阅读程序写运行成果、程序填空（把这些程序

真正馔懂，不要背答案！）

1.函数、函数调用、函数原型（包括参数引用、返回值的引用）

2.类的定义和定义对象（包括对象指针）

3.派生和继承的应用

4.派生类的构造函数和析构函数执行次序

5.函数重载和运算符重载

复习思索题

1.

#include<iostream.h>

intadd（int,int）;

intmain（）

{intx,y,sum;

coutvv〃输入二个整数:北

cin>>x>>y;

sum=add(x,y);

cout<<,,x+y=,,<<sum<<endl;

return0;

?

intadd(inta,intb)

{intc;

c=a+b;

returnc;

}

答案：输入二个整数：工。20

x+y=30

2.

#include<iostream.h>

voidfunl(inti)

{i+=5;

?

voidfun2(int&i)

{i+=15;

}

voidmain()

{intk=10;

funl(k);

cout<<"k=n<<k;

fun2(k);

cout<<"k="<<k<<endl;

}

答案：k=5k=15

3.

#include<iostream.h>

int&f(int&i)

{i+=10;

returni;

}

intmain()

{intk=0;

int&m=f(k);

cout<<k<<\,;

m=20;

cout<<k<<endl;

return0;

}

答案：［0,20

4.

#include<iostream.h>

classPoint{

public:

Point(intxl=0zintyl=0){

x=xl;y=yl;

}

voidprint();

private:

intx,y;

?；

voidPoint::print(){

cout<<nx=,,<<x<<"y=n<<y<<endl;

voidprint(Pointp)<

p.print();

}

voidmain()

{Pointp1(T0,20),p2(30),p3,*p；

P=&P1；

p->print();

p2.print();

print(p3);

}

答案：x=10y=20

x=30y=0

x=0y=0

5.

#include<iostream.h>

classPoint{

public:

Point(intxl=0,intyl=0){

x=xl;y=yl;d=x*x+y*y;

}

voidprint(){

coutvv”x="vvxvv"y="<<y<</rdist=,r<<d<<endl;

)

private:

intx,yzd;

?；

voidmain()

{Pointpl(l)zp2(2,3h*P；

P=&P1；

p->print();

p2.print();

}

答案：x=ly=0dist=l

x=2y=3dist=13

6.

#include<iostream.h>

classBase{

public:

Base(intn)

<cout<<“目前进入Base基类的构造函数\n“；

i=n;

}

~Base()<coutvv”目前进入Base基类的析构函数\n”；}

voidshowi()<cout<<i<<endl;}

private:

inti;

?；

classDerive:publicBase{

public:

Derive(intn,intm}:Base(m)

{cout<<“目前进入Derive派生类的构造函数\n”；

j=n;

}

~Derive()

<coutvv”目前进入Derive派生类的析构函数"cvendl;}

voidshowj()<cout<<j<<endl;}

private:

intj;

?；

voidmain()

{Deriveobj(30,40);

obj.showi();

obj.showj();

}

答案：目前进入Base基类的构造函数

目前进入Derive派生类的析构函数

40

30

目前进入Derive派生类的析构函数

目前进入Base基类的析构函数

7.

#include<iostream.h>

classTime{chara[9];

public:

Time(ints=0zintm=0,inth=0)<

hours=h;

minutes=m;

seconds=s;

}

voidshow(){

coutvv"时间："<vhoursvv":"vvminutesvv":"vvsecondsvvendl;

}

friendTimeoperator+(TimetlzTimet2);

private:

inthours;

intminutes;

intseconds;

?；

Timeoperator+(Timetl,Timet2){

Timetemp;

temp.hours=tl.hours+t2.hours;

temp.minutes=tl.minutes-l-t2.minutes;

temp.seconds=tl.seconds+t2.seconds;

if(temp.seconds>60){

temp.seconds=temp.seconds-60;

temp.minutes++;

}

if(temp.minutes>60){

temp.minutes=temp.minutes-60;

temp.hours++;

}

if(temp.hours>=24)temp.hours=temp.hours-24;

returntemp;

}

voidmain()

{TimeT,Tl(20,23z21)zT2(10,25,15),T3(5,10,15);

T=T1+T2;

T.show();

T=T+T3;

T.show();

}

答案：时间：12:48:30

时间：3:58:35

8.

#include<iostream.h>

#include<string.h>

classStr{

public:

Str(char*pi){

p=newchar[strlen(pl)+l];

strcpy(p,pi);

}

voidshow(){

coutvv"字符串："vvpvvendl;

}

voidoperator++();

private:

char*p;

?；

voidStr::operator++()<

Strtemp(,,\0n);

temp.p=newchar[2*strlen(this->p)+l];

strcpy(temp.p,this->p);strcat(temp.p,this->p);

this->p=newchar[2*strlen(this->p)+l];

strcpy(this->p,temp.p);

}

voidmain()

{StrTIC'ABCDXYZ");

++T1;

Tl.show();

}

答案：字符串：ABCDXYZABCDXYZ

9.

下面的程序定义一种类samp,有三类数据组员和一种构造函数和一种函数组员，填

充程序缺乏部分，使其变成完整的C++程序。

#include<iostream.h>

classSamp{

protected:

intb;.

public:

intc;

(1)fintn,intm)//构造函数

{a=n;12);c=a+b;

?

int(3)(inti)//组员函数

<if(i==l)returna;

elseif(i==2)returnb;

elsereturn0;

?

private:

inta;

?；

voidmain()

{Sampobj(20,30)；

cout<<(4)<<endl;〃输出20

cout<<obj.getab(2)<<endl;〃输出30

cout<<(5)<<endl;〃输出50

}

答案：(1).Samp(2).b=m;(3).getab(4).obj.getab(l)(5).obj.c

10.

下面的程序定义一种类samp,有三类数据组员和一种构造函数和一种函数组员，填

充程序缺乏部分，使其变成完整的C++程序。

#include<iostream.h>

class(1){

public:

intc;

(2)(intn,intm)//构造函数名

<a=n;b=m;c=a+b;

}

int⑶(charch)〃组员函数名

<switch(ch)

{case'a':returna;break;

case*b':returnb;break;

default:return0;

}

}

private:

inta,b;

?；

voidmain()

{Myclass(4)(20,30);〃定义对象

cout<<obj.get('a')<<endl;//输出20

cout<<obj.get('b')<<endl;//输出30

cout<<(5)<<endl;〃输出50

}

答案：(1).Myclass(2).Myclass(3).get(4).obj(5).obj.c

11.

定义一种基类长方形Base,私有段有长a和宽b,公有段有构造函数，能显示长方形面

积等。定义以该长方形为底面积的派生类长方体Cuboid,有高h,有构造函数，能显

示长方体体积。在主函数中定义长方体对象，其长、宽、高分别为T0,20,5,显示

出长方体体积和长方形底面积。

#include<iostream.h>

classBase{〃定义长方形

public:

Base(floatal=0zfloatbl=0)

<_________CD________//公有段构造函数体

}

voidarea()//函数area()显不长方形面积

{cout<<“区方形面积是：n<<a*b<<endl;

}

floatgetr()<returna*b;}

private:.

floatazb;

?；

classCuboid:publicBase<//定义以该长方形为底的派生类长方体

public:

Cuboid(floatal,floatblzfloathl):12)//构造系数

{h=hl;

?

void[3}()//显示长方体体积的函数

<cout<<“长方体体积是："vvh*getr()vvendl;>

private:

floath;

?；

voidmain()

<_______⑷______ob(10,20,5);//这里定义对象ob

________⑸；//这里输出长方形面积

ob.body();//这里输出长方体体积

}

答案：(1).a=al;b=bl;(2).Base(al,bl)(3).body(4).Cuboid(5).ob.area()

12.

定义一种基类长方形Base,私有段有a和宽b,公有段有构造函数，能显示长方形面

积等。定义以该长方形为底面积的派生类长方体Cuboid,有高h,有构造函数，能显

示长方体体积。在主函数中定义长方体对象，其长、宽、高分别为10,20,5,显示

出长方体体积和长方形底面积。

#include<iostream.h>

classBase{〃定义长方形

public:

Base(floatal=0zfloatbl=0)

<a=al;b=bl;//公有段构造函数体

}

voidarea()//函数area()输出显示长方形面积

{cout«"长方形面积是：”vv(1)<<endl:)

floatgetr()<returna*b;}〃函数getr()计算上方形面积

private:

floata,b;

?；

classCuboid:publicBase<〃定义以该长方形为底的派生类等方停

public:

Cuboid(floatal,floatblzfloathl):⑵//构造函数

{h=hl;

}

voidbody()〃输出显不长方体体积的函数

<cout«"长方体体积是："vvh*getr()vvendl;}

private:

floath;//h是长方体的高

?；

voidmain()

{

⑶ob(10,20,5);//这里定义对象ob

_______⑷；___________//这里调用函数，输出长方形面积

⑸_______；//这里调用函数，输出长方体体积

}

答案：(1).a*b;(2).BaseCal^bl)(3).Cuboid(4).ob.area()(5).ob.body()

复习之三、程序设计题(把这些程序真正读懂)

1.C++基础知识

2.定义类、组员函数及构造函数的习题

来自《VC++6.0面向对象程序设计试验提纲》

1.下面是一种c程序，改写它，使它采用C++风格的I/O语句。

#include<stdio.h>-#include<iostream.h>

voidmain()

<intazbrd,min;

printf("输入两个整数:“)；—coutvv”输入两个整数:“；

scanfC^^d^d^&a^&b);-cin>>a;cin>>b;

min=a>b?b:a;

for(d=2;d<=min;d++)

if((a<Vbd==O)&&(b<Vbd==O))break;

if(d>min)

printf("没有公约数!\n-coutvv”没有公约数八n”；

else

printf("最小公约数是:%d\n”,d);-coutvv”最小公约数是:"'vvdvvendl;}

2.编C++程序，从键盘输入二个任意大小的数，在屏幕上从小到大输出这二个数。

#include<iostream.h>

voidmain()

{inta,b,c;

cin>>a;cin>>b;

if(a>b){c=a;a=b;b=c;}

cout<<a<<r,r,<<b<<endl;

}

3,定义一种基类圆Circle,私有段有圆的半径，公有段有构造函数，能显示圆面积等。

定义派生类Ex_square为圆的外切正方形，有构造函数，能显示正方形面积。在主

函数中定义外切正方形对象，其圆半径为工0,显示两者面积。

答案：

#include<iostream.h>

classCircle<floatr;//申明一种圆类

public:

Circle(floatx=0){r=x;}//构造函数

voidareal()//函数area()显示圆面积

<cout<<“圆面积是：*'<<3.14*r*r<<endl;}

floatgetr()<returnr;}

private:

floatr;

};

classEx_square:publicCircle{〃派生一种圆外切正方形类

public:

Ex_square(floatx):circle(x)<}//构造函数

voidarea2()//函数area()显示正方形面积

<cout«”外切正方形面积是："vv4*getr()*getr()vvendl;}

?；

voidmain()

{Ex_squareob(10);

ob.areal();

ob.area2();

?

4.【习题3・32］建立类Cylinder,Cylinder的构造函数被传递了两个double值,

分别表达圆柱体的半径和高。用类cylinder计算圆柱体的体积,并存储在一种double

变量中。在类Cylinder中包括一翁组员函数vol,用来显示每个Cylinder对象的体

积。(数据：圆柱体的半径为2.2,高为8・09)

答案：

#include<lostream.h>

classCylinder<〃申明圆柱体

public: