C++ 虚函数

来源：互联网发布：放弃保研知乎编辑：程序博客网时间：2024/05/21 09:44

转自：http://blog.chinaunix.net/uid-26851094-id-3327323.html

http://www.cnblogs.com/jin521/p/5602190.html

面向对象的三大特征：

封装
多态
什么是多态?
相同对象收到不同消息或不同对象收到相同消息时产生的不同的动作。
继承

普通虚函数
虚析构函数
纯虚函数
抽象类
接口类
隐藏 vs 覆盖
隐藏与覆盖之间的关系
早绑定和晚绑定
虚函数表

虚函数为了重载和多态的需要，在基类中是由定义的，即便定义是空，所以子类中可以重写也可以不写基类中的函数！

纯虚函数在基类中是没有定义的，必须在子类中加以实现，很像java中的接口函数！

虚函数

引入原因：为了方便使用多态特性，我们常常需要在基类中定义虚函数。

class Cman

{

public:

virtual void Eat(){……};

void Move();

private:

};

class CChild : public CMan

{

public:

virtual void Eat(){……};

private:

};

CMan m_man;

CChild m_child;

//这才是使用的精髓，如果不定义基类的指针去使用，没有太大的意义

CMan *p ;

p = &m_man ;

p->Eat(); //始终调用CMan的Eat成员函数，不会调用 CChild 的

p = &m_child;

p->Eat(); //如果子类实现(覆盖)了该方法，则始终调用CChild的Eat函数

//不会调用CMan 的 Eat 方法；如果子类没有实现该函数，则调用CMan的Eat函数

p->Move(); //子类中没有该成员函数，所以调用的是基类中的

纯虚函数

引入原因：

1、同“虚函数”；

2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

//纯虚函数就是基类只定义了函数体，没有实现过程定义方法如下

// virtual void Eat() = 0; 直接=0 不要在cpp中定义就可以了

//纯虚函数相当于接口，不能直接实例话，需要派生类来实现函数定义

//有的人可能在想，定义这些有什么用啊，我觉得很有用

//比如你想描述一些事物的属性给别人，而自己不想去实现，就可以定

//义为纯虚函数。说的再透彻一些。比如盖楼房，你是老板，你给建筑公司

//描述清楚你的楼房的特性，多少层，楼顶要有个花园什么的

//建筑公司就可以按照你的方法去实现了，如果你不说清楚这些，可能建筑

//公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了

虚函数和纯虚函数区别

观点一：

类里声明为虚函数的话,这个函数是实现的，哪怕是空实现，它的作用就是为了能让这个函数在它的子类里面可以被重载，这样的话，这样编译器就可以使用后期绑定来达到多态了

纯虚函数只是一个接口，是个函数的声明而已，它要留到子类里去实现。

class A{

protected:

void foo();//普通类函数

virtual void foo1();//虚函数

virtual void foo2() = 0;//纯虚函数

}

观点二：

虚函数在子类里面也可以不重载的；但纯虚必须在子类去实现，这就像Java的接口一样。通常我们把很多函数加上virtual，是一个好的习惯，虽然牺牲了一些性能，但是增加了面向对象的多态性，因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现

观点三：

虚函数的类用于“实作继承”，继承接口的同时也继承了父类的实现。当然我们也可以完成自己的实现。纯虚函数的类用于“介面继承”，主要用于通信协议方面。关注的是接口的统一性，实现由子类完成。一般来说，介面类中只有纯虚函数的。

观点四：

错误：带纯虚函数的类叫虚基类，这种基类不能直接生成对象，而只有被继承，并重写其虚函数后，才能使用。这样的类也叫抽象类。

虚函数是为了继承接口和默认行为

