程序设计基础

程序设计是计算机学科的 核心和灵魂程序设计基础第七章继承机制

继承机制的作用 • 继承成员的访问控制规则 • 继承成员的调整 • 类型兼容性 • 类层次中的构造函数与析构函数 • 多重继承 • 重复继承

§7.1 继承的基本概念 7.1.1 IS-A关系IS-A关系：组织和表达知识，将知识组织成为一种有层次、可分类的结构。鸭梨是一种（IS-A))梨。 • 鸭梨具有梨都具有的特征； • 鸭梨与其他梨有不同的特征。动物分类：界（kingdom）、门（phylum）、纲（class）、目（order）、科（family）、属（genus）、种（species）。

§7.1 继承的基本概念 7.1.2 继承机制继承（inheritance）：在一个类或若干已知类的基础上，经过适当的修改、扩充构成一个新类，这个新类具有原来作为基础类的特征。继承是面向对象程序所特有的特征。如果类B继承类A，则类B自动包括了类A中定义的数据成员和成员函数，还可定义类B自己的成员；称类A为类B的父类（parent）、超类(super-class)或基类（base）；类B称为类A的子类（child)或派生类（derived-class); 祖先类（ancestor）：包括了其父类及其父类的祖先类。后代类（descendant）：包括了其子类以及子类的后代类。

§7.1 继承的基本概念 7.1.2 继承机制类的图形表示（UML）：类名类名类名类名属性属性行为行为具体抽象

§7.1 继承的基本概念 7.1.2 继承机制类层次表示（UML）：水果苹果梨国光苹果秦冠苹果红富士苹果

§7.1 继承的基本概念 7.1.2 继承机制IS-A与HAS-A 汽车轮胎真空轮胎 …轮胎

§7.1 继承的基本概念 7.1.3 继承的作用继承机制的双重作用：类的构造机制：继承通过扩充、组合先有类来构造新的类。扩充：形成先有类的特例——派生类；组后：抽取若干现有类的共性形成新的抽象层次——基类。类的构造机制：如果类B继承类A，则要求对象为A类型的地方也可以接受B类型的对象。 7.1.4 继承与软件重用软件重用：重用专家的经验；重用标准的设计与算法；重用类库与过程（函数）库；重用语言和操作系统中内置的强大的命令；重用框架；重用完整的应用（程序）。重用程序源代码： • 利用继承机制组织类之间的组织关系； • 派生类具有调节所继承的属性和行为的能力； • 提高程序可靠性。

§7.1 继承的基本概念 7.1.5 C++继承常见的几种形式 A A B A B C C B C D D 多重继承重复继承单重继承

§7.2 C++的继承机制 7.2.1 继承的语法继承是类与类之间的一种关系定义：“类B继承类A”，或者说“类A派生类B”图解为：则在类B中除了自己定义的成员之外，还自动包括了类A中定义的数据成员与成员函数，这些自动继承下来的成员称为类B的继承成员。 A 基类 B 派生类

§7.2 C++的继承机制 7.2.1 继承的语法 • 继承的语法 class 派生类名: 基类类名表{ public: 公有成员说明列表; protected: 受保护成员说明列表; private: 私有成员说明列表; }; 其中基类类名表的格式为： access 基类类名1, ……, access 基类类名n access为继承访问控制符，规定了派生类对基类的继承方式，可为public，private或者protected，继承访问控制符可省略，此时认为是private

