C++语言程序设计基础知识

第12章 面向对象程序设计与C++基础

程序设计语言是编写程序的工具，程序设计语言的发展反映了程序设计方法的演变过程。随着计算机技术的日新月异，要求软件具有良好的可重用性和可扩展性，这就导致程序设计方法从结构化程序设计方式转变到面向对象程序设计方式。C 语言能够很好地支持结构化程序设计，C++不仅兼容C ，同时具有面向对象的特征，因此充分支持面向对象程序设计。 面向对象程序设计的基本概念

面向对象技术变革了软件设计的传统方法。解决结构化程序设计不足的方法就是限制数据的存取权限，面向对象程序设计把数据和使用此数据的过程封装成一个类（类可看成是一个基本数据类型）。数据的封装和隐藏一方面使得内部数据不被破坏，另一方面程序具有良好的可读性和相对独立性。类的继承机制不仅提高了代码的可重用性，降低了软件开发难度和开发周期，同时程序的修改变得容易，软件结构更加稳定，软件的可维护性大大提高。

面向对象软件系统由类的层次结构组成，类的具体实例叫做对象，对象之间通过彼此的联系，共同实现程序的功能。如图12-1所示。

面向对象程序设计方法提出一些全新的概念：对象、类、封装、数据隐藏、继承和多态性等。多态性、数据封装和继承共同构筑了面向对象程序设计的三大机制。 1. 类与对象

面向对象的方法学认为，客观世界由对象组成，对象有自己独特的特征和行为，两者密不可分。

面向对象的软件技术中，类是将不同类型的数据和与这些数据相关的操作封装在一起的集合体。对象可看成类的具体实例。图12-2描述了洗衣机类。

【例12-1】 在现实世界中，钢笔具有笔帽、笔体、笔

尖、颜色、形状等属性特征，钢笔具有的行为是书写、灌钢笔水。钢笔作为一个整体，具有独特的属性和行为，它们将被抽象成一个钢笔类。这种自成一体性称为封装性。而你正在使用的钢笔，可以看成钢笔类中的一个具体实例。我们不必关心钢笔的内部结构及实现细节，仅利用钢笔对外提供的操作，即外部接口，就可以方便地使用钢笔。

【例12-2】 对于整型类型的数据，可以定义对它的四则运算，这是整型数据具有的行为，四则运算与整型数据封装成一体，命名为“int 类”。字符型运算和逻辑运算不可以访问、修改int 类中的数据，只有int 类中定义的四则运算才能对其进行操作。显然，我们也无需知道四则运算是如何定义的，int 类对外界提供的操作接口是“+”、“－”、“*”、“/”，可以直接利用这些接口实现整数的四则运算，这叫做数据的隐藏性。 2. 数据的封装和隐藏

封装强调的是数据和行为的自成一体性，也就是将数据和操作数据的函数代码进行有机的结合，

类的层次结构

图12-1 面向对象软件系统

图12-2 洗衣机类示意图

形成“类”。封装具有如下意义：

1) 面向对象的程序表现出强烈的可读性和独立性。

2) 程序不依赖数据结构的改变，具有良好的可维护性。当数据结构改变时，只有类中对数据进行操作的函数需要修改，程序的其他部分不受影响。

3) 对数据起到一定的保护作用。只有类中的函数才可以修改类中的私有数据。

隐藏是指类把对数据的操作信息隐藏在内部，只提供对象对外的操作接口，用户只能看见对象封装接口上的信息，这样可以保护内部数据不被破坏，同时使用者使用起来非常方便，并可以容易地将其扩展成新的产品。 3. 类的继承

类的继承是指新的派生类可以继承原有父类的全部数据和操作的机制，并可以在派生类中添加新的数据和操作方法。新的派生类又叫子类，原有父类又叫基类或超类。例如，想生产敞篷汽车不用从草图开始，只需要对原有的产品添加新的敞篷功能，这样就会快速开发出一种新的产品。利用类的继承特性，可以非常方便地产生一系列具有相似特征的对象。

再看一个类继承的例子。在小学，我们学过数的四则运算，到中学会进一步学到对数、指数等运算，到大学将学到微积分等内容。我们每一次的进步都将继承已学过的知识，在已有的基础上不断扩充新的知识。 4. 消息

对象之间通过消息相互联系，也是通过消息让某一个对象完成一定的功能。例如，给洗衣机对象发洗涤的操作信号，洗衣机就会执行洗涤的功能。

