《C++面向对象设计》(黑白-用于打印输出).doc

资料内容仅供您学习参考，如有不当或者侵权，请联系改正或者删除。

第一章 引论
1.1 系统的复杂性
面向对象设计方法
1.2 系统分析和设计方法
1.3 面向对象设计方法的特点
1.4 面向对象设计方法的应用
1.5 本课程的内容
土木工程系计算机应用研究室
马智亮

1
3
5
2
1.1 系统的复杂性
·硬件系统: 微机CPU
·软件系统
早期: 运算速度和内存容量等硬件限制
60-70年代:
推出时间 运算速度 晶体管数
8080
1974
1987
1989
1993

-
3万
硬件性能价格比改进
高级语言的出现
80386
3-5 MIPS 28万
80486
-
-
100万
310万
Ö10万句
Pentium
Pentium4
Ö1000句/人月 => 8人年!
3000 MIPS -
复杂性
4
注意: 复杂系统往往十分重要!
e.g. 全球飞机订票系统
铁路车辆调度系统
• 关于系统分析和设计方法的误区
我足够聪明, 不需要方法指导
–不能有效地进行大型软件的开发
”散兵游勇”, ”手工作坊式”
–不能有效地借鉴和利用别人的经验
”低水平重复”
股票交易管理系统
社会影响 重建代价
先进而可靠的系统分析和设计方法!
–不能很好地与软件开发商合作
”小农经济, 自给自足”
6
1

1.2 系统分析和设计方法
一方法分类
软件工程
• 软件工程的角度
生命周期法(LC)
原型法(PR)
• 程序构成的角度: 程序=算法+数据结构
面向功能(FO)
面向数据(DO)
将软件作为一个工程产品来对待。
功能, 过程
– 需要经过规划、 分析、 设计、 实现等过程
-> 生命周期法
或
– 需要经过小规模实验、 正式投产等过程
-> 原型法
面向对象(OO)
7
8
生命周期法
原型法
将软件的生命周期划分为几个阶段, 对每个
阶段的成果复审经过后才进入下一阶段
首先建立原型, 在不断充实原型的基础上形
成最终系统
规划
=> 项目实施计划
1)确定用户基本需求;
需求分析 => 系统需求说明及用户手册
2)开发初始原型;
设计
编程
测试
维护
=> 设计说明及调试计划
=> 程序代码
3)运行原型, 让用户提改进意见;
4)修改完善原型;
=> 测试报告
5)若未形成最终系统, 转 3)。
=> 维护报告
9
10
二 常见设计方法
• 常见设计方法的类属
需求分析和设计是系统开发中最重要的阶段
分析方法和设计方法总是联系在一起的
-> 分析和设计方法简称为设计方法
面向功能FO 面向数据DO 面向对象OO
生命周期法LC
原型法PR
LC-FO
PR-FO
LC-DO
PR-DO
LC-OO
PR-OO
当前比较流行的设计方法有:
自顶向下结构化设计方法
数据驱动设计方法
自顶向下结构化设计方法
数据驱动设计方法
面向对象设计方法
面向对象设计方法: 新兴的～
11
12
2

三 自顶向下结构化设计方法
基本思想
e.g. 报表制作
报表制作
计算
1) 将功能逐步分解划分为模块
2) 让模块间形成层次
输入数据
打印报表
3) 将程序结构限制为顺序、 选择和循环
读入编辑检查
印表头印表体
打印
13
14
四数据驱动设计方法
·又称Jackson方法
e.g.报表制作
文件
记录
处理文件
处理记录
·基本思想:
强调问题的组合, 使程序结构与问题结构
( 即数据结构) 相对应。
数据项1数据项2
数据项3
处理
处理
处理
数据项1
数据项2
数据项3
15
16
五面向对象设计方法
基本思想:
e.g.报表制作
1.打印报表
2.印刷
1) 经过识别对象和类来分解问题领域, 尽量
让对象和类对应于现实中的事物;
控制台
报表
2) 建立类之间的相互关系: e.g.继承关系;
3.生成
4.生成
表头
3) 以类为模板生成对象, 让对象协同工作去
实现系统的具体功能。
5.打印
表体
6.打印
印刷器
17
18
3

