第十一讲继承、派生与多态

第十一讲继承、派生与多态

内容提要 • 类的继承与派生 • 类成员的访问控制 • 类型兼容规则 • 派生类的构造函数与析构函数 • 派生类成员的标识与访问 • 多态性与运算符重载

继承关系 类的继承与派生：在已有的类的基础上定义新的类 • 从已有类的基础上产生新类的过程就是类的派生 • 原有类称为基类或父类，新类称为派生类或子类 • 类的继承：派生类继承了父类的特性（数据和函数） • 派生类可以加入新的特性 • 派生类也可以作为基类派生新的类－－类的层次结构 • 继承和派生实现了代码的重用和扩充，有利于软件开发例：火车大卡车汽车交通工具小轿车飞机面包车

派生类的定义 • 派生类的定义 class 派生类名:继承方式父类名1, 继承方式父类名2, ... { 派生类成员声明; }; • 一个派生类可以有多个父类（多继承） • 单继承：一个派生类只有一个父类 • 一个父类可以派生出多个子类－－类族 • 继承是传递的：从父类继承的特性可以传递给新的子类 • 继承方式：规定了如何访问从父类继承的成员 • 继承方式有三种：public、protected、private • 派生类成员：从父类继承的成员+新增加的成员

派生过程 派生过程：吸收父类成员，改造父类成员，添加新成员 • 吸收父类成员派生类包含父类中除构造和析构函数外的所有非静态成员 • 改造父类成员 -父类成员的访问控制（通过继承方式实现） -对父类成员的覆盖或隐藏（如同名隐藏，即新成员与父类成员同名，则只能访问新成员） • 添加新成员根据实际需要，添加新的数据成员或函数成员

访问控制 访问控制：能否访问/怎样访问从父类继承得来的成员 • 这里的访问是指派生类中新增成员和派生类外部函数访问派生类中从父类继承的成员 • 继承方式不同，访问控制不同 • 公有继承（public） -父类的公有和保护成员的访问属性保持不变 -父类的私有成员不可直接访问从父类继承的成员函数对父类成员的访问不受影响