在面向对象的程序设计中，消息名就是在对象中定义的操作（或称方法），给对象发消息，就是让对象执行某一操作，使对象具有行为的能力。如图12-3所示。

5. 多态性

多态性表示同一种东西有多种形态。例如，与对方通信，这个动作将有多种表现形态，如采用写信的方式、打电话、发电报、发电子邮件等。

在面向对象的程序设计中，多态性是指同一个（或相似的）操作作用于不同的对象上可以有不同的独特行为，比如add 操作，作用在实数对象上，表现为两个实数相加，作用在虚数对象上，表现为两个虚数相加。

面向对象的C++语言允许程序员给不同的对象发同一消息，软件系统会做出决策，即到底执行什么动作。在静态（编译或连接）时就可以分辨的，可通过函数重载实现；在运行时才能分辨的，可通过虚函数实现。

利用多态性，用户能够发送一般形式的消息，而将所有的实现细节留给接收消息的对象。这种高层次的抽象， 使得多态性、数据封装和继承共同构筑了面向对象程序设计的三大机制。 面向对象程序设计语言C++简介

C 语言是一种受到广泛重视和应用的面向过程编程的语言，它采用结构化程序设计技术，即把复杂的模块层层分解为一系列简单模块。人们侧重于开发具有特定功能的函数，而有些数据（特别是全局数据）在函数间可随意传递。

求面积

在C++中的表示：

A 求面积(边长，顶点坐标)

图12-3 消息机制

结构化程序设计语言无法处理高度复杂的程序，为了弥补结构化C 语言的不足，支持面向对象的程序设计的C++语言应运而生。C++语言是一种混合性语言，保留了C 语言的全部内容，同时扩展了C 语言所不具有的面向对象编程的机制。

C++在技术上与C 完全兼容，但它具有与C 语言完全不同的思维方式，即支持面向对象的程序设计思想，强调对数据进行封装、保护等深入的维护，强调软件的可扩展性、可修改性和可维护性。 利用C++语言可以进行结构化编程， 更重要的功能是进行面向对象的编程。 C++程序结构

本小节主要介绍两个程序， 一个是面向过程的C++程序，见例12-3； 一个是面向对象的C++程序，见例12-4。通过这两个实例，读者可以对C++程序结构有个初步认识。 【例12-3】 以下程序实现输入一个整数，求平方根并打印出来。

注释行 C++的注释有两种类型：一种是沿用C 语言的方法，采用“/*”和

“*/”括起来进

行注释，另一种方法是只能用于C++的单行注释，即从“C++的cin 与cout

cout 、cin 是C++语言中增加的用来输出和输入的函数，分别代表输出设备对象和输入设备对象。cout 和cin 函数的使用方式不随变量的类型变化，这正是面向对象语言所追求的。

cout 是代表标准输出的流设备，如显示屏。输出操作必须配合操作符“〈〈”，表示把该操作符右边的数据输出到显示屏上。cin 是代表标准输入的流设备，如输入设备键盘。输入操作必须配合操作符“〉〉”，代表从标准输入设备读取数据到内存。 cin 与cout 定义在输入输出流头文件中。 3. 关键字const 定义符号常量

C++中的符号常量使用关键字const 来说明，其一般形式： const 类型说明符 常量名=常量值 或

类型说明符

const 常量名=常量值

例如：定义一个buf 的常量。 const int buf=512 或

int const buf=512 4. new 和delete 运算符

C++新增new 和delete 作为动态内存分配和释放的操作符，用来增强C 语言中原有的函数malloc 和free ，提高了内存管理的灵活性。例如： int *p; 引用作为函数参数

C++新增了引用，它使函数调用变得清晰、简单，参数传递效率更高。同时，将引用作为函数参数给编程带来了很大的灵活性。

引用可看成某个目标变量的别名，对引用的操作，实际上就是对目标变量的操作，引用与目标变量完全对应。一旦用目标变量给引用赋初值，引用就被维系在该目标变量上，即引用不会再与其他目标变量建立联系。引用不能是空，与此相反，指针变量可以为空。 声明并初始化引用的一般格式： 数据类型& 引用名=目标变量;

其中，“数据类型”是定义目标变量的类型，而“数据类型&”是用来声明引用的。例如：

对象A

i

图12-4 定义类的对象A

对象A

i

图12-5对象A 初始化

int m;

int& kk=m; 函数返回类型是引用

当函数返回类型不是引用时，实际上是在内存中开辟临时空间存放函数返回的值，而函数返回类型是引用时，不需要这样一个中间过程，即不需要产生临时变量以存放返回值，而直接把返回值传回到主函数中，从而大大提高程序执行的效率，同样也节省了空间。

