当前位置：文档之家 › 第七章派生与继承2

第七章派生与继承2

  • 格式：doc
  • 大小：43.50 KB
  • 文档页数：8

下载文档原格式

  / 8

合集下载

C++语言程序设计第7章 继承与派生

C++语言程序设计第7章 继承与派生
– 父类（Parent Class），Smalltalk语言称为超 类（Super Class）
• 派生出的新类称为派生类(Derived Class)
– 子类（Child Class），Smalltalk语言称为子类 （Sub Class）
继承与派生问题举例
人
工人
农民
商人
知识分子
军人
教师
医生
军医
void setY(float Y); float getY();
公有 公有
公有 公有 公有 公有
继承
void moveTo(Point newPoint);
Point(void); Point(const Point &); ~Point(void); Point& operator=(Point&)；
来源
Circle的成员
原访 新访问权限 问 权 限
私有 不可直接访问 私有 不可直接访问 公有 公有 公有 公有
备注
继承 继承 继承 继承
float x; float y; void initPoint(float X, float Y); void setX(float X);
继承
继承 继承
float getX();
• 声明语法 ： class 派生类名:继承方式 基类名 { private: 私有成员说明列表 protected: 保护成员说明列表 public: 公有成员说明列表 }；
• 【例7.1】派生类示例 – 从Point类派生出Circle类
class Point { private: float x,y; public: void initPoint(float X, float Y) {x=X;y=Y;}//模仿构造函 数 //访问方法 void setX(float X) {x=X;} float getX() {return x;} void setY(float Y) {y=Y;} float getY() {return y;} void moveTo(Point newPoint) //业务方法 { x=newPoint.x;y=newPoint.y; } };

C语言程序设计PPT第七章继承与派生

C语言程序设计PPT第七章继承与派生
cout<<"C's constructor called."<<endl; } C::~C() { cout<<"C's destructor called."<<endl; } void C::Print() const { B::Print(); cout<<c<<endl; } int main() { C obj(5,6); obj.Print(); }
问 控 制
类中的public和protected成员，但 不能直接访问基类的private成员。
通过派生类的对象不能直接访问基类 中的任何成员
17
C++语言程序设计
protected 成员的特点与作用
类
成 对建立其所在类对象的模块来说，它
员 与 private 成员的性质相同。
的 对于其派生类来说，它与 public 成 访 员的性质相同。
public成员。
10
C++语言程序设计
例7-1 公有继承举例
类 成 员
class Point //基类Point类的声明 {public: //公有函数成员
void InitP(float xx=0, float yy=0)
的
{X=xx;Y=yy;}
访 void Move(float xOff, float yOff)
25
C++语言程序设计
多继承时派生类的声明
单
继 class 派生类名：继承方式1 基类名1，
承 继承方式2 基类名2，...
与{
多
成员声明；

7章_继承与派生

7章_继承与派生

例1 void main() class A{ { A a; protected: B b; int X; b.Function(); }; a.X=5; class B:public A b.X=7; { } public: 错误，水平访问时 void Function(); 保护成员相当于 }; 私有成员 void B::Function() { 正确，垂直访问时 X=5; 保护成员相当于 }
例（续2）
#include <iostream> using namespace std; void main( ) { Rectangle rect; rect.InitR(2,3,20,10); //水平访问 rect.Move(3,2); // 直接调用基类公有成员函数 cout<<rect.GetX()<<","<<rect.GetY()<<"," <<rect.GetH()<<", "<<rect.GetW()<<endl; } 输出： 5,5,10,20
公有成员
例7_1：分析下列程序中的访问权限
class Point { public: void InitP(int xx,int yy); void Move(int xOff,int yOff); int GetX() {return X;} int GetY() {return Y;} private: int X,Y; }; //基类声明结束 void Point::InitP(int xx,int yy) //函数成员实现 { X=xx; Y=yy; } void Point::Move(int xOff,int yOff) { X+=xOff; Y+=yOff; }

第七章 继承和派生

第七章 继承和派生

第七章继承和派生一、基类和派生类1. 在C++中，可以从一个类派生出另一个类，前者称为基类或父类，后者称为派生类或子类。

一个派生类可以从一个或多个基类派生。

从一个基类派生的继承称单继承，从多个基类派生的继承称多继承。

2. 单继承定义格式：class 派生类：继承方式基类{ 派生类新定义成员；}；其中，“派生类”是从“基类”按指定的“继承关系”派生出的、新定义的一个类的名字。

“继承方式”有三种：(1)public 公有继承(2)private 私有继承(3) protected 保护继承3. 多继承定义格式：class 派生类：继承方式1 基类1，继承方式2 基类2，…{ 派生类新定义成员；}；4. 公有继承：当派生类的继承方式是public继承时，基类的public和protected成员的访问属性在派生类中保持不变，而基类的private成员不可访问，即基类的public和protected成员分别作为派生类的public和protected成员，派生类的其他成员可以直接访问它们。

例1：class B{ private: int x; protected: int y; public: int z;…};class A:public B{ private: int a; protected: int b; public: int c;…}; A a;（1）类B是基类，有3个数据成员x、y、z，分别是private、protected、public属性。

类A是派生类，有3个数据成员a、b、c，分别是private、protected、public属性。

由于类A是从类B公有派生的，类B中的public、protected属性的成员可继承到类A中来，且保持原来的属性。

故类A中有5个数据成员，即a、b、c、y。

（2）可以通过类A的对象a直接访问public成员，即z和c，并不能访问a、b、y数据成员。

第7章 继承和派生

第7章 继承和派生
12
例：7.3分析下列程序的结果：
class Base1 { public: Base1(int i ) { b1=i ; cout<<"Constructor of Base1."<<endl; }
void Print() const
private:
{ cout<<b1<<endl; }
int b1;
Member ( int i)
{ m=i ; cout<<"Constructor of Member."<<endl; } int GetM ( ) { return m; } private: int m; };
16
class Derived : public Base2, public Base1 ,public Base3
{ b1=i;
b2=j;
cout<<"Base's constructor called."<<b1<<","<<b2<<","<<endl;
} Base::~Base ( ) {cout<<"Base's }
destructor called."<<b1<<","<<b2<<","<<endl;
23
Base's destructor called.1,2,
27
§7.4多继承与虚基类
§7.4.1多继承中的二义性问题 产生二义性问题主要有两种情况： ㈠产生二义性问题的第一种情况如下例： 如P215图7.4(a) class Base1 { public: void fun(); };

计算机等级考试二级C++考点分析之继承和派生

计算机等级考试二级C++考点分析之继承和派生

7.1 继承和派⽣考点1 继承和派⽣的基本概念 继承的实质就是建造新的派⽣类。

派⽣类从⼀个或多个以前定义的基类继承数据和函数，同时增加或重新定义数据和操作。

这就产⽣了类的层次性。

换句话说，继承就是创建⼀个具有别的类属性和⾏为的新类的能⼒。

我们把这种通过特殊化已有的类来建⽴新类的过程，叫做“类的派⽣”，原有的类叫做“基类”，新建⽴的类叫做“派⽣类”从类的成员⾓度来看，派⽣类⾃动地将基类的所有数据成员和除了构造，析构函数之外的全部成员函数作为⾃⼰的成员，这叫做“继承”。

基类和派⽣类⼜可以分别叫做“⽗类”和“⼦类”。

在C++中有两种继承：单继承和多继承。

对于单继承，派⽣类中只能有⼀个基类；对于多继承，派⽣类可以有多个基类。

单继承和多继承的基类和派⽣类的关考点2 派⽣类的定义与构成 在C++中，定义派⽣类的⼀般形式为： 单继承的定义如下： class<派⽣类名>：<继承⽅式><基类名>｛<派⽣类新定义的成员>｝； 多继承的定义如下： class<派⽣类名>：<继承⽅式1><基类名1>，<继承⽅式2><基类名2>， …<继承⽅式n><基类名n>{<派⽣类新定义的成员>}； 其中，<继承⽅式>即派⽣类的访问控制⽅式，⽤于规定基类成员在派⽣类中的访问权限，即基类成员在派⽣类中是公有的、私有的或保护的。

常⽤的3种继承⽅式是公有继承(public)，私有继承(private)和保护继承(protected)。

缺省的类继承⽅式是私有继承private ． <派⽣类新定义的成员>是指定义的派⽣类⾃⼰的成员(除了从基类继承来的所有成员之外，新增加的数据成员和函数成员)。

派⽣类的成员由两部分构成：⼀部分是从基类继承得到的，⼀部分是⾃⼰定义的新成员，所有这些成员仍然分为公有(public)，私有(private)和保护(protected)3种访问性质。

C语言程序设计课件第07章继承与派生

C语言程序设计课件第07章继承与派生

造 C::C(){}或C::C(int i,int j){…}
、 表示先调用B类默认的构造函数或带默认形参值的构
析 构
造函数初始化B类数据成员。 C::C(int i,int j):B(i){…} 表示先调用B类带参数的构造函数初始化B类数据成
函 员。
数
29
#include<iostream> using namespace std; class B {public:
类 { public:
成
void InitR(float x, float y,float w, float h)
员
{InitP(x,y);W=w;H=h;}
的
float GetH() {return H;}
访
float GetW() {return W;}
问 private:
控
float W,H;
与 };
多 class B { public:
继 void setB(int); 承 void showB();
private:
int b;
};
class C : public A, private B { public:
void setC(int, int, int); void showC(); private: int c; };
类 class B0 {public:
型
void display()
兼 {cout<<"B0::display()"<<endl;} };
容 class B1: public B0
{public:
void display()

C++ 第7章 继承与派生

C++ 第7章 继承与派生

【 7.1 公司雇员档案的管理】
程序执行后的显示结果如下： zhang: 23 : 610.5 zhao: 27 : 824.75 li: 32 : 812.45 level:11 cui: 34 : 1200.5manageremployengineerdirector meng: 26 : 1420.1 speciality:E academic degree:M zhou: 38 : 1800.2 level:2 post:1
7.2 派生类说明及其构造和析构函数 【 7.2.2 有关成员存取权限问题的进一步讨论】
下面给出一个程序，请仔细分析其中的类继承与派生关系， 找出所有违反存取权限的使用情况（语句）
#include <iostream.h> class B {
int priDat;
protected: int proDat;
7.2 派生类说明及其构造和析构函数 【 7.2.1 派生类说明】
派生类说明的一般格式：
列出所给类的基类 每个基类说明格式为： <派生方式><基类名>
class<类名>:<基类说明表> { private: 派生方式：公有派生，保护派生或私有派生。 <私有成员表> Public 表示公有派生， protected: protected 表示保护派生， <保护成员表> private 表示私有派生。 public: 派生方式决定了从基类继承过来的成员在派生 类中的封装属性。 <公有成员表> };
第七章 继承与派生
计算机类
台式机类
便携式类
a) 单继承 输入设备类 输出设备类
硬盘类 b) 多继承 图 单继承与多继承

《C++语言程序设计》第七章：继承与派生

《C++语言程序设计》第七章：继承与派生
11
例7-1 公有继承举例 类
成 员 的 访 问 控 制
class Point //基类 基类Point类的声明 基类 类的声明 {public: //公有函数成员 公有函数成员 void InitP(float xx=0, float yy=0) {X=xx;Y=yy;} void Move(float xOff, float yOff) {X+=xOff;Y+=yOff;} float GetX() {return X;} float GetY() {return Y;} private: //私有数据成员 私有数据成员 float X,Y; };
23
class B1: public B0 { public: void display(){cout<<"B1::display()"<<endl;} }; class D1: public B1 { public: void display(){cout<<"D1::display()"<<endl;} }; void fun(B0 *ptr) { ptr->display();//"对象指针 成员名 } 对象指针->成员名 对象指针 成员名"
int main() { C obj; obj.setA(5); obj.showA(); obj.setC(6,7,9); obj.showC(); // obj.setB(6); 错误 // obj.showB(); 错误 return 0; }
14
类 成 员 的 访 问 控 制
私有继承(private) 私有继承
基类的public和protected成员都以 和 基类的 成员都以 private身份出现在派生类中，但基类 身份出现在派生类中， 身份出现在派生类中 成员不可直接访问 的private成员不可直接访问。 成员不可直接访问。 派生类中的成员函数可以直接访问基 类中的public和protected成员，但 成员， 类中的 和 成员 不能直接访问基类的private成员。 成员。 不能直接访问基类的 成员 通过派生类的对象不能直接访问基类 中的任何成员。 中的任何成员。

2019C语言程序设计课件第07章继承与派生.ppt

2019C语言程序设计课件第07章继承与派生.ppt
class 派生类名：继承方式 基类名1
{
成员声明；
}
6
继承方式
类 成 员 的 访 问 控 制

不同继承方式的影响主要体现在：
– 派生类成员对基类成员的访问权限 – 通过派生类对象对基类成员的访问权限

三种继承方式
– 公有继承 – 私有继承 – 保护继承
7
公有继承(public)
类 成 员 的 访 问 控 制
14
类 成 员 的 访 问 控 制
பைடு நூலகம்
class Rectangle: private Point { public: void InitR(float x, float y,float w, float h) {InitP(x,y);W=w;H=h;} void Move(float xOff, float yOff) { Point::Move(xOff,yOff);} float GetX() { return Point::GetX();} float GetY() { return Point::GetY();} float GetH() {return H;} float GetW() {return W;} private: float W,H; };
13
类 成 员 的 访 问 控 制
#include<iostream> using namespace std; 非法访问 void main() { Rectangle rect; rect.InitR(2,3,20,10); rect.Move(3,2); cout<<rect.GetX()<<','<<rect.GetY()<<',' <<rect.GetH()<<','<<rect.GetW(); }

c++7继承与派生

c++7继承与派生

1. 可以访问 f1( )和j1， 而不可以访问 i1 2. 可以访问 f1( )，而不可以访问 i1和 j1 3. 可以访问直接基类中的 f2( )和 j2以及间接基类中 的 f1( )和 j1，而不可以访问 i2和 i1 4. 可以访问直接基类中的 f2( )和间接基类中的 f1( ), 其它均不可以
A
B C
输入设备
键盘 鼠标 扫描仪
B. 派生类是基类定义的延续（虚函数） C. 派生类是基类的组合（多继承）
四、 单继承中成员访问权限
class A { public: void f1( ); protected:int j1; private: int i1; }; class C:public B { public: void f3( ); }; class B:public A { public: void f2( ); protected: int j2; private: int i2; };
void main() { A oba; cout<<oba.max<<endl; //合法吗？5 cout<<oba.min<<endl; //合法吗？6
B obb; cout<<obb.max<<endl; //合法吗？7 cout<<obb.min<<endl; //合法吗？8
}
//1、3、4合法；其余不合法
换句话说：
保持已有类的特性而构造新类的过程称为继承。 在已有类的基础上新增自己的特性而产生新类的 过程称为派生。
继承的思想方法是人类常用的分析问题的方 法——演绎
动物
猴子
猫
鸟
狮子

第7章继承和派生2

第7章继承和派生2

9
C++语言程序设计
多继承派生类的声明
class 派生类名：继承方式1 基类名1， 继承方式2 基类名2，...
{
成员声明；
}
注意：每一个“继承方式”，只用于限制对紧随其 后之基类的继承。
10
C++语言程序设计
class Derived: public Base1, private Base2 { public: Derived ( ); ~Derived ( ); };
类 成 员 的ቤተ መጻሕፍቲ ባይዱ访 问 控 制
class A { protected: int x; } int main() { A a; a.x=5; //错误 }
23
class A { protected: int x; } class B: public A{ public: void Function(); }; void B:Function() { x=5; //正确 }
17
C++语言程序设计
私有继承(private)
类 成 员 的 访 问 控 制
基类的public和protected成员都以private 身份出现在派生类中，但基类的private 成员不可直接访问。 派生类中的成员函数可以直接访问基类 中的public和protected成员，但不能直接 访问基类的private成员。 通过派生类的对象不能直接访问基类中 的任何成员。


3
C++语言程序设计
继承与派生问题举例
类 的 继 承 与 派 生
工具车 交通工具
汽车
小汽车
卡车
旅行车

继承和派生(2)

继承和派生(2)

被继承，对滚动条对象成员的使用是通过新类的内
部消息实现的。
多继承的定义
多重继承派生类定义的一般形式：
class 派生类名:继承方式 基类名1, … 继承方式 基类名n { 派生类新增的数据成员和成员函数 };
注意，在每个基类名之前必须有继承方式，如果缺省
继承方式，则表示从该基类私有派生。例如：
class c : public a,b {…}; // c 对 a 公有派生，对 b 私有派生 // c 对 a 私有派生，对 b 公有派生 // c 对 a,b 均为公有派生
class c : a, public b {…};
class c : public a, public b {… };
• 例 多重继承。 #include<iostream> #include<cstring> using namespace std; class Point{ //二维直角坐标点类 protected: float x,y; public: Point(float x,float y) { this->x=x; this->y=y; } void Setxy(float x,float y) { this->x=x; this->y=y; } void Getxy(float &x,float &y) { x=this->x; y=this->y; } void ShowP( ){ cout<<'('<<x<<','<<y<<')'; } };
}
}
class D:public B1,public B2{ protected: int z; public: D(int x,int y,int z):B1(x),B2(y) { this->z=z; cout<<"派生类D的构造函数!\n"; } ~D(){ cout<<"派生类D的析构函数!\n"; } }; int main(void){ D d(1,2,3); return 0; } 程序运行结果： • 说明派生类的对象：先调用各基类的 基类B1的构造函数! 构造函数，后执行派生类的构造函数。 基类B2的构造函数! 若某个基类仍是派生类，则这种调用 派生类D的构造函数! 基类构造函数的过程递归进行。 派生类D的析构函数! • 撤消派生类的对象：析构函数的调用 基类B2的析构函数! 顺序正好与构造函数的顺序相反。 基类B1的析构函数!

C语言程序设计课件第07章继承与派生

C语言程序设计课件第07章继承与派生

访
rect.InitR(2,3,20,10);
问
rect.Move(3,2); cout<<rect.GetX()<<','<<rect.GetY()<<','
控
<<rect.GetH()<<','<<rect.GetW();
制}
13
class Rectangle: private Point
{ public:
void Function(); };
void B::Function() { x=5;
cout<<x<<endl; } void C::Function() { x=15;
cout<<x<<endl; } void main() { B b;
b.Function(); C c; c.Function(); }
16
#include<iostream> using namespace std; class A { protected:
int x; }; class B: protected A { public:
void Function(); }; class C: private B { public:
问
float GetY() { return Point::GetY();} float GetH() {return H;}
控
float GetW() {return W;}
制 private:
float W,H;
};
14
类 #include<iostream> 成 using namespace std;

第7章 继承与派生

第7章 继承与派生

B 私有继承
特点： ①公有成员,保护成员私有成员， 派生类的其他成员函数可以直接访问它们，类外部，不能通过派生类的对象访 问它们
②私有成员×
③所有成员私有成员或不可访问的成员 如果进一步派生的，基类的全部成员将无法在新的派生类中被访问。中止了 基类的继续派生，因此，一般情况下私有继承的使用比较少
成员名 Point:: X, Y move() ShowXY() radius area() private public public
访问权限 不可访问 public public private public
ShowCircle()
Circle()
public
public
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
/********************** * p7_1.cpp * * Circle 类的使用 * ***********************/ #include "Circle.h" using namespace std; int main() { Circle Cir1(100,200,10); Cir1.ShowCircle(); cout<<"area is:"<<Cir1.area()<<endl; Cir1.move(10,20); Cir1.ShowXY(); return 0; }
继承方式，系统默认为私有继承 【例如】ClockAlarmClock:
class Clock 派生类AlarmClock的成员构成图(表) { private: 类名 成员名 int H,M,S; public: AlarmClock Clock H, M, S void SetTime(int H=0,int M=0,int S=0); :: :: void ShowTime(); SetTime() Clock(int H=0,int M=0,int S=0); ~Clock(); ShowTime() }; class AlarmClock: public Clock AH, AM, OpenAlarm { private: SetAlarm() int AH,AM; //响铃的时间 bool OpenAlarm; //是否关闭闹钟 SwitchAlarm() public: SetAlarm（int AH, int AM）; //设置响铃时间 ShowTime() SwitchAlarm(bool Open=true); //打开/关闭闹铃 ShowTime(); //显示当前时间与闹铃时间 AlarmClock() }
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

第七章派生与继承2/*7.4多继承与虚基类7.4.1多继承中的二义性问题解决方式1<对象名>.<基类名>::<成员名> //数据成员<对象名>.<基类名>::<成员名>(<参数名>) //成员函数*//*#include<iostream>using namespace std;class Base1{public:int date;void fun(){cout<<"Member of Base1"<<";base1="<<date<<endl;} };class Base2{public:int date;void fun(){cout<<"Member of Base2"<<";base2="<<date<<endl;} };class Derived:public Base1,public Base2{public:int date;void fun(){cout<<"Member of Derived"<<";Derived="<<date<<endl;} };int main(){Derived obj;obj.date=1;obj.fun();obj.Base1::date=2;obj.Base1::fun();obj.Base2::date=3;obj.Base2::fun();return 0;}*//*#include <iostream>using namespace std;class Base{public:int date;void fun(){cout<<"This is Base"<<"; base="<<date<<endl;}};class Derived11:public Base{public:int date;void fun(){cout<<"This is Derived11"<<"; Derived11="<<date<<endl;}};class Derived12:public Base{public:int date;void fun(){cout<<"This is Derived12"<<"; Derived12="<<date<<endl;}};class Derived2:public Derived11,public Derived12{public:int date;void fun(){cout<<"This is Derived2"<<"; Derived2="<<date<<endl;}};int main(){Derived2 obj;obj.date=1;obj.fun();//obj.Base::date=2;//obj.Base::fun();obj.Derived11::date=3;obj.Derived11::fun();obj.Derived12::date=4;obj.Derived12::fun();return 0;}*//*7.4.2虚基类的定义虚基类格式：class<类名>:virtual<继承方式><基类名>virtual与继承方式的位置无关，但是必须位于虚基类之前，切只对紧后面的基类名起作用。

7.4.3虚基类的构造函数由于派生类的对象中只有一个虚基类对象，所以在建立一个派生类的对象时，为保证虚基类对象只被初始化一次。

这个虚基类构造函数只能被调用一次，当在构造函数的初始化列表中同时出现对虚基类和非虚基类构造函数的调用时虚基类的构造函数先于非基类的构造函数被调用；*//* #include<iostream>using namespace std;class Base{public:Base(char i){cout<<"Base'scons"<<i<<endl;}~Base(){cout<<"Base'sdes."<<endl;}private:// char c;};class Derived11:virtual public Base{public:Derived11(char i,char j):Base(i){cout<<"Derived11's cons"<<j<<endl;} ~Derived11(){cout<<"Derived11's des."<<endl;}private://char b;};class Derived12:virtual public Base{public:Derived12(char i,char j):Base(i){cout<<"Derived12's cons"<<j<<endl;} ~Derived12(){cout<<"Derived12's des."<<endl;}private://char f;};class Derived2:public Derived11,public Derived12{public:Derived2(char i,char j,char k,char l,char m,char n):Derived12(k,l),Derived11(i,j),Base(i),aa(m){cout<<"Derived2's cons"<<n<<endl;}~Derived2(){cout<<"Derived2's des."<<endl;}private:Base aa;};int main(){ Derived2 obj('a','b','c','d','e','f');return 0;}*//*7.5子类型关系1.子类型关系可以传递但不可逆，公有继承可以实现子类型关系，通过公有继承，派生类得到了基类的除了构造函数析构函数之外的所有成员。

所以派生类对象就可以作为基类的对象使用，但是他只能使用从基类继承的成员，2.具有子类型关系的基类和平派生类的对象之间满足如下赋值兼容规则。

（1）公有派生类的对象可以赋值给基类的对象，即公有派生类对象中从基类继承来的成员。

（2）公有派生类的对象可以初始化基类的引用（3）公有派生类的地址可以赋值给指向基类的指针。

*//*#include <iostream>using namespace std;class Base{public :void Who(){cout<<"class Base. "<<endl;}};class Derived1:public Base{public :void Who(){cout<<"class Derived1. "<<endl;}};class Derived2:public Base{public :void Who(){cout<<"class Derived2. "<<endl;}};int main(){Base obj1,*p;Derived1 obj2;Derived2 obj3;p=&obj1;p->Who();p=&obj2;p->Who();p=&obj3;p->Who();obj2.Who();obj3.Who();return 0;}*//*7.6虚函数与多态性一个面向对象的系统常常要求一组具有基本语义的方法能在同意接口下为不同的对象服务，这就是多态性多态性分为编译多态性和运行多态性7.6.2虚函数1，在非静态成员函数声明前加virtual就叫虚函数。

2，在派生类中重定义虚函数时，函数名，形参表和返回值类型必须保持不变。

3，虚函数在派生类中被定义后，仍是虚函数，在派生类中再次被定义后还是虚函数，不管是否加了virtual 4，对虚函数的调用分多态调用和非多态调用多态调用是指借助于指针和引用的调用，非多态调用是指不借助于指针和引用的调用，通过成员访问运算符"." 进行的。

对实函数的任何形式的调用都是非多态的。

下面是如何实现动态绑定机制的*//*#include<iostream>using namespace std;class Base{char base_name[10];public:Base(){strcpy (base_name,"BASE");}virtual char * my_name(){return base_name;}char * class_name(){return base_name;}};class Derived:public Base{char derived_name[10];public:Derived(){strcpy(derived_name,"DERIVED");}virtual char * my_name(){return derived_name;}char * class_name(){return derived_name;}};void show_ptr(Base *p){cout<<endl<<p->my_name()<<" "<<p->class_name();}void show_ref(Base &r){cout<<endl<<r.my_name()<<" "<<r.class_name();}int main(){Base bb;Derived dd;cout<<endl;show_ptr(&bb);cout<<"<==应该显示'BASE BASE'"; show_ptr(&dd);cout<<"<==应该显示'DERIVED BASE'"; cout<<endl;show_ref(bb);cout<<"<==应该显示'BASE BASE'";show_ref(dd);cout<<"<==应该显示'BASEDERIVED BASE'";cout<<endl;cout<<endl<<bb.Base::my_name()<<""<<bb.Base::class_name();cout<<"<==应该显示'BASE BASE'";cout<<endl<<dd.Base::my_name()<<""<<dd.Base::class_name();cout<<"<==应该显示'BASE BASE'";return 0;} *//*7.6.3虚析构函数只要派生类这种对析构函数进行了专门的定义，其基类的析构函数就应该声明为虚析构函数。