C++虚函数

　　简单的说，虚函数就是被virtual修饰的成员函数。其目的就是为了实现类的多态性，需要了解一下几个问题：

1.一个函数是虚函数，并不是说这个函数不被实现；

2.定义一个函数为虚函数的目的，是为了从基类调用派生类的同名函数；

3.如果一个函数被定义为纯虚函数，代表这个函数没有被实现，需要子类实现。

举例说明：

class A 
{ 
public: 
    virtual void foo() 
    { 
        cout<<"A::f()"<<endl; 
    } 
}; 

class B : public A 
{ 
public: 
    void foo() 
    { 
        cout<<"B::f()"<<endl; 
    } 
};

void main() 
{ 
    B b; 
    b.foo();        //1.子类调用函数 

   ((A)b).foo();    //2.转换成基类调用 

    A* p = &b; 
    p->foo();        //3.通过基类指针调用 

    A a; 
    a.foo();        //4.基类调用 
}

结果：

　　虽然基类有虚函数foo()的实现，但其派生类仍然会调用其本身的foo函数。

通过强制类型转换将派生类转成基类，则会调用基类的foo函数。

通过基类调用派生类的同名函数，需要以指针的形式调用。

纯虚函数：

　　纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”

　　为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
　　在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。
　　为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。
　　声明了纯虚函数的类是一个抽象类。所以，用户不能创建类的实例，只能创建它的派生类的实例。
　　纯虚函数最显著的特征是：它们必须在继承类中重新声明函数（不要后面的＝0，否则该派生类也不能实例化），而且它们在抽象类中往往没有定义。
　　定义纯虚函数的目的在于，使派生类仅仅只是继承函数的接口。
　　纯虚函数的意义，让所有的类对象（主要是派生类对象）都可以执行纯虚函数的动作，但类无法为纯虚函数提供一个合理的缺省实现。

再看一个例子：

class A 
{ 
public: 
    virtual void foo() = 0;//定义为纯虚函数 
};

class B : public A 
{ 
public: 
    void foo() 
    { 
        cout<<"B::f()"<<endl; 
    } 
};

A a;            //错误，无法实例化 
B b; 
((A)b).foo();    //错误

正确的调用方法是：

B b; 
b.foo();        //1.子类调用函数

A* p = &b; 
p->foo();        //2.通过基类指针调用

结果：

但是对于析构函数，问题就不是这么简单了，如果通过delete基类的指针销毁派生类的对象，会出现一些问题，例如：

class A
{
public:
    A()
    {
        cout<<"A()"<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<endl;
    }
};

class B : public A
{
public:
    B()
    {
        cout<<"B()"<<endl;
    }
    ~B()
    {
        cout<<"~B()"<<endl;
    }
};

void main()
{
    A* pA = new B;
    delete pA;
}

结果：

可见派生类的析构函数并没有被调用，如果派生类析构函数中含有释放资源的操作，就会产生意想不到的结果。为了保证基类的析构函数被调用，我们可以将基类的析构函数定义为虚函数。

class A
{
public:
    A()
    {
        cout<<"A()"<<endl;
    }
    virtual ~A()    //定义为虚函数
    {
        cout<<"~A()"<<endl;
    }
};

class B : public A
{
public:
    B()
    {
        cout<<"B()"<<endl;
    }
    ~B()
    {
        cout<<"~B()"<<endl;
    }
};

void main()
{
    A* pA = new B;
    delete pA;
}