注意不要返回不在主函数作用域内的变量或对象的引用。

【例12-7】返回引用类型的应用。

#include

using namespace std;

int large;

int& max(x,y)

{

large=(x>y)x:y;

return large; 内联函数

为了减少函数调用的开销，C++引入了内联函数。内联函数的功能是强迫C++编译程序直接使用函数体代码替换调用语句，以提高程序的运行速度。

内联函数定义的一般形式：

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

{

函数体

}

如果在类的声明中直接给出成员函数的定义，该成员函数默认为内联函数。通常只将规模较小又使用频繁的函数设计为内联函数。

8. 带默认形参值的函数

C++允许定义带多个默认形参值的函数。例如，设函数原型声明情况如下：

int change(int x=10, int y=20);

则函数调用情况如下：

change(40); 类的定义

类是由成员组成的，包括一组数据成员和成员函数，其定义的一般形式：

class 类名

{

private:

私有数据和成员函数

public：

公有数据和成员函数

protected：

保护数据和成员函数

};

类的名称由关键字class开始，类的定义体夹在一对花括号{}中，后面可以跟分号，或一组属于该类的对象。

类内的一组成员变量和成员函数可以有以下三种类型：私有数据类型（private）、保护数据类型（protected）、公有数据类型（public）。

如果用private来说明类的数据和成员函数，则意味着它们只能被该类中定义的成员函数和友元函数访问。通常数据默认为私有类型，私有类型的保留字private可以省略。

如果用protected来说明类的数据和成员函数，则意味着它们只能被该类中的成员函数、友元函数、该类的派生类中的成员函数所访问。

如果用public来说明类的数据和成员函数，意味着可以在类的外部（不通过类的成员函数，如主函数）存取数据。类中的公有成员函数提供了该类对外的接口，即通过公有成员函数，才可以访问类的私有数据。

2. 类的成员

类的数据成员不仅包含普通的数据变量，而且还可以包含其他类的对象。类是一种新的数据类型，而对象可看成是由类定义的变量。类的成员函数对类内的数据成员施加操作，实现类的特定功能。若成员函数很小，可以在类内定义，反之，一般在类外定义。

数据成员通常定义为私有或保护类型，以便隐藏和保护数据。成员函数通常定义为公有类型，目的是提供对外的接口，以便能够对类访问。

为了在类外定义成员函数，必须指出该成员函数是属于哪个类的，C++中引入了一个符号“：：”，称为作用域运算符。

在类外定义成员函数的一般形式：

函数返回类型类名：：成员函数名（形参表）

{

函数体

}

3. 对象的定义

类是对具有相同属性和行为的一组相似对象的抽象，而对象是类的具体实例。类可看成是一个抽象的数据类型，而类的对象就是属于类的一个具体变量。

类不是一个占有内存的实体，但对象却是。创建类中的对象，就是在内存中创建具体的对象，其含义就是在内存中为类中的数据分配存储空间，它们是对象的具体体现。

通常在子函数中、主函数中以及函数的前面采用如下方式定义对象：

类名对象名;

这种方式使得对象如普通变量一样，具有一定的作用域（生存期）。

4. 类成员的使用

类中的成员，包括数据成员和成员函数。有了对象，若想使用类中的公有成员，可采用以下形式：对象名. 公有数据成员

对象名. 公有成员函数

例如，(); 是指给对象m发消息input()，对象m执行input()函数。

注意类中的私有数据只能通过该类的成员函数进行访问，类中的保护数据可被该类的成员函数以及该类的派生类的成员函数或友元函数所访问。

5. 类成员的初始化

(1) 数据成员初始化

类中公有数据成员可像普通变量一样使用，可在定义对象后，在需要时赋初值。假设有一公有数据num，对象名为A，则用如下方式初始化：

=10; 构造函数

在C++中通常自动初始化对象的数据。为了做到这一点，可以定义一个特殊的成员函数，它的名字与类名相同，称为构造函数。构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。当我们定义属于类的对象时，系统就自动执行构造函数，初始化具体的对象。

如果程序没有声明构造函数，系统会自动地为程序设置一个，此构造函数什么也不做。对象在创建时只是被分配空间，具体的初值只能由用户定义的初始化函数来实现。

关于构造函数，给出以下几点说明： 1) 构造函数与类名相同。

2) 构造函数没有返回类型，也不能是void 类型。 3) 构造函数不能被随意调用，由系统自动调用。

