虚函数与纯虚函数

  相关概念：

1、多态性

　　指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种形式的多态：编译时多态性，运行时多态性。

　　a.编译时多态性：通过重载函数实现

　　b 运行时多态性：通过虚函数实现。

　2、虚函数

　　虚函数是在基类中被声明为virtual，并在派生类中重新定义的成员函数，可实现成员函数的动态重载。 在使用指针和引用调用时, 会表现出多态性。

　3、抽象类

　　包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。

 

 

虚函数与纯虚函数：

1．虚函数的定义形式：   virtual ReturnType name{method body} 
   纯虚函数的定义形式： virtual ReturnType name{ } = 0; 
   在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然而虚函数却是动态绑定（run-time bind），而且被两者修饰的函数生命周期（life recycle）也不一样。

虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。 在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了 这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

能够在编译时就能够确定哪个重载的成员函数被调用的情况被称做先期联编（early binding），而在系统能够在运行时，能够根据其类型确定调用哪个重载的成员函数的能力，称为多态性，或叫滞后联编(late binding)，下面我们要看下面的例程，就是滞后联编，滞后联编正是解决多态问题的方法。 

#include <iostream>      
using namespace std;    
    
class Vehicle  
{    
public:    
    Vehicle(float speed,int total)  
    {  
        Vehicle::speed = speed;  
        Vehicle::total = total;  
    }  
    virtual void ShowMember()//虚函数  
    {  
        cout< 
    }  
protected:    
    float speed;  
    int total;  
};    
class Car:public Vehicle    
{    
public:    
    Car(int aird,float speed,int total):Vehicle(speed,total)    
    {    
        Car::aird = aird;    
    }  
    virtual void ShowMember()//虚函数,在派生类中，由于继承的关系，这里的virtual也可以不加  
    {  
        cout< 
    }  
public:    
    int aird;  
};  
  
void test(Vehicle &temp)  
{  
    temp.ShowMember();  
}  
  
int main()    
{    
    Vehicle a(120,4);  
    Car b(180,110,4);  
    test(a);  
    test(b);  
    cin.get();  
}

虚函数的定义要遵循以下重要规则： 

　　1.如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，那么即使加上了virtual关键字，也是不会进行滞后联编的。 

　　2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。 

　　3.静态成员函数不能是虚函数,因为静态成员函数的特点是不受限制于某个对象。 

　　4.内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义定义，但是在编译的时候系统仍然将它看做是非内联的。 

　　5.构造函数不能是虚函数，因为构造的时候，对象还是一片位定型的空间，只有构造完成后，对象才是具体类的实例。 

　　6.析构函数可以是虚函数,而且通常声名为虚函数。 

　　说明一下，虽然我们说使用虚函数会降低效率，但是在处理器速度越来越快的今天，将一个类中的所有成员函数都定义成为virtual总是有好处的，它除了会增加一些额外的开销是没有其它坏处的，对于保证类的封装特性是有好处的。

　　对于上面虚函数使用的重要规则6，我们有必要用实例说明一下，为什么具备多态特性的类的析构函数，有必要声明为virtual。 

　　代码如下：

#include <iostream>      
using namespace std;    
    
class Vehicle  
{    
public:   
    Vehicle(float speed,int total)  
    {  
        Vehicle::speed=speed;  
        Vehicle::total=total;  
    }  
    virtual void ShowMember()  
    {  
        cout< 
    }  
    virtual ~Vehicle()  
    {  
        cout<<"载入Vehicle基类析构函数"< 
        cin.get();  
    }  
protected:    
    float speed;  
    int total;  
};    
class Car:public Vehicle    
{    
public:    
    Car(int aird,float speed,int total):Vehicle(speed,total)    
    {    
        Car::aird=aird;    
    }  
    virtual void ShowMember()  
    {  
        cout< 
    }  
    virtual ~Car()  
    {  
        cout<<"载入Car派生类析构函数"< 
        cin.get();  
    }  
protected:    
    int aird;  
};    
  
void test(Vehicle &temp)  
{  
    temp.ShowMember();  
}  
void DelPN(Vehicle *temp)  
{  
    delete temp;  
}  
void main()  
{    
    Car *a=new Car(100,1,1);  
    a->ShowMember();  
    DelPN(a);  
    cin.get();  
}

　　从上例代码的运行结果来看，当调用DelPN(a);后，在析构的时候，系统成功的确定了先调用Car类的析构函数，而如果将析构函数的virtual修饰去掉，再观察结果，会发现析构的时候，始终只调用了基类的析构函数，由此我们发现，多态的特性的virtual修饰，不单单对基类和派生类的普通成员函数有必要，而且对于基类和派生类的析构函数同样重要。

 

2. 如果一个类中含有纯虚函数，那么任何试图对该类进行实例化的语句都将导致错误的产生，因为抽象基类（ABC）是不能被直接调用的。必须被子类继承重载以后，根据要求调用其子类的方法。定义一个函数为纯虚函数，代表函数没有被实现 ，定义他是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

class CA 
{ 
public: 
virtual void fun() = 0; // 说明fun函数为纯虚函数 
virtual void fun1(); 
};

class CB 
{ 
public: 
virtual void fun(); 
virtual void fun1(); 
};

// CA，CB类的实现 
...

void main() 
{ 
CA a; // 不允许，因为类CA中有纯虚函数 
CB b; // 可以，因为类CB中没有纯虚函数 
... 
}