纯虚函数只是继承接口，行为必须重新定义
////////////////////////////////////////////////////////////////////////////////////
虚基类的初始化　　虚基类的初始化与一般多继承的初始化在语法上是一样的,但构造函数的调用次序不同.
　　派生类构造函数的调用次序有三个原则:
　　(1)虚基类的构造函数在非虚基类之前调用;
　　(2)若同一层次中包含多个虚基类,这些虚基类的构造函虚基类和非虚基类的区别虚基类和非虚基类的区别数按它们说明的次序调用;
　　(3)若虚基类由非虚基类派生而来,则仍先调用基类构造函数,再调用派生类的构造函数.
编辑本段
C++的虚基类　　在派生类继承基类时，加上一个virtual关键词则为虚拟基类继承，如：
　　class derive:virtual public base
　　{
　　};
　　虚基类主要解决在多重继承时，基类可能被多次继承，虚基类主要提供一个基类给派生类，如：
　　class B
　　{
　　};
　　class D1:public B
　　{
　　};
　　class D2:public B
　　{
　　};
　　class C:public D1,public D2
　　{
　　};
　　这里C在D1,D2上继承，但有两个基类，造成混乱。因而使用虚基类，即：
　　classB
　　{
　　};
　　class D1:virtual public B
　　{
　　};
　　class D2:virtual publicB
　　{
　　};
　　class C:public D1,public D2
编辑本段
在使用虚基类时要注意：　　(1) 一个类可以在一个类族中既被用作虚基类，也被用作非虚基类。
　　(2) 在派生类的对象中，同名的虚基类只产生一个虚基类子对象，而某个非虚基类产生各自的子对象。
　　(3) 虚基类子对象是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。
　　(4) 最远派生类是指在继承结构中建立对象时所指定的类。
　　(5) 派生类的构造函数的成员初始化列表中必须列出对虚基类构造函数的调用；如果未列出，则表示使用该虚基类的缺省构造函数。
　　(6) 从虚基类直接或间接派生的派生类中的构造函数的成员初始化列表中都要列出对虚基类构造函数的调用。但仅仅用建立对象的最远派生类的构造函数调用虚基类的构造函数，而该派生类的所有基类中列出的对虚基类的构造函数的调用在执行中被忽略，从而保证对虚基类子对象只初始化一次。
　　(7) 在一个成员初始化列表中同时出现对虚基类和非虚基类构造函数的调用时，虚基类的构造函数先于非虚基类的构造函数执行。
静态联编：在程序链接阶段就可以确定的调用。

动态联编：在程序执行时才能确定的调用。

静态多态 vs 动态多态

