C++语言程序设计 第四章 类与对象

本章主要内容 面向对象的思想 OOP的基本特点 类概念和声明 对象 构造函数 析构函数 内联成员函数 拷贝构造函数 类的组合

回顾：面向过程的设计方法 面向对象的思想 重点: 形式： 特点： 缺点： 如何实现细节过程，将数据与函数分开。 主模块+若干个子模块（main()+子函数）。 特点： 自顶向下，逐步求精——功能分解。 缺点： 效率低，程序的可重用性差。

面向对象的方法 面向对象的思想 目的： 观点： 程序设计方法： 要求： 实现软件设计的产业化。 自然界是由实体（对象）所组成。 使用面向对象的观点来描述模仿并处理现实问题。 要求： 高度概括、分类、和抽象。

抽象 OOP的基本特点 抽象是对具体对象（问题）进行概括，抽出这一类对象的公共性质并加以描述的过程。 先注意问题的本质及描述，其次是实现过程或细节。 数据抽象：描述某类对象的属性或状态（对象相互区别的物理量）。 代码抽象：描述某类对象的共有的行为特征或具有的功能。 抽象的实现：通过类的声明。 OOP的基本特点

抽象实例——钟表 OOP的基本特点 数据抽象： 代码抽象： int Hour, int Minute, int Second SetTime(), ShowTime()

抽象实例——钟表类 OOP的基本特点 class Clock { public: void SetTime(int NewH, int NewM, int NewS); void ShowTime(); private: int Hour,Minute,Second; };

抽象实例——人 OOP的基本特点 数据抽象： 代码抽象： char *name,char *gender,int age,int id 生物属性角度： GetCloth(), Eat(), Step(),… 社会属性角度： Work(), Promote() ,…

封装 OOP的基本特点 将抽象出的数据成员、代码成员相结合，将它们视为一个整体。 目的是曾强安全性和简化编程，使用者不必了解具体的实现细节，而只需要通过外部接口，以特定的访问权限，来使用类的成员。 实现封装：类声明中的{}

封装 OOP的基本特点 实例： class Clock { public: void SetTime(int NewH,int NewM, int NewS); void ShowTime(); private: int Hour,Minute,Second; }; 外部接口 边界 特定的访问权限

继承与派生 OOP的基本特点 是C++中支持层次分类的一种机制，允许程序员在保持原有类特性的基础上，进行更具体的说明。 实现：声明派生类——第七章

多态性 OOP的基本特点 多态：同一名称，不同的功能实现方式。 目的：达到行为标识统一，减少程序中标识符的个数。 实现：重载函数和虚函数——第八章

类与对象 类 和 对 象 定义数据的类型以及操作这些数据的函数 类的实例称为对象 类中的变量和函数称为成员

类与对象 类 和 对 象 类的声明 类成员的访问控制 类的成员函数 对象

c++中的类 类 和 对 象 类是具有相同属性和行为的一组对象的集合，它为属于该类的全部对象提供了统一的抽象描述，其内部包括属性和行为两个主要部分。 利用类可以实现数据的封装、隐藏、继承与派生。 利用类易于编写大型复杂程序，其模块化程度比C中采用函数更高。

类的声明形式 类 和 对 象 类是一种用户自定义类型，声明形式： class 类名称 { public: 公有成员（外部接口） private: 私有成员 protected: 保护型成员 } 我们以时钟为例，声明一个类来描述时钟 程序

类成员的访问控制属性 类 和 对 象 对于成员列表中所包含的数据成员和函数成员，都可通过设置成员的访问控制属性来实现对类成员访问权限的控制。每个成员都具有一定的存取权限，或称存取属性，访问属性，访问权限。 访问控制属性有三种： 公有类型（public），私有类型(private)和保护类型(protected)

公有类型成员 类 和 对 象 在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。

私有类型成员 类 和 对 象 在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。

保护类型 类 和 对 象 与private类似，其差别表现在继承与派生时对派生类的影响不同，第七章讲。

私有和公有 类 和 对 象 公有类型声明了类的外部接口，所有来自外部的访问都必须通过接口来完成。 私有类型的成员只允许本类的成员函数来访问，外界只能通 过类中提供的公有成员函数间接访问其私有成员。 因此隐藏了某些成员，使类外无法看到 private public