4) 构造函数可以重载，可以带默认形参，可以是内联函数。

5) 构造函数可以带参数也可不带参数，不带参数的构造函数称为默认的构造函数。 2. 析构函数

此外，C++还提供了一种特殊的成员函数，叫做析构函数。当对象被取消时，系统首先会自动调用类的析构函数，然后撤销对象（释放对象所占用的存储空间）。如果程序中没有声明析构函数，则系统会自动为程序设置一个析构函数。如果用new()函数动态分配对象，当动态对象被取消时，系统会调用析构函数。因此，通常在析构函数中设置delete()函数就会自动撤销动态对象。 关于析构函数，给出以下几点说明：

1) 析构函数的名称与类名相同，但前面加符号“～”。 2) 析构函数没有返回类型，也不能是void 类型，没有参数。 3) 析构函数由系统自动调用，不能随意调用，不能重载。 4) 一个类中只能有一个析构函数。

5) 基类的析构函数可以是虚函数，以便系统调用派生类析构函数，撤销其对象。

【例12-8】 编写一个日期类DATE ，对年、月、日进行管理，能响应询问日期及判断是否闰年。

#include using namespace std; class DATE{

派生类

在C++中，派生类从一个基类继承的一般形式： class 派生类名：public 基类名 {

成员变量和成员函数声明; }

其中，派生类名是新类名，public 是最常用的继承方式，本章主要介绍public 继承方式。此外，还有private 、protected 继承方式，其特殊性可参考其他C++教材。

注意 1) 自动从基类继承下来的所有成员变量和成员函数不在派生类的定义中出现，但若需要在派生类中重新定义基类的成员函数，就必须在派生类的声明中列出来，并为其赋予一个新定义，这如同在派生类中新增一个成员函数。

2) 任何其他类（包括派生类）的成员函数定义中，不能直接根据名称访问继承下来的基类私有成员变量，但可以使用基类中定义的成员函数间接访问基类的私有成员变量。 3) 私有成员函数根本不会被继承。

【例12-10】 派生类程序示例（基类是例12-8中定义的DATE 类）。

基类的protected 成员

不能在派生类的定义或实现中直接用名称访问基类的私有成员变量。但如果在基类中把成员变量和成员函数标记为protected 性质，则在其派生类（以及派生类的派生类）中不仅能继承下来，且可以用名称直接访问，其性质保持为protected 。而在其他任何类或函数中，等同于用private 来标记。

year month day

对象A

图12-6 实例化类中的对象

图12-7 派生类对象实体

C++中的多态性、函数重载和虚函数

多态性是面向对象程序设计的重要特征之一。继承重点研究类与类的层次，多态则研究在不同层次的类中，同名成员函数的关系。所谓多态性就是同样的接口有不同的功能，同样的消息被不同的对象接收时产生不同的行为。C++获得多态性的方式是函数重载、运算符重载和利用虚函数来实现。

1. 函数重载

普通函数、类的成员函数和友元函数都可以重载。函数重载是指函数名相同，但参数的类型和数量可以不同。系统根据其参数个数、参数类型，调用相应的函数，执行特定的功能。函数重载的意义在于能使用户为某类操作起一个通用的名字，由编译器在编译时来确定选择哪个函数来执行某一操作，从而降低了程序的复杂性。

【例12-11】编写两个函数，分别求整型数和浮点型数的最大值。

#include

using namespace std;

int max(int a,int b);

double max(double a, double b);

int max(int a, int b)

{ return (a>b a:b);}

double max(double a, double b)

{ return (a>b a:b);}

void main()