1.3 面向对象设计方法的特点
六常见设计方法比较
一优点
·适用范围
1) 充分利用面向对象语言的表现力
数据驱动设计方法不适于大型系统开发
·与高级语言的关系
2) 系统结构对应于现实生活, 系统结构相
对稳定
3) 系统结构自然, 便于理解和交流, 可维护
性和可扩充性好
自顶向下结构化～: FORTRAN, COBOL, C
面向对象～: Smalltalk, C++, Java
·混合使用的可能性
-> 适用于开发大型和复杂系统
总体: 无 局部: 有
19
21
23
20
1.4 面向对象设计方法的应用
二 缺点
·系统类型
单机系统
1)系统执行速度比较慢
基于C/S( 客户/服务器) 结构的系统
基于B/S( 浏览器/服务器) 结构的系统
2)初始成本高
设计方法学习: 几周 -> 实践: 几个月
三 能否取代传统设计方法?
系统代码数在10万句以下时,
与自顶向下结构化方法差别不大;
系统代码数在10万句以上时, 推荐使用
·系统应用领域
几乎覆盖所有的领域:
操作系统, 文档处理, 图象识别, 用户界
面, 专家系统CAD, CAI 等
22
1.5 本课程的内容和要求
• 我们用它来做什么?
–从事系统的开发
Chp.2 对象模型
模型
语言
Chp.3 编程语言C++
e.g. 利用面向对象语言进行大型系统开发
e.g. 利用Autodesk ObjectARX的二次开发
–从事大型系统的开发管理
与开发商进行更有效的沟通
–作为一种通用的解决问题的方式
e.g. 管理大型工程项目
设计原理
Chp.4 面向对象设计原理
表示方法
Chp.5 标准建模语言UML
Chp.6 统一的软件开发过程
实施步骤
24
4

作业1
• 教学要求的基本考虑
1. 请参考有关文献, 归纳程序设计语言的发展过
程及趋势。要求:
作为研究生的课来要求
–要注明文献的出处
–不合格者需要重做
– 9月22日( 周四) 提交
–无教科书, 指定参考文献
–需要主动去查找并阅读相关文献
–需要阅读一定的外文资料
–需要做大作业( Project)
结合课程进展分步提交, 完善后最终提交
提示: 能够上网检索有关刊物, 或浏览有关
的网页。
25
26
5

第二章 对象模型
2.1 概述
2.1 概述
一 回顾
2.2 对象和类
2.3 抽象原则
2.4 封装原则
2.5 模块原则
2.6 层次原则
2.7 其它原则
面向对象设计方法的基本思想
与自顶向下结构化设计方法相比
不同的角度:
把问题领域分解为对象和类 = 识别对象和类
什么是对象和类? 如何分解? 如何系统化?
1
3
5
2
二 对象模型的概念
对象模型
模型: 原系统的简化系统
抽象原则
类型原则
～ : 反映进行问题领域分解及系统化的基本
原则, 是面向对象设计方法的工程基础。
封装原则
平行原则
层次原则
持久原则
模块原则
由一些原则组成:
主要: 抽象、 封装、 模块、 层次
非主要: 类型、 平行、 持久
4
2.2 对象和类
关于原则的注意点
一 对象的概念
• 形成概念框架
• 描述性定义
这些原则本身并不新, 只是在面向对象设计
方法中被集成在一起
对象是用面向对象设计方法构造系统时所使
用的基本要素。这里限于考虑软件系统。
• 主要原则构成判别准则
• 形象化说法
只有在系统设计中使用了全部的主要原则,
才属于面向对象设计
对象是用面向对象设计方法构筑软件系统时
所使用的基本材料
<->自顶向下结构化设计方法?
6
1