[-:>静态多态也叫做早绑定

class Rect       //矩形类{public:    int calcArea(int width);    int calcArea(int width,int height);};

如上面的代码，他们函数名相同，参数个数不同，一看就是互为重载的两个函数

1 int main()2 {3     Rect.rect;4     rect.calcArea(10);5     rect.calcArea(10,20);6     return 0;7 }

程序在编译阶段根据参数个数确定调用哪个函数。这种情况叫做静态多态（早绑定）

[-:>动态多态也叫做晚绑定

比如计算面积当给圆形计算面积时使用圆形面积的计算公式，给矩形计算面积时使用矩形面积的计算公式。也就是说有一个计算面积的形状基类，圆形和矩形类派生自形状类，圆形与矩形的类各有自己的计算面积的方法。可见动态多态是以封装和继承为基础的。

 1 class Shape//形状类 2 { 3 public: 4     double calcArea() 5     { 6         cout<<"calcArea"<<endl; 7         return 0; 8     } 9 }；10 class Circle:public Shape      //公有继承自形状类的圆形类11 {12 public:13     Circle(double r);14     double calcArea();15 private:16     double m_dR;17 };18 double Circle::calcArea()19 {20     return 3.14*m_dR*m_dR;21 }22 class Rect:public Shape       //公有继承自形状类的矩形类23 {24 public:25     Rect(double width,double height);26     double calArea();27 private:28     double m_dWidth;29     double m_dHeight;30 }；31 double Rect::calcArea()32 {33     return m_dWidth*m_dHeight;34 }35 int main()36 {37     Shape *shape1=new Circle(4.0);38     Shape *shape2=new Rect(3.0,5.0);39     shape1->calcArea();40     shape2->calcArea();41     .......42     return 0;43 }

如果打印结果的话，以上程序结果会打印两行"calcArea"，因为调用到的都是父类的calcArea函数，并不是我们想要的那样去分别调用各自的计算面积的函数。如果要想实现动态多态则必须使用虚函数

关键字 virtual ->虚函数

用virtual去修饰成员函数使其成为虚函数

所以以上函数的修改部分如下

class Shape{public:    virtual double calcArea(){...}//虚函数    ....                                      //其他部分private:    ....}；....class Circle:public Shape{public:    Circle(double r);    virtual double calcArea();//此处的virtual不是必须的，如果不加，系统会自动加                                        //上，如果加上则会在后续的时候看的比较明显（推荐加上）    ....private:    ....};....class Rect:public Shape{    Rect(double width,double height);    virtual double calcArea();private    ....};....

这样就可以达到预期的结果了

多态中存在的问题

[-:>内存泄漏，一个很严重的问题

例如上面的程序中，如果在圆形的类中定义一个圆心的坐标，并且坐标是在堆中申请的内存，则在mian函数中通过父类指针操作子类对象的成员函数的时候是没有问题的，可是在销毁对象内存的时候则只是执行了父类的析构函数，子类的析构函数却没有执行，这会导致内存泄漏。部分代码如下(想去借助父类指针去销毁子类对象的时候去不能去销毁子类对象)

如果delete后边跟父类的指针则只会执行父类的析构函数，如果delete后面跟的是子类的指针，那么它即会执行子类的析构函数，也会执行父类的析构函数

class Circle:public Shape{public:    Circle(int x,int y,double r);    ~Circle();    virtual double calcArea();    ....private:    double m_dR;    Coordinate *m_pCenter;      //坐标类指针    ....};Circle::Circle(int x,int y,double r){    m_pCenter=new Coordinate(x,y);    m_dR=r;}Circle::~Circle(){    delete m_pCenter;    m_pCenter-NULL;}....int main(){    Shape *shape1=new Circle(3,5,4.0);    shape1->calcArea();    delete shape1;    shape1=NULL;    return 0;}

可见我们必须要去解决这个问题，不解决这个问题当使用的时候都会造成内存泄漏。面对这种情况则需要引入虚析构函数

虚析构函数

关键字 virtual ->析构函数

之前是使用virtual去修饰成员函数，这里使用virtual去修饰析构函数，部分代码如下

 1 class Shape 2 { 3 public: 4     .... 5     virtual ~Shape(); 6 private: 7     .... 8 }; 9 class Circle:public Shape10 {11 public:12     virtual ~Circle();//与虚函数相同，此处virtual可以不写，系统将会自动添加，建议写上13     ....14 };15 ....

这样父类指针指向的是哪个对象，哪个对象的构造函数就会先执行，然后执行父类的构造函数。销毁的时候子类的析构函数也会执行。

virtual关键字可以修饰普通的成员函数，也可以修饰析构函数，但并不是没有限制

virtual在函数中的使用限制

普通函数不能是虚函数，也就是说这个函数必须是某一个类的成员函数，不可以是一个全局函数，否则会导致编译错误。
静态成员函数不能是虚函数 static成员函数是和类同生共处的，他不属于任何对象，使用virtual也将导致错误。
内联函数不能是虚函数如果修饰内联函数如果内联函数被virtual修饰，计算机会忽略inline使它变成存粹的虚函数。
构造函数不能是虚函数，否则会出现编译错误。

虚函数实现原理

【：-》首先：什么是函数指针？

　　指针指向对象称为对象指针，指针除了指向对象还可以指向函数，函数的本质就是一段二进制代码，我们可以通过指针指向这段代码的开头，计算机就会从这个开头一直往下执行，直到函数结束，并且通过指令返回回来。函数的指针与普通的指针本质上是一样的，也是由四个基本的内存单元组成，存储着内存的地址，这个地址就是函数的首地址。

【：-》多态的实现原理

虚函数表指针：类中除了定义的函数成员，还有一个成员是虚函数表指针（占四个基本内存单元），这个指针指向一个虚函数表的起始位置，这个表会与类的定义同时出现，这个表存放着该类的虚函数指针，调用的时候可以找到该类的虚函数表指针，通过虚函数表指针找到虚函数表，通过虚函数表的偏移找到函数的入口地址，从而找到要使用的虚函数。

当实例化一个该类的子类对象的时候，（如果）该类的子类并没有定义虚函数，但是却从父类中继承了虚函数，所以在实例化该类子类对象的时候也会产生一个虚函数表，这个虚函数表是子类的虚函数表，但是记录的子类的虚函数地址却是与父类的是一样的。所以通过子类对象的虚函数表指针找到自己的虚函数表，在自己的虚函数表找到的要执行的函数指针也是父类的相应函数入口的地址。

如果我们在子类中定义了从父类继承来的虚函数，对于父类来说情况是不变的，对于子类来说它的虚函数表与之前的虚函数表是一样的，但是此时子类定义了自己的（从父类那继承来的）相应函数，所以它的虚函数表当中管于这个函数的指针就会覆盖掉原有的指向父类函数的指针的值，换句话说就是指向了自己定义的相应函数，这样如果用父类的指针，指向子类的对象，就会通过子类对象当中的虚函数表指针找到子类的虚函数表，从而通过子类的虚函数表找到子类的相应虚函数地址，而此时的地址已经是该函数自己定义的虚函数入口地址，而不是父类的相应虚函数入口地址，所以执行的将会是子类当中的虚函数。这就是多态的原理。

函数的覆盖和隐藏

父类和子类出现同名函数称为隐藏。

父类对象.函数函数名(...); //调用父类的函数
子类对象.函数名(...); //调用子类的函数
子类对象.父类名::函数名(...);//子类调用从父类继承来的函数。

父类和子类出现同名虚函数称为覆盖

父类指针=new 子类名(...);父类指针->函数名(...);//调用子类的虚函数。

虚析构函数的实现原理

[:->虚析构函数的特点：

当我们在父类中通过virtual修饰析构函数之后，通过父类指针指向子类对象，通过delete接父类指针就可以释放掉子类对象

[:->理论前提：

执行完子类的析构函数就会执行父类的析构函数

原理：

如果父类当中定义了虚析构函数，那么父类的虚函数表当中就会有一个父类的虚析构函数的入口指针，指向的是父类的虚析构函数，子类虚函数表当中也会产生一个子类的虚析构函数的入口指针，指向的是子类的虚析构函数，这个时候使用父类的指针指向子类的对象，delete接父类指针，就会通过指向的子类的对象找到子类的虚函数表指针，从而找到虚函数表，再虚函数表中找到子类的虚析构函数，从而使得子类的析构函数得以执行，子类的析构函数执行之后系统会自动执行父类的虚析构函数。这个是虚析构函数的实现原理。

纯虚函数：

纯虚函数的定义

1 class Shape2 {3 public:4     virtual  double calcArea()//虚函数5     {....}6     virtual  double calcPerimeter()=0;//纯虚函数7     ....8 };

纯虚函数没有函数体，同时在定义的时候函数名后面要加“=0”。

纯虚函数的实现原理：

在虚函数原理的基础上，虚函数表中，虚函数的地址是一个有意义的值，如果是纯虚函数就实实在在的写一个0。

含有纯虚函数的类被称为抽象类

含有纯虚函数的类被称为抽象类，比如上面代码中的类就是一个抽象类，包含一个计算周长的纯虚函数。哪怕只有一个纯虚函数，那么这个类也是一个抽象类，纯虚函数没有函数体，所以抽象类不允许实例化对象，抽象类的子类也可以是一个抽象类。抽象类子类只有把抽象类当中的所有的纯虚函数都做了实现才可以实例化对象。

对于抽象的类来说，我们往往不希望它能实例化，因为实例化之后也没什么用，而对于一些具体的类来说，我们要求必须实现那些要求（纯虚函数），使之成为有具体动作的类。

近含有纯虚函数的类称为接口类

如果在抽象类当中仅含有纯虚函数而不含其他任何东西，我们称之为接口类。

没有任何数据成员
仅有成员函数
成员函数都是纯虚函数

class Shape{    virtual double calcArea()=0//计算面积    virtual double calcPerimeter()=0//计算周长};

实际的工作中接口类更多的表达一种能力或协议

比如

 1 class Flyable//会飞 2 { 3 public: 4     virtual void takeoff()=0;//起飞 5     virtual void land()=0;//降落 6 }； 7 class Bird:public Flyable 8 { 9 public:10     ....11     virtual void takeoff(){....}12     virtual void land(){....}13 private:14     ....15 };16 void flyMatch(Flyable *a,Flyable *b)//飞行比赛17 //要求传入一个会飞对象的指针，此时鸟类的对象指针可以传入进来18 {19     ....20     a->takeoff();21     b->takeoff();22     a->land();23     b->land();24 }

例如上面的代码，定义一个会飞的接口，凡是实现这个接口的都是会飞的，飞行比赛要求会飞的来参加，鸟实现了会飞的接口，所以鸟可以参加飞行比赛，如果复杂点定义一个能够射击的接口，那么实现射击接口的类就可以参加战争之类需要会射击的对象，有一个战斗机类通过多继承实现会飞的接口和射击的接口还可以参加空中作战的函数呢

阅读全文

0 0