{ cout<

运行结果：

5

2. 虚函数与纯虚函数

虚函数可以使程序在运行过程中动态地确定操作所针对的具体对象，从而实现运行时的多态性。声明虚函数的方法是在基类中的成员函数原型前加上virtual。虚函数可以在一个或多个派生类中重复定义，但要求必须与基类中的函数原型完全相同。这时，无论在派生类的相应成员函数前是否加上关键字virtual，都将视其为虚函数。

在实际应用中，通常把基类中的虚函数定义为纯虚函数，即只在基类中声明虚函数，而不定义其函数体，将它的具体定义放到各个派生类中。通过该基类指针或引用，就可以在运行时调用所有派生类的虚函数。

纯虚函数的声明的语法形式如下：

virtual 函数类型函数名（形参表）=0;

【例12-12】设计一个图形类，利用纯虚函数实现运行时的多态性。

要求：计算矩形和三角形的面积。

分析：首先定义一个抽象的图形类Shape，在类Shape下可以派生出多种具体的形状。为了求这些图形的面积，只需在类Shape中声明一个纯虚函数getArea()，而将计算具体形状面积的定义放在其派生类中。

#include

using namespace std;

class Shape

{

protected:

double x,y;

public:

void set(double a, double b)

{ x=a;

y=b;}

virtual void getArea()=0;

};

class Triangle:public Shape

{

public:

void getArea()

{ cout<<"Triangle S=1/2*"<

};

class Rectangle:public Shape

{

public:

void getArea()

{ cout<<"Rectangle S="<

};

void main()

{

Shape *p; //声明抽象类Shape的指针p

Triangle t; //定义派生类对象

Rectangle r;

p=&t; //p指向Triangle对象t

p->set,; //给对象t赋值

p->getArea(); //此时p->getArea()就调用Triangle的函数getArea()

p=&r; //p指向Rectangle对象r

p->set,; //给对象r赋值

p->getArea(); //此时p->getArea()就调用Rectangle的函数getArea()

}

运行结果：

Triangle S=1/2**=

Rectangle S=*=

小结

C语言能够很好地支持结构化程序设计，C++不仅兼容C，同时具有面向对象的特征，因此充分支持面向对象程序设计。

结构化程序设计解决问题时，常常把复杂的问题分解为一系列数据和对数据进行处理的过程（或函数），因为数据没有被“隐藏”在对它进行处理的过程中，这导致结构化程序设计存在着巨大的隐患。

面向对象技术变革了软件设计的传统方法。面向对象程序设计把数据和使用此数据的过程封装成一个类。数据的封装和隐藏一方面使得内部数据不被破坏，另一方面使程序具有良好的可读性和相对独立性。类的继承机制不仅提高了代码的可重用性，降低了软件开发难度和开发周期，同时程序的修改变得容易，软件结构更加稳定，软件的可维护性大大提高。

面向对象软件系统由类的层次结构组成，类的具体实例叫做对象，对象之间通过彼此的联系，共

同实现程序的功能。面向对象程序设计方法提出一些全新的概念：对象、类、封装、数据隐藏、继承和多态性等。多态性、数据封装和继承共同构筑了面向对象程序设计的三大机制。

封装强调的是数据和行为的自成一体性，也就是将数据和操作数据的函数代码进行有机的结合，形成“类”。类把对数据的操作信息隐藏在内部，只提供对象对外的操作接口，用户只能看见对象封装接口上的信息，这样可以保护内部数据不被破坏，同时使用者使用起来非常方便。

继承是C++语言的一种重要机制，该机制实现了对原有类进行扩充，在此基础上进行更具体、更详细的定义。通过继承，新的派生类不仅可以自动获得基类的所有成员变量和成员函数（构造函数和私有函数除外），同时可定义新的成员变量和成员函数，来满足新的软件需求，进一步完善程序设计，提高软件的重用性。

多态性是面向对象程序设计的重要特征之一。继承重点研究类与类的层次，多态则研究在不同层次的类中，同名成员函数的关系。所谓多态性就是同样的接口有不同的功能，同样的消息被不同的对象接收时产生不同的行为。C++获得多态性的方式是函数重载、运算符重载和利用虚函数来实现。利用多态性，用户能够发送一般形式的消息，而将所有的实现细节留给接收消息的对象。习题

一、阅读程序题

写出下面程序的运行结果。

#include

using namespace std;

class Clock

{

public:

void SetTime(int NewH=0, int NewM=0, int NewS=0);

void ShowTime();

private:

int Hour,Minute,Second;

};

void Clock::SetTime(int NewH, int NewM, int NewS)

{

Hour=NewH;

Minute=NewM;

Second=NewS;

}

void Clock::ShowTime()

{

cout<

}

void main()

{

Clock myClock;

cout<<"First time set and output:"<

();

();

cout<<"Second time set and output:"<

(8,30,30);

();

}

运行结果：_____________。

#include

using namespace std;

class CPU

{

private:

int frequency;

float voltage;

public:

CPU (int f, float v)

{

frequency = f;

voltage = v;

cout << "构造了一个CPU!" << endl;

}

~CPU () { cout << "析构了一个CPU!" << endl; }

int GetFrequency() const { return frequency; }

float GetVoltage() const { return voltage; }

void Run() {cout << "CPU开始运行!" << endl; }

void Stop() {cout << "CPU停止运行!" << endl; } };

void main()

{

CPU a(400,;

cout<<"frequency="<<()<<" voltage="<<()<

();

();

}

运行结果：______________。