• 可作为对象的事物
现实生活中有关的事物均能够成为对象
e.g.报表制作
1.打印报表
2.印刷
–看得见、 摸得着的～
控制台
e.g.桌子、 椅子、 教室、 电灯、 温度计、 文档
–可被人领悟的～
报表
3.生成
表头
4.生成
e.g.弯矩、 座位、 买卖交易、 交通事故
–思想和行动有所指向的～
5.打印
表体
e.g.技术员、 医生、 顾客、 债权人
6.打印
印刷器
7
8
• 对象的特性
二类的概念
任何对象都可被唯一地识别并具有属性和行
为。
e.g. 温度计对象
识别: 区分不同的对象, e.g. m1, m2
属性: 测温范围、 当前温度
值的变化反映对象状态的变化
行为: 测温、 校准
• 描述性定义
用来规定相似对象的共同特征、 并用来生成
对象的系统要素。对象都需要从类来生成。
e.g. 温度计类
• 形象化说法
类是对象的模板、 对象是类的实例
使用对象需要先定义类
反映为其它对象或外部提供的服务
9
10
typedef float Temperature;
typedef unsigned int Location;
class TemperatureSensor{
public:
三用C++语言表示类和对象
e.g. ”温度计”类
类的定义和使用类似于C语言中的结构体
•用数据成员表示属性
TemperatureSensor(Location); // 构造函数
~TemperatureSensor(); // 析构函数
void calibrate(Temperature actualTemperature);
Temperature currentTemperature();
•用成员函数表示行为
private:
•构造函数: 生成对象时被自动执行的函数
•析构函数: 对象消亡时被自动执行的函数
Temperature TemperatureRangeHigh;
Temperature TemperatureRangeLow;
Temperature currentTemp;
};
11
12
2

2.3 抽象原则
e.g. 生成温度计对象
一基本内容
TemperatureSensor theSensor1(1);
体会: 模板
应用抽象方法: 舍弃事物个别的、 非本质的
特征, 抽取共同的、 本质的特征。
e.g.
e.g. 对象的使用
Temperature Temp;
图书馆、 教室、 研究室…
桌子、 椅子、 连为一体的桌椅…
红色的、 黄色的、 白色的…
座位
Temp=theSensor1.currentTemperature();
讨论: 软件系统中的温度计和实物温度计的关
系是什么?
13
14
确定对象和类的过程中
二 确定对象和类
有时不能简单确定对应于实际事物的对象和类
而需要根据更高层次的抽象来确定
e.g. The Mark IV Special Coffee Maker
开始: Boiler, Warmer, BrewButton, RelieveValve,
Indicator
首先应用的原则! 常常做的事:
• 系统中的对象 <- 现实世界中的事物
• 类 <- 对象
• 属性 <- 事物的特征
• 行为 <- 事物的特征
后来: Sprayer, Warmer, UI
详见网上英文资料
特别说明: 抽象相对于观察者的视点而存在
同一系统, 不同设计者也可能采用不同的抽象
15
16
RelieveValve
Boiler
三 建立对象的界面
• 对象的界面代表对象的外部特征, 包含对象
的行为:
–对象能做什么: 承担的责任
–对象如何使用: 对外部( 对象) 所做的约定
Warmer
• 相对于对象的实现
• 应用抽象原则来确定
BrewButton
Indicator
17
18
3