私有和公有 类 和 对 象 无法从类的外部访问私有数据 其他类的私有数据对于当前类也是隐藏的 类 私有 不可从类的外部访问 数据或函数 公有 可以从类的外部访问

类成员的访问控制属性 类 和 对 象 注：在类中若无显式规定其访问属性，采用隐含属性private； 一个成员只能有一种访问属性； 一般情况下，一个类的数据成员都应声明为私有成员。

类的成员 类 和 对 象 class Clock { public: void SetTime(int NewH, int NewM, int NewS); 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<<Hour<<":"<<Minute<<":"<<Second; 19

成员数据 类 和 对 象 与一般的变量声明相同，但需要将它放在类的声明体中。

成员函数 类 和 对 象 成员函数的声明 原型声明：原型声明在类的声明中，包括函数的参数表和返回值类型。 定义：即函数的具体实现，函数体。 一般在类定义之外。 返回值类型 类名 : : 函数成员名（参数表） { 函数体} 带默认值的成员函数 内联成员函数 显示声明：用关键字定义。 隐式声明： 成员函数是在类中定义的，隐含为内联。

成员函数 类 和 对 象 在类中说明原形，可以在类外给出函数体实现，并在函数名前使用类名加以限定。也可以直接在类中给出函数体，形成内联成员函数。 允许声明重载函数和带默认形参值的函数

内联成员函数 类 和 对 象 为了提高运行时的效率，对于较简单的函数可以声明为内联形式。 内联函数体中不要有复杂结构（如循环语句和switch语句）。 在类中声明内联成员函数的方式： 将函数体放在类的声明中。 使用inline关键字。

内联成员函数举例(一) 类 和 对 象 class Point { public: void Init(int initX,int initY) X=initX; Y=initY; } int GetX() {return X;} int GetY() {return Y;} private: int X,Y; };

内联成员函数举例(二) 类 和 对 象 class Point { public: void Init(int initX,int initY); int GetX()； int GetY()； private: int X,Y; };

inline void Point:: Init(int initX,int initY) { X=initX; Y=initY; } inline int Point::GetX() return X; inline int Point::GetY() return Y; 25

对象 类 和 对 象 类的对象是该类的某一特定实体，即类类型的变量。 声明形式： 类名 对象名； 例： Clock myClock;

对象 类 和 对 象 每个对象对类中的数据成员都有其自己的副本 给定类的所有对象都使用相同的成员函数 在定义每个对象时数据就会存入内存，所以每个对象都有一个数据集

对象 类 和 对 象 对象 1 数据 1 数据 2 对象 2 对象 3 成员函数1() 成员函数2()

对象 类 和 对 象 “类”类型的大小 由某类定义的对象所占用存储空间的字节数等于所有数据成员所占存储空间字节数的总和，也就是每个类对象中只保留有数据成员的存储空间，不保留有成员函数的存储空间。 问题：如何完成对象调用成员函数？

this 指针 类 和 对 象 编译器把调用成员函数的对象的地址赋给 this指针 可以像其他指向对象的指针一样使用this this -> age = 5; this -> getdata();