7.2.1 继承的语法 §7.2 C++的继承机制 class BASE { …… }; class A:public BASE{ ……// 单继承 }; class B:private BASE, public D{ …… // 多重继承 }; class C:public A, B{ …… }; BASE BASE D A B C 私有派生

成员访问控制 类自身派生类其他类 public 可访问可访问可访问 protected 可访问可访问不可访问 private 可访问不可访问不可访问 §7.2 C++的继承机制 7.2.1 继承的语法 • 保护访问控制属性：protected • 在protected后定义的是保护段，其中的数据成员或成员函数称为受保护成员：具有公有成员与私有成员的双重角色。 • 一个类的受保护成员，对于其子孙类（派生类）的成员函数来说是公有的，对类本身及后代类之外定义的其他函数则是私有成员。例： class BASE { private: int x; protected: int i, j; }; class D:public BASE{ void make(); }; void D::make() { int k = i* j ; …… }

§7.2 C++的继承机制 7.2.1 继承的语法 • 派生类可以重新定义基类的成员函数，覆盖基类的同名函数例： class DATE { public: DATE(int yy = 0, int mm = 0, int dd = 0); // 构造函数 void set_date(int yy, int mm, int dd); // 设置日期 void get_date(int& yy, int& mm, int& dd); // 取日期 void print_date(); // 以ANSI格式（yy.mm.dd）打印日期 protected: int year, month, day; // 年、月、日 }; void DATE::print_date() { cout<<year<<“.”<<month<< “.”<<day<<“\n”; }

§7.2 C++的继承机制 7.2.1 继承的语法 class EUROPE_DATE: public DATE { public: void print_date(); // 以欧洲格式（dd-mm-yy）打印日期 void print(int isANSI); }; void EUROPE_DATE::print_date() { // 以欧洲格式（dd-mm-yy）打印日期 cout<< day <<“-”<<month<< “-”<<year<<“\n”; }

§7.2 C++的继承机制 7.2.1 继承的语法 • 通过类名限定符在派生类中使用基类的同名成员 void EUROPE_DATE::print(int isANSI) { if (isANSI) DATE::print_date(); else print_date(); } void main() { EUROPE_DATE test ; test.print_date(); //调用EUROPE_DATE中重定义的同名函数 //以欧洲格式（dd-mm-yy）打印 test.DATE::print_date(); //以ANSI格式（yy.mm.dd）打印 }

§7.2 C++的继承机制 7.2.1 继承的语法 // 程序：TIME.HPP // 功能：带有日期信息的时间类的类界面 Class TIME: public DATE { public: TIME(int hh, int mm, int ss); void set_time(int hh, int mm, int ss); void get_time(int hh, int mm, int ss); void print_time(); Protected: int hour,minute,second; }; DATE EUROPE_DATE TIME

§7.2 C++的继承机制 7.2.2 继承访问控制规则 • 公有继承（公有派生）、私有继承、保护继承无论采用什么派生的方式，派生类中都不能访问基类的私有成员

§7.2 C++的继承机制 7.2.2 继承访问控制规则 class BASE{ protected: int i, j; public: void get_ij(); private: int x_temp; }; class Y1:public BASE{ // 公有派生：在Y1类中，i、j是受保护成员 float yMember; // get_ij()是公有成员 }; class Y2:protected BASE{ // 保护派生：在Y2类中，i、j是受保护成员 …… // get_ij()变成受保护成员 }; class Y3:private BASE{ // 私有派生：在Y3类中，i、j、 get_ij()都变 …… // 成私有成员 };

§7.2 C++的继承机制 7.2.3 一个应用继承机制的完整例子简单图形程序设计 CRectangle CPoint CPoint m_cpLocation; int m_nWidth; int m_nHeight; int m_x; int m_y; int GetArea(); int GetPerimeter(); CPoint& GetPosition(); int GetX(); int GetY(); CSquare int GetEdge();

§7.2 C++的继承机制 7.2.3 一个应用继承机制的完整例子 #include <iostream.h> #include <conio.h> class CPoint { private: int m_x; int m_y; public: CPoint(int, int); int GetX(); int GetY(); }; CPoint::CPoint(int x, int y) { m_x=x; m_y=y; } int CPoint::GetX() { return m_x; } int CPoint::GetY() { return m_y; }

§7.2 C++的继承机制 7.2.3 一个应用继承机制的完整例子 class CRectangle //矩形类 { public: CPoint m_cpLocation; //图形所在位置 int m_nWidth; //图形的宽度 int m_nHeight; //图形的高度 CRectangle(int nX, int nY, int nWidth, int nHeight); int GetArea(); //求面积 int GetPerimeter(); //求周长 CPoint& GetPosition(); //返回图形位置 };

§7.2 C++的继承机制 7.2.3 一个应用继承机制的完整例子 CRectangle::CRectangle(int nX,int nY,int nW,int nH):m_cpLocation(nX,nY) { m_nWidth=nW; m_nHeight=nH; } int CRectangle::GetArea() { return m_nWidth*m_nHeight; } int CRectangle::GetPerimeter() { return m_nWidth+m_nWidth+m_nHeight+m_nHeight; } CPoint& CRectangle::GetPosition() { return this->m_cpLocation; }

§7.2 C++的继承机制 7.2.3 一个应用继承机制的完整例子 class CSquare : public CRectangle //正方形类，派生自矩形类 { public: CSquare(int nX, int nY, int nEdge); int GetEdge(); //返回边长 }; CSquare::CSquare(int nX, int nY, int nEdge) : CRectangle(nX, nY, nEdge, nEdge) { } int CSquare::GetEdge() { return m_nWidth; }

§7.2 C++的继承机制 7.2.3 一个应用继承机制的完整例子 void main() { CRectangle r(1,1,2,3); CSquare s(0,0,2); cout<<"Rectangle area: "<<r.GetArea()<<endl; cout<<"Square area: "<<s.GetArea()<<endl; getch(); } 程序运行结果： Rectangle area: 6 Square area: 4

obj1 i J x_temp 函数指针 i J x_temp yMember 函数指针 obj2 §7.2 C++的继承机制 7.2.4 派生类对象的存储组织派生类的对象不仅存放了在派生类中定义的非静态数据成员，而且也存放了从基类中继承下来的非静态数据成员。例： class BASE{ protected: int i, j; public: void get_ij(); private: int x_temp; }; class Y1:public BASE{ float yMember; }; BASE obj1; Y1 obj2;

§7.2 C++的继承机制 7.2.5 类型兼容性1.赋值运算的类型兼容性 • 类型的赋值兼容性规则允许将后代类的对象赋值给祖先类，但反之不成立。例：BASE obj1; Y1 obj2; obj1 = obj2 ; 把obj2中基类部分的内容赋给obj1 obj2 = obj1 ; 但此规则只适用于公有派生，只有公有派生类才能兼容基类类型

§7.2 C++的继承机制 7.2.5 类型兼容性 • 指向基类对象的指针也可指向公有派生类对象 BASE *p ; Y1 *p1; p = &obj1; p1 = &obj1; p = &obj2; p1 = &obj2; p = p1 ; 2. 参数传递与对象初始化的类型兼容性 • 与赋值运算类型兼容性相同

§7.3 继承与构造函数、析构函数 7.3.1 构造函数与析构函数的调用次序 1. 构造函数的调用次序在创建一个派生类的对象时 • 先调用其基类的构造函数 • 再调用本类对象成员的构造函数 • 最后才调用本类的构造函数 2. 析构函数的调用次序 • 先调用本类的析构函数 • 再调用本类对象成员的析构函数 • 最后才调用其基类的析构函数

§7.3 继承与构造函数、析构函数 7.3.1 构造函数与析构函数的调用次序 #include <iostream.h> class C { public: C() // 构造函数 { cout << "Constructing C object.\n"; } ~C() // 析构函数 { cout << "Destructing C object.\n"; } }; class BASE { public: BASE() // 构造函数 { cout << "Constructing base object.\n"; } ~BASE() // 析构函数 { cout << "Destructing base object.\n"; } };

§7.3 继承与构造函数、析构函数 7.3.1 构造函数与析构函数的调用次序 class DERIVED: public BASE { C mOBJ; public: DERIVED() // 构造函数 { cout << "Constructing derived object.\n";} ~DERIVED() // 析构函数 { cout << "Destructing derived object.\n"; } }; int main() { DERIVED obj; // 声明一个派生类的对象 // 什么也不做，仅完成对象obj的构造与析构 return 0; } 运行结果： Constructing base object. Constructing C object. Constructing derived object. Destructing derived object. Destructing C object. Destructing base object.

§7.3 继承与构造函数、析构函数 7.3.2 向基类构造函数传递实际参数 • 给基类构造函数传递实际参数是通过向派生类构造函数传递实际参数以及初始化列表来间接实现传递的。 • 带初始化列表的派生类构造函数的一般形式派生类名 ( 参数表 ) : 基类名 ( 调用基类构造函数参数表 ) { 派生类构造函数体 }

§7.3 继承与构造函数、析构函数 7.3.2 向基类构造函数传递实际参数 #include <iostream.h> class Base { int private1, private2; public: Base(int p1, int p2) { private1 = p1; private2 = p2;} int inc1() { return ++private1; } int inc2() { return ++private2; } void display() { cout<<"private1 = "<<private1 <<", privte2 = "<<private2<<"\n";} };

§7.3 继承与构造函数、析构函数 7.3.2 向基类构造函数传递实际参数 class Derived:private Base{ int private3; Base private4; public: Derived(int p1, int p2, int p3, int p4, int p5):Base(p1,p2),private4(p3,p4) { private3 = p5 ; } int inc1() { return Base::inc1();} int inc3() { return ++private3 ; } void display() { Base::display(); private4.display(); cout<<"private3 = "<<private3<<"\n"; } };

obj 17 18 -5 1 2 private1 从基类继承 private2 private3 private4.private1 private4.private2 §7.3 继承与构造函数、析构函数 7.3.2 向基类构造函数传递实际参数 void main() { Derived obj( 17, 18, 1, 2, -5); obj.inc1(); obj.display(); } 输出结果： private1 = 18, private2 = 18 private1 = 1, private2 =2 private3 = -5 18

§7.4 继承成员的调整 7.4.1 恢复访问控制方式使用访问声明将一些被屏蔽的共有成员恢复到原来的访问控制状态。访问声明采用作用域运算符”::”，它的一般形式是：基类名::成员名 /程序：ACCESS.CPP //功能：演示在派生类中如何调整从基类继承下来的成员的访问控制方式 #include <iostream.h> class Base { public: void set_i(int x) { i=x; } int get_i() { return i; } protected: int i; };

§7.4 继承成员的调整 7.4.1 恢复访问控制方式 class Derived:private Base { public: Base::set_i; // 访问声明 void set_j(int x) { j=x; } int get_ij() { return i+j; } protected: int j; }; int main() { Derived obj; obj.set_i(5); //set_i()已从私有转为公有 obj.set_j(7); //set_j()本来就是公有 cout<<obj.get_ij()<<endl; //get_ij()本来就是公有 return 0; }

§7.4 继承成员的调整 7.4.2 继承成员的重定义函数重载：派生类中增加了一个与基类成员函数同名的成员函数，但函数的形式参数个数、类型或次序不同，编译程序认为是增加了一个新的成员函数。重定义：派生类中定义了一个函数原型与继承成员函数一样的成员函数，但语义上修改了成员函数的实现。对成员函数重定义后，派生类对象使用函数名进行函数调用，那么使用的是派生类中新定义的成员函数。此时称这个派生类中的成员的名字支配了基类的名字。继承成员被重定义后，若想继续使用基类被屏蔽了的成员，可用：基类名::成员名来使用。

§7.4 继承成员的调整 7.4.2 继承成员的重定义 //程序：ACCESS1.CPP //功能：演示在派生类继承成员重定义 #include <iostream.h> class Base { public: void set_i(int x) { i=x; } int get_i() { return i; } void print() { cout<<"i="<<i<<endl; } protected: int i; };

§7.4 继承成员的调整 7.4.2 继承成员的重定义 class Derived:private Base { public: Base::set_i; // 访问声明 void set_j(int x) { j=x; } int get_ij() { return i+j; } void print() { Base::print(); //调用基类被屏蔽的成员函数 cout<<"j="<<j<<endl; } protected: int j; };

§7.4 继承成员的调整 7.4.2 继承成员的重定义 int main() { Derived obj; obj.set_i(5); //set_i()已从私有转为公有 obj.set_j(7); //set_j()本来就是公有 obj.print(); cout<<obj.get_ij()<<endl; return 0; } 程序运行结果 i=5 J=7 12

§7.4 继承成员的调整 7.4.3 继承成员的重命名重命名：在派生类中不改变继承成员的语义，仅仅为成员起一个新的名字。目的： • 解决名字冲突问题（在多继承情况下）； • 允许派生类根据新的应用环境选择更适合的术语来命名，使得继承成员的名字更容易理解。 C++没有提供直接的重命名机制。

§7.4 继承成员的调整 7.4.3 继承成员的重命名 class CSquare : public CRectangle //正方形类，派生自矩形类 { public: CSquare(int nX, int nY, int nEdge); int Get_Square_Area(); //重命名计算面积成员函数 int GetEdge(); //返回边长 }; Int CSquare :: Get_Square_Area() { return CRectangle::GetArea(); } GetArea();

§7.4 继承成员的调整 7.4.4 屏蔽继承成员屏蔽继承成员：实现在派生类中不能再访问从基类继承过来的某些成员。方法：通过访问控制方式protected和private //程序：PROHIBIT.CPP //功能：演示在派生类中如何屏蔽从基类继承下来的公有成员 #include <iostream.h> class Base { public: void set_i(int x) { i=x; } int get_i() { return i; } protected: int i; };

§7.4 继承成员的调整 private 7.4.4 屏蔽继承成员 class Derived: public Base { public: void set_ij(int x, int y) { i=x; j=y; } int get_ij() { return i+j; } protected: int j; private: void set_i(int x) {} };

§7.4 继承成员的调整 7.4.4 屏蔽继承成员 int main() { Derived obj; // obj.set_i(5); //不可访问错误，除非使用obj.BASE::set_i(8) obj.set_ij(5,7); //set_ij()本来就是公有 cout<<obj.get_ij()<<endl; return 0; } obj.Base::set_i(8); 如果连obj.Base::set_i(8);这种形式都不让用，怎么办？

§7.5 多重继承 7.5.1 多重继承的应用背景多重继承：一个类由多个基类派生而来单继承：一个类由单个基类派生而来父亲基因母亲基因博士教师 istream ostream 儿女基因在职博士 iostream

§7.5 多重继承 7.5.2 多重继承的语法形式 class 派生类名: access 基类名1, ……, access 基类名n{ … }; 基类名1 基类名2 …… 基类名n 派生类名

§7.5 多重继承 7.5.2 多重继承的语法形式 // 程序：MULINHER.CPP // 功能：演示多重继承的作用 #include <iostream.h> class Base1 { public: void show_i() { cout<<"i="<<i<<endl; } protected: int i; };

§7.5 多重继承 7.5.2 多重继承的语法形式 class Base2 { public: void show_j() { cout<<"j="<<j<<endl; } protected: int j; }; class Derived: public Base1, public Base2 { public: void set(int x, int y) { i=x; j=y; } };

程序设计基础

程序设计基础

Presentation Transcript