四程序实现: C++语言
五 应用例
在类的public部分表示对象的界面
水溶液植物农场
植物种在培养棚内的水溶液中
培养环境因素: 温度、 湿度、 浓度、 光照等
-> 用自动化系统来监控
如何对该软件系统进行设计?
识别对象和类
-> 建立对象的界面
19
21
23
20
回调函数
class ActiveTemperatureSensor{
public:
• 温度计类
系统中的温度计: 对实际温度计进行控制
–被动式温度计
ActiveTemperatureSensor(Location, void
(*f)(Location, Temperature));
~ ActiveTemperatureSensor();
如前例: 可进行校准, 可报告温度
<=> 被动对象
void calibrate(Temperature actualTemperature);
void establishSetpoint(Temperature setpoint,
Temperature delta);
–主动式温度计
Temperature currentTemperature();
温度>规定度数 -> 启动空调机
<=> 主动对象
private:
…
}
22
2.4 封装原则
• 讨论
一基本内容
–在该例中, ”对象的界面”是如何体现的?
利用信息隐藏的办法, 将对象的实现与对象
的界面分离开来, 使外部( 对象) 只能经过
对象的界面来利用对象的服务。
所承担的责任: 校准、 测温成员函数
对外部的约定: 成员函数的参数表
–观察者的视点有何不同?
实现问题的离散化。即, 如果只改变对象的
实现方法, 并不会影响到利用它的服务的外
部( 对象, 即客户对象) 。
采用被动对象时, 需要用其它对象与之
配合, 实现对温度的控制
24
4

一般封装 e.g.: 记数器
客户对象 <=> 服务器对象
访问者和被访问者: 被服务和服务关系
归零
记数
–服务器对象所提供的服务均体现在界面上,
界面同时反映了对客户对象的约定
读数
–服务器对象的实现细节均被封装起来
当前数
对象的实现:
机械式? 电子式?
25
26
二 对象封装的确定
和抽象相对
三程序实现: C++语言
经过protected和private以及文件的形式来组
织代码
将对象的实现封装起来, 包括
•对象的属性
–定义类时
将类的数据成员及表现内部行为的成员函数放在
类定义的private或protected部分;
•对象的界面的实现
•实现对象的界面过程中用到的内部行为
–实现类时
将成员函数的实现放在不同的文件中。
27
28
1/3
//gplan.h
四 应用例
typedef unsigned int Day;
typedef unsigned int Hour;
enum Light{OFF, ON};
typedef float Concentration;
struct Condition{
Temperature temperature;
Light lighting;
PH acidity;
水溶液植物农场: 植物培育计划类
–抽象: 建立培育计划, 清除培育计划, 报告培育
计划等行为
–封装: 包括
有关的属性( 数据)
”时间: 环境因素的状态 ”关系
封装
Concentration concentration;
};
对象行为实现: 基于属性的
29
30
5

2/3
3/3
class GrowingPlan{
public:
//gplan.cpp
#include "plan.h"
GrowingPlan(char* name);
virtual ~GrowingPlan();
void clear();
GrowingPlan::GrowingPlan(char* name){
...
}
virtual void establish(Day, Hour, const
Condition&);
virtual GrowingPlan::~GrowingPlan() {
...
const Condition& desiredCondition(Day, Hour);
}
protected:
const Condition& desiredCondition(Day, Hour){
Condition conditionArray[10000];
...
}
...
…
};
31
32
class homeStereoSystem{
public:
PlayCD(const CD& theCD);
private:
Speaker itsSpeaker[2];
Turner itsTurner;
家庭音响系统: 家庭音响类
•抽象: 播放CD
•封装: 作为组成要素
控制面板、 功放器、 喇叭等对象
TurnTable itsTurnTable;
CDPlayer itsCDPlayer;
CassetteDeck itsCassetteDeck;
Amplifier itsAmplifier;
};
33
34
2.5 模块原则
一 基本内容
二 模块的确定
将类组合成一系列内聚力强、 耦合力弱且可
操作的模块去构成复杂系统。
• 模块结构简单、 易懂 -> 独立设计、 修改
• 模块界面稳定 -> 修改一个模块的实现时不
至于影响别的模块
–模块内的各个类关联紧密: 逻辑上
–模块间联系松散
• 模块内容相对完整、 独立 -> 程序的重用
• 考虑非技术因素: 分工、 保密等
–模块的大小适中
模块也有界面和实现
简化问题, 便于分工进行系统开发
35
36
6

