ç¬¬å…«ç« å¤šæ€æ€§

第八章多态性 C++语言程序设计

本章主要内容 多态性运算符重载虚函数纯虚函数抽象类深度探索

多态性的概念 多态性是面向对象程序设计的重要特征之一。多态性是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。多态的实现：函数重载运算符重载虚函数

问题举例——复数的运算 class Complex { //复数类声明 public: Complex(double r = 0.0,double i = 0.0) { real = r; imag=i; } void display() const; //显示复数的值 private: double real; double imag; };

问题举例——复数的运算 用“+”、“-”能够实现复数的加减运算吗？实现复数加减运算的方法——重载“+”、“-”运算符

运算符重载的实质 运算符重载是对已有的运算符赋予多重含义必要性 C++中预定义的运算符其运算对象只能是基本数据类型，而不适用于用户自定义类型（如类）实现机制将指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参。编译系统对重载运算符的选择，遵循函数重载的选择原则。

规则和限制 可以重载C++中除下列运算符外的所有运算符：. .* :: ?: 只能重载C++语言中已有的运算符，不可臆造新的。不改变原运算符的优先级和结合性。不能改变操作数个数。经重载的运算符，其操作数中至少应该有一个是自定义类型。

两种形式 重载为类的非静态成员函数重载为非成员函数

运算符函数 声明形式函数类型 operator 运算符（形参） { ...... } 重载为类成员函数时参数个数=原操作数个数-1 （后置++、--除外）重载为非成员函数时参数个数=原操作数个数，且至少应该有一个自定义类型的形参。

运算符成员函数的设计 双目运算符 B 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2所属的类型。经重载后，表达式oprd1 B oprd2相当于 oprd1.operator B(oprd2)

例 8-1 将“+”、“-”运算重载为复数类的成员函数。规则: 实部和虚部分别相加减。操作数: 两个操作数都是复数类的对象。

#include <iostream> using namespace std; class Complex { //复数类定义 public: //外部接口 Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) { } //构造函数 Complex operator + (const Complex &c2) const; //运算符+重载成员函数 Complex operator - (const Complex &c2) const; //运算符-重载成员函数 void display() const; //输出复数 private: //私有数据成员 double real; //复数实部 double imag; //复数虚部 }; 12

Complex Complex::operator + (const Complex &c2) const { //重载运算符函数实现 return Complex(real + c2.real, imag + c2.imag); //创建一个临时无名对象作为返回值 } Complex Complex::operator - (const Complex &c2) const { //重载运算符函数实现 return Complex(real - c2.real, imag - c2.imag); //创建一个临时无名对象作为返回值 } 13

void Complex::display() const { cout << "(" << real << ", " << imag << ")" << endl; } int main() { //主函数 Complex c1(5, 4), c2(2, 10), c3; //定义复数类的对象 cout << "c1 = "; c1.display(); cout << "c2 = "; c2.display(); c3 = c1 - c2; //使用重载运算符完成复数减法 cout << "c3 = c1 - c2 = "; c3.display(); c3 = c1 + c2; //使用重载运算符完成复数加法 cout << "c3 = c1 + c2 = "; c3.display(); return 0; } 14

程序输出的结果为： c1 = (5, 4) c2 = (2, 10) c3 = c1 - c2 = (3, -6) c3 = c1 + c2 = (7, 14) 15

运算符成员函数的设计 前置单目运算符 U 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中oprd 为A类对象，则 U 应被重载为 A 类的成员函数，无形参。经重载后，表达式U oprd相当于 oprd.operator U()

运算符成员函数的设计 后置单目运算符 ++和-- 如果要重载 ++或--为类成员函数，使之能够实现表达式 oprd++或 oprd--，其中oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。经重载后，表达式 oprd++相当于 oprd.operator ++(0)

例8-2 运算符前置++和后置++重载为时钟类的成员函数。前置单目运算符，重载函数没有形参，对于后置单目运算符，重载函数需要有一个整型形参。操作数是时钟类的对象。实现时间增加1秒钟。

#include <iostream> using namespace std; class Clock { //时钟类声明定义 public: //外部接口 Clock(int hour = 0, int minute = 0, int second = 0); void showTime() const; Clock& operator ++ ( );//前置单目运算符重载 Clock operator ++ (int);//后置单目运算符重载 private: //私有数据成员 int hour, minute, second; }; 19

//前置单目运算符重载函数 Clock & Clock::operator ++ () { second++; if (second >= 60) { second -= 60; minute++; if (minute >= 60) { minute -= 60; hour = (hour + 1) % 24; } } return *this; } 20

//后置单目运算符重载 Clock Clock::operator ++ (int) { //注意形参表中的整型参数 Clock old = *this; ++(*this); //调用前置“++”运算符 return old; } 21

//其它成员函数的实现略 int main() { Clock myClock(23, 59, 59); cout << "First time output: "; myClock.showTime(); cout << "Show myClock++: "; (myClock++).showTime(); cout << "Show ++myClock: "; (++myClock).showTime(); return 0; } 22

程序运行结果为： First time output: 23:59:59 Show myClock++: 23:59:59 Show ++myClock: 0:0:1 23

运算符非成员函数的设计 函数的形参代表依自左至右次序排列的各操作数。后置单目运算符 ++和--的重载函数，形参列表中要增加一个int，但不必写形参名。如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。

运算符非成员函数的设计 双目运算符 B重载后，表达式oprd1 B oprd2 等同于operator B(oprd1,oprd2 ) 前置单目运算符 B重载后，表达式 B oprd等同于operator B(oprd ) 后置单目运算符 ++和--重载后，表达式 oprd B等同于operator B(oprd,0 ) 运算符重载

例8-3 将+、-（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用。将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：cout << a << b;该输出调用的是：operator << (operator << (cout, a), b);

#include <iostream> using namespace std; class Complex { //复数类定义 public: //外部接口 Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) { } //构造函数 friend Complex operator + (const Complex &c1, const Complex &c2); //运算符+重载 friend Complex operator - (const Complex &c1, const Complex &c2); //运算符-重载 friend ostream & operator << (ostream &out, const Complex &c);//运算符<<重载 private: //私有数据成员 double real; //复数实部 double imag; //复数虚部 }; 27

Complex operator +(const Complex &c1, const Complex &c2) { return Complex(c1.real + c2.real, c1.imag + c2.imag); } Complex operator - (const Complex &c1, const Complex &c2) { return Complex(c1.real - c2.real, c1.imag - c2.imag); } ostream & operator <<(ostream &out, const Complex &c) { out << "(" << c.real << ", " << c.imag << ")"; return out; } 28

静态绑定与动态绑定 绑定程序自身彼此关联的过程，确定程序中的操作调用与执行该操作的代码间的关系。静态绑定绑定过程出现在编译阶段，用对象名或者类名来限定要调用的函数。动态绑定绑定过程工作在程序运行时执行，在程序运行时才确定将要调用的函数。

虚函数 虚函数是动态绑定的基础。是非静态的成员函数。在类的声明中，在函数原型之前写virtual。 virtual只用来说明类声明中的原型，不能用在函数实现时。具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数。本质：不是重载声明而是覆盖。调用方式：通过基类指针或引用，执行时会根据指针指向的对象的类，决定调用哪个函数。

例 8-4 #include <iostream> using namespace std; class Base1 { //基类Base1定义 public: virtual void display() const; //虚函数 }; void Base1::display() const { cout << "Base1::display()" << endl; } class Base2: public Base1 { //公有派生类Base2定义 public: void display() const; //覆盖基类的虚函数 }; void Base2::display() const { cout << "Base2::display()" << endl; }

//公有派生类Derived定义 class Derived: public Base2 { public: void display() const; //覆盖基类的虚函数 }; void Derived::display() const { cout << "Derived::display()" << endl; } //参数为指向基类对象的指针 void fun(Base1 *ptr) { ptr->display(); //"对象指针->成员名" } 36

int main() { //主函数 Base1 base1; //定义Base1类对象 Base2 base2; //定义Base2类对象 Derived derived; //定义Derived类对象 fun(&base1); //用Base1对象的指针调用fun函数 fun(&base2); //用Base2对象的指针调用fun函数 fun(&derived); //用Derived对象的指针调用fun函数 return 0; } 运行结果： Base1::display() Base2::display() Derived::display() 37

虚析构函数 为什么需要虚析构函数？可能通过基类指针删除派生类对象；如果你打算允许其他人通过基类指针调用对象的析构函数（通过delete这样做是正常的），就需要让基类的析构函数成为虚函数，否则执行delete的结果是不确定的。

带有纯虚函数的类称为抽象类: class 类名 { virtual类型函数名(参数表)=0; //纯虚函数 ... } 纯虚函数与抽象类

抽象类 作用抽象类为抽象和设计的目的而声明，将有关的数据和行为组织在一个继承层次结构中，保证派生类具有要求的行为。对于暂时无法实现的函数，可以声明为纯虚函数，留给派生类去实现。注意抽象类只能作为基类来使用。不能声明抽象类的对象。构造函数不能是虚函数，析构函数可以是虚函数。纯虚函数与抽象类

例 8-5 #include <iostream> using namespace std; class Base1 { //基类Base1定义 public: virtual void display() const =0; //纯虚函数 }; class Base2: public Base1 { //公有派生类Base2定义 public: void display() const { //覆盖基类的虚函数 cout << "Base2::display()" << endl; } }; class Derived: public Base2 { //公有派生类Derived定义 public: void display() const { //覆盖基类的虚函数 cout << "Derived::display()" << endl; } }; 纯虚函数与抽象类

void fun(Base1 *ptr) { ptr->display(); //"对象指针->成员名" } int main() { //主函数 Base2 base2; //定义Base2类对象 Derived derived; //定义Derived类对象 fun(&base2); //用Base2对象的指针调用fun函数 fun(&derived);//用Derived对象的指针调用fun函数 return 0; } 运行结果： Base2::display() Derived::display() 42

多态类型与非多态类型 • 多态类型与非多态类型 • 有虚函数的类类型称为多态类型 • 其它类型皆为非多态类型 • 二者的差异 • 语言层面的差异 • 多态类型支持运行时类型识别 • 多态类型对象占用额外的空间 • 设计原则上的差异

设计原则 • 多态类型 • 多态类型的析构函数一般应为虚函数 • 非多态类型 • 非多态类型不宜作为公共基类 • 由于没有利用动态多态性，一般可以用组合，而无需用共有继承； • 如果继承，则由于析构函数不是虚函数，删除对象时所执行操作与指针类型有关，易引起混乱。 • 把不需被继承的类型设定为非多态类型 • 由于成员函数都是静态绑定，调用速度较快； • 对象占用空间较小。

运行时类型识别 • 运行时类型识别 • 允许在运行时通过基类指针（或引用）辨别对象所属的具体派生类； • 只对多态类型适用； • 比虚函数动态绑定的开销更大，因此应仅对虚函数无法解决的问题使用。 • 运行时类型识别的方式 • 用dynamic_cast做类型转换的尝试； • 用typeid直接获取类型信息。

dynamic_cast的使用 • 语法形式 • dynamic_cast<目的类型>(表达式) • 功能 • 将基类指针转换为派生类指针，将基类引用转换为派生类引用； • 转换是有条件的 • 如果指针（或引用）所指对象的实际类型与转换的目的类型兼容，则转换成功进行； • 否则如执行的是指针类型的转换，则得到空指针；如执行的是引用类型的转换，则抛出异常。

例8-9 dynamic_cast示例 #include <iostream> using namespace std; class Base { public: virtual void fun1() { cout << "Base::fun1()" << endl; } virtual ~Base() { } }; class Derived1: public Base{ public: virtual void fun1() { cout << "Derived1::fun1()" << endl; } virtual void fun2() { cout << "Derived1::fun2()" << endl; } }; class Derived2: public Derived1 { public: virtual void fun1() { cout << "Derived2::fun1()" << endl; } virtual void fun2() { cout << "Derived2::fun2()" << endl; } };

void fun(Base *b) { b->fun1(); //尝试将b转换为Derived1指针 Derived1 *d = dynamic_cast<Derived1 *>(b); //判断转换是否成功 if (d != 0) d->fun2(); } int main() { Base b; fun(&b); Derived1 d1; fun(&d1); Derived2 d2; fun(&d2); return 0; } 运行结果： Base::fun1() Derived1::fun1() Derived1::fun2() Derived2::fun1() Derived2::fun2() 48

typeid的使用 深度探索 • 语法形式 • typeid ( 表达式 ) • typeid ( 类型说明符 ) • 功能 • 获得表达式或类型说明符的类型信息 • 表达式有多态类型时，会被求值，并得到动态类型信息； • 否则，表达式不被求值，只能得到静态的类型信息。 • 类型信息用type_info对象表示 • type_info是typeinfo头文件中声明的类； • typeid的结果是type_info类型的常引用； • 可以用type_info的重载的“==”、“!=”操作符比较两类型的异同； • type_info的name成员函数返回类型名称，类型为const char *。

例8-10 typeid示例 #include <iostream> #include <typeinfo> using namespace std; class Base { public: virtual ~Base() { } }; class Derived: public Base { };

void fun(Base *b) { //得到表示b和*b类型信息的对象 const type_info &info1 = typeid(b); const type_info &info2 = typeid(*b); cout << "typeid(b): " << info1.name() << endl; cout << "typeid(*b): " << info2.name() << endl; if (info2 == typeid(Base)) //判断*b是否为Base类型 cout << "A base class!" << endl; } int main() { Base b; fun(&b); Derived d; fun(&d); return 0; } 运行结果： typeid(b): class Base * typeid(*b): class Base A base class! typeid(b): class Base * typeid(*b): class Derived 51

虚函数动态绑定的实现原理 • 动态选择被执行的函数 • 函数的调用，需要通过函数代码的入口地址 • 把函数入口地址作为变量，在不同情况下赋予不同的值，通过该变量调用函数，就可动态选择被执行的函数 • 回顾：第6章介绍的函数指针、指向成员函数的指针 • 虚表 • 每个多态类有一个虚表（virtual table） • 虚表中有当前类的各个虚函数的入口地址 • 每个对象有一个指向当前类的虚表的指针（虚指针vptr） • 动态绑定的实现 • 构造函数中为对象的虚指针赋值 • 通过多态类型的指针或引用调用成员函数时，通过虚指针找到虚表，进而找到所调用的虚函数的入口地址 • 通过该入口地址调用虚函数

class Derived: public Base { public: virtual void f(); //覆盖Base::f virtual void h(); //新增的虚函数 private: int j; }; class Base { public: virtual void f(); virtual void g(); private: int i; }; (Base::f的代码) push %ebp mov %esp,%ebp …… 指向f()的指针 vptr 指向g()的指针 (Base::g的代码) push %ebp mov %esp,%ebp …… i Base的虚表 Base类型对象 (Derived::f的代码) push %ebp mov %esp,%ebp …… 指向f()的指针 vptr 指向g()的指针 i 指向h()的指针 j (Derived::h的代码) push %ebp mov %esp,%ebp …… Derived的虚表 Derived类型对象 53

小结与复习 主要内容多态性的概念、运算符重载、虚函数、纯虚函数、抽象类达到的目标理解多态的概念，学会运用多态机制。实验任务实验八

ç¬¬å…«ç« å¤šæ€æ€§

ç¬¬å…«ç« å¤šæ€æ€§

Presentation Transcript

ç¬¬å…«ç« å¤šæ€æ€§

ç¬¬å…«ç« å¤šæ€æ€§