第3章 类和对象课件

类的成员函数定义
※带默认形参值的成员函数

class Clock { public: void setTime(int newH=0, int newM=0, int newS=0) { cout<<hour<<":"<<minute<<":"<<second; } ...... }
※内联பைடு நூலகம்员函数
※如果用户不显示定义类的析构函数，则系统为各个类 生成一个隐含的默认析构函数

该函数并非什么都不做，而是完成成员变量内存释放和 回收
※注意：类成员数据中动态申请的内存在析构函数中释 放！
类的更多例子（构造和析构函数）
※例1—Clock完整实例 ※例2 --基于动态内存分配

Pointer Matrix的三种实现


※protected

类的成员函数的定义
※类的声明外的成员函数定义

返回值类 类名::函数成员名(参数列表) { 函数体 }
void Clock :: setTime(int newHour, int newMinute, int newSecond) { hour = newHour; //类内直接使用私有成员 minute = newMinute; second = newSecond; } void Clock :: showTime() { cout<<hour<<":"<<minute<<":"<<second; }
复制构造函数实例
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: Point::Point (Point& p) { int X,Y; }; X=p.X; Y=p.Y; cout<<"拷贝构造函数"<<endl; } int main() { Point A(1,2); Point B(A); //调用拷贝构造函数 }
数据抽象
某类对象共有的属性或 状态
行为抽象
某类对象共有的行为特 征或功能
面向对象的基本特征 抽象实例—时钟
数据抽象 类：表 class：Clock
时、分、秒 • int hour • int minute • int second
行为抽象
显示时间、设置时间

showTime() setTime()

复制构造函数
※
为什么参数是引用类型？
※ 不用对象：避免复制过程 ※ 不用对象：避免循环引用 ※ 不用指针：传参数、返回值、直接赋值有问题
析构函数
※析构函数用来完成对象销毁前的清理工作，对象生命 周期结束前由系统自动调用 ※ ~，无参数： ~类名(){......}
class Clock { public: Clock();//构造函数 ~Clock();//析构函数 ...... }
对象
※this指针

指向本对象的指针
void Clock::setTime(int newHour, int newMinute, int newSecond) { this->hour = newHour; this->minute = newMinute; this->second = newSecond; } void Clock::setTime(int hour, int minute, int second) { this->hour = hour; this->minute = minute; this->second = second; }
※例3

浅拷贝vs.深拷贝
class Rect { public: Rect() { // 构造函数，p指向堆中分配的一空间 p = new int(100); } ~Rect() { // 析构函数，释放动态分配的空间 if(p != NULL) { delete p; } } int main() { Rect rect1; private: Rect rect2(rect1); // 复制对象 int width; return 0; int height; } int *p; // 指针成员 };
构造函数的调用时刻
※复制构造函数
2）若函数的形参是类的对象，调用函数时，自动调用 void f(Clock c) {...}//形参为类的对象 int main() { Clock c; f(c); // 调用函数时，自动调用复制构造函数 } 3）函数的返回值是类的对象，函数执行完成返回时 Clock g() { Clock c(1,2,3); return c; } int main() { Clock c2 = g(); //用返回值赋值时，自动调用复制构造函数 } 此时需要拷贝构造函数的声明为Clock::Clock(const Clock & c)
类和对象
面向对象（Object Oriented）的基本特征
对象 现实世界中
• 客观世界中的一个实体
属性—静态特征 行为—动态特征
面向对象方法中
• 系统中用来描述客观事物的一个实体
面向对象的基本特征
抽象(abstract)和类
对具体对象进行概括，抽出这一类对象的共同属性和行 为并加以描述--类
面向对象的基本特征
类与对象的关系
抽象
对象 类
实例化
信息隐藏
※面向对象的重要特性


对象的属性无法由外界直接操作，而必须通过其像外 界提供的接口来访问 外界与对象的交互只需通过访问对象提供的接口，而 无需了解对象行为的具体实现过程
类的封装
※ 封装是将抽象出的对象的数据与行为绑定在一起，形成一 个有机的整体，进行必要的权限控制 ※ 形成了“类”。类的定义： //声明部分：
struct vs. class
※struct与类相比，没有封装性：

只有数据，没有对数据的操作 数据没有访问权限的控制
矩阵： struct matrix { int a[100][100]; int rows; int columns; }
how about： transform()？ print()？
复制构造函数（拷贝构造函数）
※用该类的已有对象初始化另一个对象
class 类名{ public: 类名(类名 &对象名) //拷贝构造函数 ....... }
※隐含的复制构造函数

如果用户不显示定义类的复制构造函数，则系统为各 个类生成一个隐含的复制构造函数，该函数将形参的 各个成员数据赋值给该对象的成员数据

隐式声明：函数体放在类声明内 显示：
inline void Clock::showTime() { cout<<hour<<":"<<minute<<":"<<second; }
对象
※类实际是一种复杂数据类型 ※对象是类的实例 ※对象的声明
类名 对象名；

如 Clock myClock; 类的外部，“.”
浅拷贝vs.深拷贝
※ ※ ※ ※ ※ ※ Rect(const Rect& r) { width = r.width; height = r.height; p = new int; // 为新对象重新动态分配空间 *p = *(r.p); }
类的组合
※描述对象之间的包含关系，可以在已有的类的基 础上实现更复杂的类 class Point {
动态申请类的对象
※类的指针，动态申请对象

Clock c1; Clock c2(1,2,3); Clock c3(c1); Clock *p1 = new Clock(); Clock *p2 = new Clock(0,0,0); Clock *p3 = new Clock(c1);
※对象的声明

构造函数
※构造函数是在对象被创建时对对象的初始化过程 ※构造函数的名字与类名相同，无返回值

//类声明 class Clock { public: Clock(); } //构造函数定义： Clock :: Clock() { hour=0; minute=0; second=0; }
构造函数的调用时刻
※无参及具有形参（非复制构造函数）的调用时刻 主要是对象定义时，根据参数类型

Clock c; Clock *p = new Clock(); Clock *p2 = new Clock(0,0,0);
※复制构造函数

1）用类的一个对象初始化另一个对象时，自动调用
Clock c1(c); //用对象c初始化对象c1，复制构造函数被调用 Clock c2=c; //用c初始化c2，复制构造函数被调用 Clock *p3 = new Clock(c);//用c初始化动态申请的Clock对象
只能访问公有成员 myClock.showTime();
※对象的使用

※ 注意：类的内部可直接访问该类的所有成员数据和成员函 数
对象
※this指针

指向本对象的指针
void Clock::setTime(int newHour, int newMinute, int newSecond) { hour = newHour; minute = newMinute; second = newSecond; } void Clock::setTime(int hour, int minute, int second) { this->hour = hour; this->minute = minute; this->second = second; }