三程序实现: C++语言
四 应用例
C++语言中未直接提供支持模块的机制,
可使用文件的形式来组织模块
水溶液植物农场
•有关培育计划的类形成模块
•有关控制培育计划执行的类形成模块
•有关图形用户界面类形成的模块
•...
37
38
//培育计划模块界面(gplan.h)
#include "gtypes.h"
//培育计划模块实现(gplan.cpp)
#include "gplan.h"
#include "except.h"
#include "actions.h"
class GrowingPlan{…};
GrowingPlan::GrowingPlan(char* name){…}
virtual GrowingPlan:: ~GrowingPlan{…}
…
class FruitGrowingPlan{…};
class GrainGrowingPlan{…};
…
关联紧密的
各个类的定义
//相当于C语言程序的.c文件
类成员函
数的实现
//相当于C语言程序的头文件
39
40
2.6 层次原则
讨论
一 基本内容
• 有关控制培育计划执行的类形成的模块界面
至少应包含什么?
经过对类和对象进行等级划分来形成层次结
构, 以简化对事物的理解。
– gplan.h
包括
–有关图形用户界面类形成的模块界面
• 如何经过模块实现程序的重用?
–类层次结构
–对象层次结构
–按照一定的方式来组织模块结构
41
42
7

二类层次结构
• 特性
• 定义
继承性: 子类能够继承父类的特性
对于类A和类B, 若满足: B是一种A( 特殊/
一般关系) , 则称: A是B的父类, B是A的
子类; 又称为一般/特殊结构。
程序代码的共享 -> 表示的经济性
• 分类
e.g. 微机: 计算机
–单继承: 一个子类只拥有一个父类
–多继承: 一个子类拥有一个以上的父类
43
45
47
44
• e.g. 水溶液植物农场: 单继承
要建立水果培育计划的类
class GrowingPlan{
public:
//前面给出过
•选取GrowingPlan作为父类
父类表现子类所共享的属性和行为
GrowingPlan(char* name);
virtual ~GrowingPlan();
void clear();
e.g. FruitGrowingPlan, VegetableGrowingPlan,
FlowerGrowingPlan等类
virtual void establish(Day, Hour, const
Condition&);
均需要clear等行为
const Condition& desiredCondition(Day, Hour);
protected:
•子类对父类提供的行为进行具体化或扩充
Condition conditionArray[10000];
…
};
e.g. 函数estimateYield
46
typedef unsigned int Yield;
class FruitGrowingPlan : public GrowingPlan{
public:
• e.g. 水溶液植物农场: 多继承
要建立苹果类
FruitGrowingPlan(char* name);
virtual ~FruitGrowingPlan();
virtual establish(Day, Hour, Condition&);
Boolean isHarvested() const;
unsigned dayUntilHarvest() const;
Yield estimateYield() const;
protected:
既是一种水果, 又是一种花
class apple : public Flower, public Fruit{
…
};
Boolean repHarvested;
Yield repYield;
问题: 重复继承?
};
48
8

1/2
2/2
class FlowerMixin{
class FruitMixin{
public:
public:
FlowerMixin(Day timeToFlower,
Day timeToSeed);
virtual ~FlowerMixin();
Day timeToFlower() const;
Day timeToSeed() const;
protected:
…
};
FruitMixin(Day timeToHarvest);
virtual ~FruitMixin();
Day timeToHarvest() const;
protected:
…
};
独立地表示被继
承类的一些独特
操作和属性
class apple : public Plant, public FlowerMixin,
public FruitMixin{
…
};
49
50
三对象层次结构
• 特性
• 定义
形成较高层次的对象和类
对于类A和类B, 若满足: A的对象中包含有
B的对象, 则称A与B形成对象层次关系; 又
称为聚合结构, A的对象为聚合对象, B的
对象为被聚合对象。
简化对事物的理解
• 分类: 聚合对象和被聚合对象之间
–物理包含: 同生同灭
–非物理包含: 互为参照关系
51
52
2.7 其它原则
一类型原则
• e.g. 花园类
能够对类进行强制, 使不同类的对象不可互
换, 或至多以有限的方式互换。
class Garden{
public:
Garden();
virtual ~Garden();
protected:
Plant * repPlants;
GrowingPlan repPlan;
};
• 实现方法
一般经过语言来实现
与语言类型有关: 强类型～、 弱类型～
强类型语言: 强制严格, 在编译时可检出是
否违反。
53
54
9

