虚函数和纯虚函数

一，相似概念 

1、多态性
  指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。
  a.编译时多态性：通过重载函数实现
  b 运行时多态性：通过虚函数实现。
  2、虚函数
  虚函数是在基类中被声明为virtual，并在派生类中重新定义的成员函数，可实现成员函数的动态重载
  3、抽象类
  包含纯虚函数的类称为抽象类。由于抽象类包含了纯虚函数，所以不能定义抽象类的对象

二，两者的区别

虚函数：a:基类本身可以实例化对象（创建对象）；

              b:基类中必须给出虚函数的实现；

              c:“实体继承”

纯虚函数：a:基类本身不可以实例化对象；
                 b:基类纯虚函数可给可不给函数实现；
                c:“接口继承”
eg:
#include <iostream>
using namespace std;


 class A
  {
  public:
  A(){;}
  virtual ~A(){;}
  void f1(){cout<<"A::f1"<<endl;}
 virtual void f2(){cout<<"A::f2"<<endl;}
  virtual void f3()=0;
  };


  class B : public A
  {
  public:
  B(){;}
  virtual ~B(){;}
  void f1(){cout<<"B::f1"<<endl;}
  void f2(){cout<<"B::f2"<<endl;}
  virtual void f3(){cout<<"B::f3"<<endl;}
  };


  int main(int argc, char* argv[])
  {
  A *m_j=new B();
  m_j->f1();
  m_j->f2();
  m_j->f3();
  delete m_j;
  return 0;
  }
结果是：A：：f1
           B::f2
           B::f3
从输出结果我们可以看出声明为visual和非visual的输出结果是不一样的，成员函数的动态重载
（声明为visual的函数 指针指向的为new的类型，非visual函数 与指针申明的类型一致）
如果在main函数里面 A *m_A = new A()；会报错A为一个抽象基类，不能实例化一个对象
如果去掉里面的纯虚函数就可以了
在看个例子：
class FBase
{
    public:
    FBase()
    {
        cout<<"FBase::FBase()"<<endl;
    }
    ~FBase()
    {
        cout<<"FBase::~FBase()"<<endl;
    }
};


class SubF:public FBase
{
    public:
    SubF()
    {
        cout<<"SubF::SubF()"<<endl;
    }
    ~SubF()
    {
        cout<<"SubF::~SubF()"<<endl;
    }
};
int main()
{
    FBase *base = (FBase*)new SubF();
    delete base;
    cout<<"###############################"<<endl;
    SubF *sub = (SubF*)new FBase();
    delete sub;
    return 0;
}
输出结果：
FBase::FBase()
SubF::SubF()                //调用两次构造函数是因为new 的是子类，要先创建父类在创建子类
FBase::~FBase()          //因为不是virtual 子类强制转化为父类所以调用
###############################
FBase::FBase()           //创建的是父类
SubF::~SubF()       
FBase::~FBase()        //调用两次析构函数是因为sub是子类所以要析构两次，先析构自己在析构父类
class FBase
{
    public:
    FBase()
    {
        cout<<"FBase::FBase()"<<endl;
    }
    virtual ~FBase()
    {
        cout<<"FBase::~FBase()"<<endl;
    }
};


class SubF:public FBase
{
    public:
    SubF()
    {
        cout<<"SubF::SubF()"<<endl;
    }
    ~SubF()
    {
        cout<<"SubF::~SubF()"<<endl;
    }
};
int main()
{
    FBase *base = (FBase*)new SubF();
    delete base;
    cout<<"###############################"<<endl;
    SubF *sub = (SubF*)new FBase();
    delete sub;
    return 0;
}
结果是：//添加 virtual后以 new后面的类型决定
FBase::FBase()
SubF::SubF()
SubF::~SubF()
FBase::~FBase()
#########################
FBase::FBase()
FBase::~FBase()