公有继承示例 class Point { public: void initPoint(float x=0, float y=0); void move(float offx, float offy); float getx() const {return x;} float gety() const {return y;} private: float x, y; } class Rectangle: public Point { public: void initRect(float x,float y,float w,float h) { initPoint(x,y); this->w=w; this->h=h; } float geth() const {return h;} float getw() const {return w;} private: float h, w; // 新增私有成员 }

私有与保护继承 • 私有继承（private） -父类的公有和保护成员都成为派生类的私有成员 -父类的私有成员不可直接访问私有继承后，父类成员（特别是公有函数）无法在以后的派生类中直接发挥作用，相当于终止了父类功能的继续派生。因此，私有继承较少使用。 • 保护继承（protected） -父类的公有和保护成员都成为派生类的保护成员 -父类的私有成员不可直接访问与私有继承的区别：父类成员（特别是公有函数）可以在以后的派生中作为保护成员继承下去。

类型兼容规则 类型兼容规则：在需要父类对象出现的地方，可以使用派生类（以公有方式继承）的对象来替代。 • 通俗解释：公有派生类实际具备了父类的所有功能，凡是父类能解决的问题，公有派生类都可以解决。 • 类型兼容规则中的替代包括以下情况： -派生类的对象可以隐式转化为父类对象 -派生类的对象可以初始化父类的引用 -派生类的指针可以隐式转化为父类的指针 • 几点说明： -在父类对象出现的场合，都可以使用派生类对象替代 -替代后，只能使用从父类继承的成员 -替代后，派生类只能发挥父类的作用

派生类的构造函数 派生类的构造和析构函数：派生类不能继承父类的构造和析构函数，必须自己定义 • 派生类的构造函数只负责新增成员的初始化 • 派生类中从父类继承的成员的初始化由父类的构造函数负责 • 派生类对象的初始化： -派生类对象的（数据）成员：父类成员 + 新增成员 -初始化：父类成员初始化 + 新增成员初始化 -数据成员：基本数据类型变量 + 类的对象 -由于父类成员需要调用父类构造函数，因此在派生类构造函数的参数中，有一些参数是传递给父类的构造函数的

派生类的构造函数 • 派生类构造函数的定义派生类名::派生类名(参数):父类名1(参数), ..., 父类名n(参数), 成员对象1(参数), ..., 成员对象m(参数) { 派生类构造函数的其它初始化工作; } • 若父类使用默认构造函数，则可以省略 • 若成员对象使用默认构造函数，也可以省略 • 派生类构造函数执行的一般次序 -调用父类的构造函数，按被继承时声明的顺序执行 -对派生类新增成员对象初始化，按它们在类中声明的顺序 -执行派生类的构造函数体的内容

示例 class B1 // 类B1，构造函数有参数 { public: B1(int i) {cout<<"constructing B1 "<<i<<endl;} }; class B2 // 类B2，构造函数有参数 { public: B2(int j) {cout<<"constructing B2 "<<j<<endl;} }; class B3 // 类B3，构造函数无参数 { public: B3() {cout<<"constructing B3 *"<<endl;} };

示例 class C: public B2, public B1, public B3 //派生新类C，注意父类名的顺序 {public: //派生类的公有成员 C(int a, int b, int c, int d): B1(a),memberB2(d),memberB1(c),B2(b), x(a) {} //注意父类名的个数与顺序 //注意成员对象名的个数与顺序 private: //派生类的私有对象成员 B1 memberB1; B2 memberB2; B3 memberB3; int x; }; int main() { C obj(1,2,3,4); } 屏幕输出结果： constructing B2 2 constructing B1 1 constructing B3 * constructing B1 3 constructing B2 4 constructing B3 * 普通变量也可以看作是对象 ex11_constructor.cpp

复制构造函数 • 若没有定义复制构造函数，则系统自动生成一个，自动调用父类的复制构造函数 • 在定义派生类的复制构造函数时，需要为父类相应的复制构造函数传递参数例： class C: public B { C(const C &v) : B(v); ... ... }; C::C(const C &v) : B(v) { ... ... }

析构函数 • 派生类的析构函数只负责新增非对象成员的清理工作 • 派生类析构函数的定义与没有继承关系的类的析构函数一样 • 父类和新增对象成员的清理工作由父类和对象成员的析构函数负责 • 析构函数的执行顺序与构造函数相反： - 执行派生类析构函数体 - 执行派生类对象成员的析构函数 - 执行父类的析构函数

派生类成员的标识 派生类成员的标识问题：如何处理成员同名问题？ • 派生类成员：所有父类的成员 + 新增的成员 • 派生类成员按访问属性可划分为下面四类： -不可访问成员：父类的私有成员 -私有成员：父类继承的部分成员 + 新增的私有成员 -保护成员：父类继承的部分成员 + 新增的保护成员 -公有成员：父类继承的部分成员 + 新增的公有成员 • 作用域分辨符：连续的两个冒号，即 “::” -用来限定要访问的成员所在的类类名::成员名 // 数据成员类名::成员名(参数) // 函数成员

隐藏规则 隐藏规则：如果存在两个或多个具有包含关系的作用域，外层作用域声明的标识符在内层作用域可见，但如果在内层作用域声明了同名标识符，则外层标识符在内层不可见。 • 父类是外层，派生类是内层 • 若在派生类中声明了与父类同名的新函数，即使函数参数表不同，从父类继承的同名函数的所有重载形式都会被隐藏 • 访问被隐藏的成员，需要使用类名和作用域分辨符 • 若派生类有多个父类，且这些父类中有同名标识符，则必须使用作用域分辨符来指定使用哪个父类的标识符！通过作用域分辨符就明确地唯一标识了派生类中从父类继承的成员，从而解决了成员同名问题。

虚父类 在多继承时，如果派生类的部分或全部父类是从另一个共同父类派生而来，这时就会存在标识符同名问题，因此需要作用域分辨符。此时，最初的共同父类的成员就会在很多派生类中存在副本，但是在很多情况下，我们只需要一个这样的数据副本（特别是函数成员），为了节省开销，我们希望不存放多于的副本。虚父类：当某个类的部分或全部父类是从另一个共同父类派生而来时，可以将这个共同父类设置成虚父类，这时从不同路径继承来的同名数据成员在内存中只存放一个副本，同一个函数名也只有一个映射。

虚父类 • 虚父类的声明 class 派生类名:virtual 继承方式父类名 { ... ... } 例： class A { ... }; class B : virtual publicA { ... }; class C : virtual publicA { ... }; class D : public B, public C { ... };

虚父类 • 虚父类及其派生类的构造函数在直接或间接继承虚父类的所有派生类，都必须在构造函数的成员初始化表中列出对虚父类的初始化。例： class A { public: A(int x); ... }; class B : virtual publicA { public: B(int x) : A(x); ... }; class D : public B { public: C(int x) : A(x), B(x); ... };

多态性 多态：同样的消息被不同类型的对象接收时导致不同的行为 • 消息：对类的成员函数的调用 • 不同行为：不同的实现（功能），即调用不同函数 • 多态性是面向对象程序设计的重要特征之一 • 面向对象的多态性可分为： - 重载多态、强制多态、包含多态、参数多态 • 多态的实现： - 函数重载，运算符重载 - 虚函数 - 类模板

运算符重载 运算符重载：预定义的运算符只针对基本数据类型，若要对类的对象进行类似的运算，需要重新定义运算符的功能 • 运算符重载实质就是函数重载，就是对已有的运算符赋予多重含义，使得同一个运算符作用于不同类型的数据时导致不同的行为 • 运算符重载的规则： - 只能重载已有的运算符 - 除“.”、“.*”、“::”、“?:”不能被重载外，其余都可以 - 重载之后运算符的优先级和结合性不变 - 运算符重载是针对新类型数据的需要，一般来说，重载的功能与已有的功能类似，操作数的个数不能变，同时至少有一个操作数是自定义类型

运算符重载 • 运算符重载的一般定义形式类型说明符 operator运算符(参数) { 函数体; } • 这里的类型说明符可以是类名或普通数据类型 • 运算符重载可以作为类的成员函数，也可以定义为普通函数 • 若定义成普通函数，则在类中需将其声明为友元函数 • 运算符重载为普通函数时，形参个数与操作数相同 • 运算符重载为成员函数时，形参个数少一个：目的对象自动作为第一个操作数，因此无需通过参数传递。（后置 ++和后置 --除外）

重载为成员函数 • 运算符重载为成员函数 - 可以自由访问本类的数据成员 - 实际使用时，通过本类的某个对象来访问重载的运算符 - 若是双目运算，左操作数是对象本身，使用 this 指针 - 若是单目运算，操作数由 this 指针给出，不需要其它参数 • 双目运算符的重载（成员函数）对象A ⊙ 对象B operator⊙(对象A,对象B) - 将 ⊙ 重载为成员函数，只有一个形参，类型与对象B一致例： Point operator+(Point p) { 函数体; }

重载为成员函数 • 前置单目运算符的重载（成员函数） ⊙ 对象A operator⊙(对象A) - 将 ⊙ 重载为成员函数，没有形参例： Point operator++() { 函数体; } • 后置单目运算符（++、--）的重载（成员函数）对象A ⊙ operator⊙(对象A,0) - 将 ⊙ 重载为成员函数，带一个整型形参，该形参在运算中不起任何作用，只是用于区分前置和后置例： Point operator++(int x) { 函数体; }

重载示例一 例：复数运算 class complex// 声明复数类 { public: complex(double r=0.0,double i=0.0) // 构造函数 {real=r;imag=i;} complex operator+(complex c2);// 运算符+重载 complex operator-(complex c2);// 运算符-重载 void display() // 输出复数 { cout<<"("<<real<<","<<imag<<")"<<endl; } private: double real; //实部 double imag; //虚部 }; • 构造函数也可以写为： complex(double r=0.0,double i=0.0) : real(r), imag(i) {}

重载示例一 complex complex::operator+(complex c2){ // 创建一个临时匿名对象作为返回值 return complex(real+c2.real, imag+c2.imag);} complex complex::operator-(complex c2) { // 创建一个临时匿名对象作为返回值 return complex(real-c2.real, imag-c2.imag); } int main() { complex c1(5,4), c2(2,10), c3; cout<<"c1="; c1.display(); cout<<"c2="; c2.display(); c3 = c1 - c2; // 使用重载运算符完成复数减法 cout<<"c1-c2="; c3.display(); c3 = c1 + c2; // 使用重载运算符完成复数加法 cout<<"c1+c2="; c3.display(); } ex11_overload01.cpp

重载示例二 例：将单目运算 ++ 重载为成员函数 class Clock{ public: Clock(int H=0, int M=0, int S=0); void showTime() const//显示时间 {cout<<hour<<":"<<minute<<":"<<second<<endl;} Clockoperator++();//前置单目运算符重载 Clock operator++(int);//后置单目运算符重载 private: int hour, minute, second; }; Clock::Clock(int H, int M, int S)//构造函数 { if(0<=H && H<24 && 0<=M && M<60 && 0<=S && S<60) { hour = H; minute = M;second = S; } else cout<<"Time error!"<<endl; }

重载示例二 Clock Clock::operator++() // 前置单目运算符重载函数 { second++; if(second >= 60) { second -= 60; minute++; if(minute >= 60) { minute -= 60; hour = (++hour) % 24; } } return *this; } Clock Clock::operator++(int) // 后置单目运算符重载 { // 注意形参表中的整型参数 Clock old=*this; ++(*this); // 调用前置++ return old; } ex11_overload02.cpp

重载为普通函数 • 运算符重载为非成员函数 - 需在相关类中将其声明为友元函数 - 所有操作数都通过参数传递

上机作业 • 上机作业 1) 教材第 414 页，18.1，程序取名为 hw11_81.cpp 2) 教材第 414 页，18.2，使用成员函数方式。程序取名为 hw11_82.cpp 3) 重载复数的加法运算，使用非成员函数方式。程序取名为 hw11_83.cpp

第十一讲 继承、派生与多态