• e.g.有限的互换
二并行原则
GrowingPlan a("ABC"), b(" FG");
FruitGrowingPlan c("LMN");
a=b;
能够使多个对象同时拥有线程。
线程: 不需外部触发、 独立地运行的任务
a=c;
区分主动对象和被动对象: 拥有线程的对象
为主动对象
c=a; //C++语言(X)
e.g. 主动式温度计
控制台对象与温度计对象同时被激活
55
56
• 实现方法
三 持久原则
–利用语言提供的功能
–利用库存类 C++: Sched, Timer, Task
能够使对象具有持久性。
• 数据按持久性分类
–利用系统中断功能: 周期性地中断应用程
序: 看起来像多线程
–对表示式求值后得到的数据
–计算过程中的局部变量
–不同执行模块间存在的数据
–程序的不同版本间存在的数据
–程序之外存在的数据
临时数据
持久数据
57
58
作业2
• 持久数据的处理方法
请查阅有关文献, 归纳对象模型所包含的主要
原则的起源、 发展及其与编程语言的关系。
使用数据文件或数据库
要求:
面向对象数据库 <=> 关系数据库
–对象的存在从内存扩展到外存
–要注明文献的出处
–不合格者需要重做
– 10月13日交
–主要由于价格因素还未得到广泛应用
59
60
10

请开始做大作业( 另附)
61
11

3.1概述
第三章面向对象编程语言C++
一 C++语言的发展
·C语言: 70年代初, 为构筑UNIX
•运算符丰富
•数据结构柔软
•直接访问物理地址
•目标代码质量高
3.1概述
3.2对C语言格式上的改进点
3.3封装性
3.4友元函数和友元类
3.5继承性
3.6多态性
•可移植性好
-> 系统软件、 应用软件
1
3
5
2
4
6
• 开发动机: 与C语言成一体系, 与C语言
独立存在, 事件驱动的仿真语言
• 编译器
–1985
• 发展过程
AT&T 1.0版编译器
–现在
Simula 67
C
Agol-68
Microsoft Visual C++ .NET
( 前一版本6.0)
Borland C++ Builder 6 Studio
特点: 集成开发环境( IDE)
CwithClasses
C++
1983
仿真语言Simula 67: 类和继承
算法结构语言Agol-68: 多态性
3.2对C语言格式上的改进点
二 C++语言的好处
• C语言的超集
-> 利用C语言的积累, 便于学习
• 普遍采用的面向对象语言
三 学习前提
• 已掌握了C语言, 否则请自学
• 本章只讲述相对于C语言的主要增量部分
• 目的是帮助大家理解程序
一 常量的定义
C++: const double PI=3.141592;
PI=2.1;
//(X)
C: #define PI 3.141592
1

二 变量的定义
三 结构体变量的定义
C++: 可在函数的任意部分定义
-> 方便变量的增加
C++: 定义结构体变量时可省去”struct”
struct emp{
char* name;
int salary;
};
#include <stdio.h>
void main (){
int s=0;
for (int j=1; j<=50; j++)
s=s+j;
printf (”s=%d\n”, s);
}
emp engineer;
7
8
e.g. 用参照型实现函数参照调用( <-> C指针)
四 参照型( 引用)
#include <stdio.h>
• 为实体定义别名。
void add10(int& i){
• 格式: 类型名& 变量名=表示式;
i = i + 10;
}
main(){
int size=512;
int k=1;
add10(k);
printf(”k=%d\n”, k);
}
int& refSize=size;
// refSize和size代表同一实体
9
10
五 数据类型转换
六 注释
C++:数据类型( 表示式) ;
C++: int x=186; //x holds an integer value
e.g. x=float(j);
C: int x=186; /*x holds an integer value */
C: ( 数据类型) 表示式;
e.g. x=(float)j;
11
12
2