this的用法 class person{ private: int age; public: void display(); }; void Person::display(){ this -> age = 25; // 与age = 25一样 cout << this -> age; // 与cout << age一样 cout << endl; int main(){ Person Jack; Jack.display(); return 0; }

类中成员的访问方式 类 和 对 象 类中成员互访 类外访问 直接使用成员名 使用“对象名.成员名”方式访问 public 属性的成员 成员操作符

例4-1类的应用举例 类 和 对 象 #include<iostream> using namespace std; class Clock { ......//类的声明略 } //......类的实现略 void main(void) { Clock myClock; myClock.SetTime(8,30,30); myClock.ShowTime();

构造函数 构造函数和析构函数 对象的初始化： 在声明对象的时候进行的数据成员设置 构造函数就是用来完成对象的初始化工作的 构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。

构造函数 构造函数和析构函数 在对象创建时由系统自动调用。 如果程序中未声明，则系统自动产生出一个默认形式的构造函数 允许为内联函数、重载函数、带默认形参值的函数

构造函数的特点 构造函数和析构函数 2、由系统自动调用，只运行一次，别的成员函数无权调用； 3、存在一个缺省的构造函数； 4、可表现为多态 1、都被声明为公有成员函数，取名与类名相同，无返回值； 2、由系统自动调用，只运行一次，别的成员函数无权调用； 3、存在一个缺省的构造函数； 4、可表现为多态

构造函数 构造函数和析构函数 构造函数没有返回类型 默认构造函数是不带任何参数的构造函数 class username { public: }; username::username() { }

构造函数 4-3 多态性 构造函数和析构函数 class date{ int month, day, year; public: 构造函数 4-3 多态性 构造函数和析构函数 class date{ int month, day, year; public: date() //默认构造函数 {day=1; month=1; year=1999;} date(int x) //仅指定日 {day=x; month=1; year=1999;} date(int x, int y, int z) //指定年月日 {day=x; month=y; year=z;} };

构造函数-多态性 构造函数和析构函数 编译器根据参数调用不同的构造函数 date now; date today(4); date all(23,3,1998);

构造函数举例 构造函数和析构函数 class Clock { public: Clock (int NewH, int NewM, int NewS);//构造函数 void SetTime(int NewH, int NewM, int NewS); void ShowTime(); private: int Hour,Minute,Second; };

Clock::Clock(int NewH, int NewM, int NewS) { Hour= NewH; Minute= NewM; 构造函数的实现： Clock::Clock(int NewH, int NewM, int NewS) { Hour= NewH; Minute= NewM; Second= NewS; } 建立对象时构造函数的作用： void main() Clock c (0,0,0); //隐含调用构造函数，将初始值作为实参。 c.ShowTime(); 31

拷贝构造函数 构造函数和析构函数 拷贝构造函数是一种特殊的构造函数，其形参为本类的对象引用。 class 类名 { public : 类名（形参）；//构造函数 类名（类名 &对象名）；//拷贝构造函数 ... }； 类名:: 类名（类名 &对象名）//拷贝构造函数的实现 { 函数体 }

例4-2 拷贝构造函数举例 构造函数和析构函数 class Point { public: Point(int xx=0,int yy=0){X=xx; Y=yy;} Point(Point& p); int GetX() {return X;} int GetY() {return Y;} private: int X,Y; };

Point::Point (Point& p) { X=p.X; Y=p.Y; cout<<"拷贝构造函数被调用"<<endl; } 34

拷贝构造函数的激发条件 构造函数和析构函数 在下列情况，会调用拷贝构造函数 当用一个类的对象去初始化该类的另一个对象时； 若函数的形参是类的对象，调用函数时,将对象当作参数传递给函数时 ，用实参对象去初始化形参对象； 若函数的返回值是类的对象，函数返回对象时。

例4-2 拷贝构造函数举例 构造函数和析构函数 当用类的一个对象去初始化该类的另一个对象时系统自动调用拷贝构造函数实现拷贝赋值。 void main(void) { Point A(1,2); Point B(A); //拷贝构造函数被调用 cout<<B.GetX()<<endl; }

例4-2拷贝构造函数举例 构造函数和析构函数 若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。例如： void fun1(Point p) { cout<<p.GetX()<<endl; } void main() { Point A(1,2); fun1(A); //调用拷贝构造函数

拷贝构造函数(例4-2) 构造函数和析构函数 当函数的返回值是类对象时，系统自动调用拷贝构造函数。例如： Point fun2() { Point A(1,2); return A; //调用拷贝构造函数 } void main() { Point B; B=fun2();

拷贝构造函数 构造函数和析构函数 如果程序员没有为类声明拷贝初始化构造函数，则编译器自己生成一个拷贝构造函数。 这个构造函数执行的功能是：用作为初始值的对象的每个数据成员的值，初始化将要建立的对象的对应数据成员。

拷贝构造函数的特点 构造函数和析构函数 特征： 1、一般构造函数的特征； 2、其形参是本类对象的引用； 3、如果没有定义复制构造函数，编译器将自动生成一个，自动生成的复制构造函数只是把初始值对象的每个数据成员的值逐个字节地copy到新建立的对象中。

析构函数 构造函数和析构函数 完成对象被删除前的一些清理工作。 在对象的生存期结束的时刻系统自动调用它，然后再释放此对象所属的空间。 如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。

析构函数 构造函数和析构函数 在对象销毁时自动调用的成员函数 编译器会生成对析构函数的调用 与类同名，但是在函数名前有个波浪号 (~) 析构函数没有返回类型，也不带参数 class username { public: ~username(); //析构函数 };

构造函数和析构函数举例 构造函数和析构函数 #include<iostream> using namespace std; class Point { public: Point(int xx,int yy); ~Point(); //...其它函数原形 private: int X,int Y; };

Point::Point(int xx,int yy) { X=xx; Y=yy; } Point::~Point() { //...其它函数的实现略 41

类的应用举例(例4-3) 一圆型游泳池如图所示，现在需在其周围建一圆型过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。过道宽度为3米，游泳池半径由键盘输入。要求编程计算并输出过道和栅栏的造价。 游泳池 过道

#include <iostream> using namespace std; const float PI = 3.14159; const float FencePrice = 35; const float ConcretePrice = 20; //声明类Circle 及其数据和方法 class Circle { private: float radius; public: Circle(float r); //构造函数 float Circumference() const; //圆周长 float Area() const; //圆面积 }; 43

Circle::Circle(float r) {radius=r} // 计算圆的周长 // 类的实现 // 构造函数初始化数据成员radius Circle::Circle(float r) {radius=r} // 计算圆的周长 float Circle::Circumference() const { return 2 * PI * radius; } // 计算圆的面积 float Circle::Area() const return PI * radius * radius; 44

float FenceCost, ConcreteCost; // 提示用户输入半径 void main () { float radius; float FenceCost, ConcreteCost; // 提示用户输入半径 cout<<"Enter the radius of the pool: "; cin>>radius; // 声明 Circle 对象 Circle Pool(radius); Circle PoolRim(radius + 3); 45

FenceCost = PoolRim.Circumference() * FencePrice; // 计算栅栏造价并输出 FenceCost = PoolRim.Circumference() * FencePrice; cout << "Fencing Cost is ￥" << FenceCost << endl; // 计算过道造价并输出 ConcreteCost = (PoolRim.Area() - Pool.Area())*ConcretePrice; cout << "Concrete Cost is ￥" << ConcreteCost << endl; } 运行结果 Enter the radius of the pool: 10 Fencing Cost is ￥2858.85 Concrete Cost is ￥4335.39 46

作用域解析操作符 使用作用域解析操作符(::)在类外定义成员函数 作用域操作符左侧是类名 将函数标识为特定类的成员 在全局与局部变量同名的情况下引用全局变量 ::global_variable

其他说明 new 和delete 运算符 对象数组 对象指针

组合的概念 类 的 组 合 类中的成员数据是另一个类的对象。它们之间的关系是一种包含与被包含的关系。 可以在已有的抽象的基础上实现更复杂的抽象。

举例 类 的 组 合 class Point { private: float x,y; //点的坐标 public: Point(float h,float v); //构造函数 float GetX(void); //取X坐标 float GetY(void); //取Y坐标 void Draw(void); //在(x,y)处画点 }; //...函数的实现略

Line(Point a,Point b); //构造函数 Void Draw(void); //画出线段 }; //...函数的实现略 class Line { private: Point p1,p2; //线段的两个端点 public: Line(Point a,Point b); //构造函数 Void Draw(void); //画出线段 }; //...函数的实现略 49

问题：如何对组合类进行初始化？ 类 的 组 合 当创建组合类的对象时，各个内嵌对象也将被自动创建；因此，在创建对象时既要对本类的基本数据成员进行初始化，又要对本类的内嵌对象成员进行初始化。

类组合的构造函数设计 类 的 组 合 原则：不仅要负责对本类中的基本类型成员数据赋初值，也要对对象成员初始化。 声明形式： 类名::类名(对象成员所需的形参，本类成员形参) ：对象1(参数)，对象2(参数)，...... { 本类初始化 }

3、执行函数体，对本类基本数据成员进行初始化。 注：1、内嵌对象初始化的顺序，依在组合类的声明中出现的顺序而定 。 class C { Clock cc; Point p; int x; int y; public: C( ); … } C::C( ): cc , p {…} main( ) { C C1;……} 初始化顺序： 1、调用clock类的构造函数。 2、调用point类的构造函数。 3、执行函数体，对本类基本数据成员进行初始化。 注：1、内嵌对象初始化的顺序，依在组合类的声明中出现的顺序而定 。 2、若声明组合类的对象时没有指定对象的初始值，则自动调用无形参的构造函数，相应也调用内嵌对象的无形参的构造函数。

类组合的构造函数调用 类 的 组 合 构造函数的调用顺序为： 1、先按照内嵌对象在组合类的声明中出现的次序，先声明者先构造，依次调用内嵌对象本类的构造函数。（析构函数的调用顺序相反） 2、然后调用本类的构造函数。执行本类构造函数的函数体. 若调用默认构造函数（即无形参的），则内嵌对象的初始化也将调用相应的默认构造函数。

类的组合举例（二） 类 的 组 合 class Part //部件类 { public: Part(); Part(int i); void Print(); private: int val; };

Whole(int i,int j,int k); ~Whole(); void Print(); private: Part one; class Whole { public: Whole(); Whole(int i,int j,int k); ~Whole(); void Print(); private: Part one; Part two; int date; }; 53

Whole::Whole(int i,int j,int k): two(i),one(j),date(k) {} //...其它函数的实现略 54

前向引用声明 类 的 组 合 类应该先声明，后使用 如果需要在某个类的声明之前，引用该类，则应进行前向引用声明。 前向引用声明只为程序引入一个标识符，但具体声明在其它地方。

前向引用声明举例 类 的 组 合 class B; //前向引用声明 class A { public: void f(B b); }; void g(A a);

前向引用声明注意事项 类 的 组 合 使用前向引用声明虽然可以解决一些问题，但它并不是万能的。需要注意的是，尽管使用了前向引用声明，但是在提供一个完整的类声明之前，不能声明该类的对象，也不能在内联成员函数中使用该类的对象。请看下面的程序段： class Fred; //前向引用声明 class Barney { Fred x; //错误：类Fred的声明尚不完善 }; class Fred { Barney y;

前向引用声明注意事项 类 的 组 合 class Fred; //前向引用声明 class Barney { public: void method() { x->yabbaDabbaDo(); //错误：Fred类的对象在定义之前被使用 } private: Fred* x; //正确，经过前向引用声明，可以声明Fred类的对象指针 }; class Fred { void yabbaDabbaDo(); Barney* y;

前向引用声明注意事项 类 的 组 合 应该记住：当你使用前向引用声明时，你只能使用被声明的符号，而不能涉及类的任何细节。

UML简介 UML图形标识 UML语言是一种可视化的的面向对象建模语言。 UML有三个基本的部分 事物（Things） UML中重要的组成部分，在模型中属于最静态的部分，代表概念上的或物理上的元素 关系（Relationships） 关系把事物紧密联系在一起 图（Diagrams） 图是很多有相互相关的事物的组

UML中有4种类型的事物 UML图形标识 结构事物（Structural things） 动作事物（Behavioral things） 分组事物（Grouping things） 注释事物（Annotational things）

UML中的关系 UML图形标识 依赖（Dependencies） 关联（Association） 泛化（generalization） 实现（realuzation）

UML中的9种图 UML图形标识 类图（class diagram） 对象图（class diagram） 用例图（Use case diagram） 顺序图（Sequence diagram） 协作图（Collaboration diagram） 状态图（Statechart diagram） 活动图（Activity diagram） 组件图（Compomnent diagram） 实施图（Deployment diagram）

类图 UML图形标识 举例：Clock类的完整表示 Clock类的简洁表示 Clock - Hour : int - Minute : int - Second : int + ShowTime() : void + SetTime(NewH : int = 0, NewM : int = 0, NewS : int = 0) : void Clock

对象图 UML图形标识 myClock : Clock - Hour : int - Minute : int - Second : int

类与对象关系的图形标识 UML图形标识 依赖关系 图中的“类A”是源，“类B”是目标，表示“类A”使用了“类B”，或称“类A”依赖“类B”

类与对象关系的图形标识 UML图形标识 作用关系——关联 图中的“重数A”决定了类B的每个对象与类A的多少个对象发生作用，同样“重数B”决定了类A的每个对象与类B的多少个对象发生作用。 类 A 重数A 类 B 重数B

类与对象关系的图形标识 UML图形标识 包含关系——聚集和组合 类 A 类 B 重数A 重数B 聚集表示类之间的关系是整体与部分的关系，“包含”、“组成”、“分为……部分”等都是聚集关系。

类与对象关系的图形标识 UML图形标识 继承关系——泛化 父类 A 父类 B 子类 1 子类 2

注释 UML图形标识 在UML图形上，注释表示为带有褶角的矩形，然后用虚线连接到UML的其他元素上，它是一种用于在图中附加文字注释的机制。 注释文字