七 输入输出
八 内存的动态分配和释放
( 流输入输出)
int* spt=new int[15];
delete [] spt;
#include <iostream.h>
#include <stdio.h>
main(){
float x;
scanf(”%f”, &x);
printf(”x=%f\n”, x);
}
main(){
float x;
cin >> x;
cout << ”x=” << x <<
int* spt=malloc(60);
free(spt);
”\n”;
}
13
14
16
18
3.3封装性
一 类的定义
说明
1) 区分数据成员和成员函数的访问特性
private: 只能在类内被访问
protected: 只能在类内或其子类内被访问
public: 可在任意处被访问
class 类名{
说明部分
public:
数据成员及成员函数
实现部分
protected:
数据成员及成员函数
private:
类名::成员函数名(){
2) 结构体被扩展, 具有与类相同功能
不同点: 缺省访问特性
数据成员及成员函数
…
}
};
类为private <-> 结构体为public
15
二 简单例程序
int Set::isMember(int ex){
for (int j=0; j<nelem; j++)
if (elem[j]==ex)
return 1;
#include <iostream.h>
class Set{
编译预处理
private:
return 0;
int elem[1000];
int nelem;
}
类的实现部分
<->连同private
部分:
void Set::putElem(int ee, int
ps){
public:
类的说明部分
<-> public:
对象的界面
if (ps<=0 && ps<1000){
Set(){nelem=0;}
int Nelem(){return nelem;}
int isMember(int);
void putElem(int, int);
};
elem[ps]=ee;
对象的实现
if (ps> nelem)
nelem=ps;
}
}
iset.cpp
iset.h
17
3

void main(){
说明
Set ss;
for (int j=0; j<10; ++j)
ss.putElem(j+600, j);
cout << ”Nelem()=” << ss.Nelem() << ”\n”;
cout << ss.isMember(601) << ” ”;
cout << ss.isMember(609) << ” ”;
cout << ss.isMember(610) << ”\n”;
}
1) 文件组织: 习惯上3个文件
·iset.h
预编译及类的说明部分
#include ”iset.h”
类的实现部分
#include ”iset.h”
主函数
主函数
对象的定义
·iset.cpp
·main.cpp
Nelem()=10
1 1 0
main.cpp
19
20
2) 利用对象和类作为构成程序的基本要素
三 构造和析构函数
3) 封装性( 数据封装) : 将数据放在private或
protected部分, 使外部不能直接访问, 外部
对数据的访问需经过 public部分定义的成员
函数来进行; 对象的实现与对象的界面分开
特殊的成员函数: 构造函数与类同名, 析构
函数在类名前加~
• 构造函数: 生成对象时被自动执行, 用于进
行对象的初始化, 一般在其中动态分配内存
4) 内联函数: <->外联函数
• 析构函数: 对象消亡时被自动执行, 进行对
象的内存清理工作, 一般在其中释放内存
好处: 省去调用过程 -> 提高执行速度
缺点: 未封装 -> 简单函数
• 缺省的构造函数和析构函数: 函数体是空的
21
22
2/2
1/2
#include <iostream.h>
#include ”tdate.h”
void main(){
Tdate today( , 9, 22), tomorrow( , 9, 23);
cout << ”Today is ”;
today.Print();
//tdate.h
month = m;
day = d;
class Tdate{
public:
cout << ”CON called.\n”;
Tdate(int y, int m, int d);
~ Tdate();
}
TDate:: ~ Tdate(){
cout << ”DES called.\n”;
}
void TDate::Print(){
cout << year << ”.” <<
month << ”.” << day
<<endl;
void Print()
private:
CON called