C++中的virtual

参考资料：http://www.programfan.com/article/2782.html
作为通常的原则，如果一个类定义了虚函数，那么它的析构函数就应当是virtual的。因为定义了虚函数则隐含着：这个类会被继承，并且会通过基类的指针指向子类对象，从而得到多态性。”，因此基类的析构函数是否为虚将决定子类的对象是否被析构。
虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。

class A
{
public:
    virtual voidfoo() { cout << "A::foo() is called"<< endl;}
};
class B: public A
{
public:
    virtual voidfoo() { cout << "B::foo() is called"<< endl;}
};

那么，在使用的时候，我们可以：
A * a = new B(); 父类类型的指针指向子类类型的对象，从而父类调用子类函数
a->foo();      // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
   这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。

class A
{
public:
    virtual voidfoo();
};
class B: public A
{
    virtual voidfoo();
};
void bar()
{
    A a;
   a.foo();   // A::foo()被调用
}
void bar(A * a)
{
   a->foo();   //若a指向A的实例，则A的foo被调用，若a指向B的实例，则B的foo被调用。 多态
}

1.3 如何“动态联编”
      编译器是如何针对虚函数产生可以再运行时刻确定被调用函数的代码呢？也就是说，虚函数实际上是如何被编译器处理的呢？Lippman在深度探索C++对象模型[1]中的不同章节讲到了几种方式，这里把“标准的”方式简单介绍一下。
      我所说的“标准”方式，也就是所谓的“VTABLE”机制。编译器发现一个类中有被声明为virtual的函数，就会为其搞一个虚函数表，也就是VTABLE。VTABLE实际上是一个函数指针的数组，每个虚函数占用这个数组的一个slot。一个类只有一个VTABLE，不管它有多少个实例。派生类有自己的VTABLE，但是派生类的VTABLE与基类的VTABLE有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。在创建类实例的时候，编译器还会在每个实例的内存布局中增加一个vptr字段，该字段指向本类的VTABLE。通过这些手段，编译器在看到一个虚函数调用的时候，就会将这个调用改写，针对1.1中的例子：
void bar(A * a)
{
      a->foo();
}
会被改写为：
void bar(A * a)
{
      (a->vptr[1])();
}
      因为派生类和基类的foo()函数具有相同的VTABLE索引，而他们的vptr又指向不同的VTABLE，因此通过这样的方法可以在运行时刻决定调用哪个foo()函数。
一个类只有一个VTABLE，所以基类和派生类具有自己的VTABLE（函数指针）。但两者有相同的虚函数排列顺序。同名的虚函数被放在VTABLE表的相同位置。
在创建类实例时，编译器会在类的内存空间生成一个vptr字段，指向该类的VTABLE.
当调用上面的foo函数时，根据A *a=new A 还是 A *a=new B决定调用哪个类的foo函数，从而实现多态。

#include <iostream>
using namespace std;
struct A
{
    A(){cout<<"A::()"<<endl;}
    virtual ~A(){cout<<"~A()\n";}
};
struct B: public A
{
    B(){cout<<"B::()"<<endl;}
    ~B(){cout<<"~B()\n";}
};

基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。
int main()
{
      A* p = newB;      //多态出现了
      deletep;
      //B b;
      return0;
}
如果 A的析构函数不是virtual的，那么此时就不是先调用B的析构函数再调用A的析构函数。
输出:
~A(); 
如果A的析构函数为virtual，则先~B()，再~A()   
输出:
~B();
~A();
类如果会被派生的话，析构函数一般都应该定义为virtual的，主要不是防止内存泄露，而是为了正确的析构。如果是个封闭类（即不再被派生），就不要定义为virtual的。虚函数毕竟耗费较大的。

不用virtual 的几种情况：
 1、作为非公有基类。仅作为  private  base  class  使用的   class不需要使用虚拟析构函数  
 2、不作为接口使用的基类。  
  3.  如果你可以保证这个类不被public继承（private/protected继承的话，在非friend函数/类中就无法用基类指针指向派生类了）  
  4.  如果它的所有派生类（包括派生类的派生类）的析构函数都是trivial的（这里的trivial指的是在程序员的层次什么事也不做）  
  5.  如果不需要用基类的指针指向派生类的对象  
 在这五种情况下，不把析构函数声明为virtual都是可以的，何况效率会高一些——但前提是你得保证前提的成立——不过这些保证常常是很难100％的：谁能保证别人在派生你的类的时候，析构函数是trivial的，或者别人不用你提供的基类的指针指向派生类对象？这些常常是很难得到保证的。  
声明基类的析构函数为virtual并非总是为了防止memory  leak  另外这也只是作为一般的原则（基类中有虚函数则把其析构函数声明为virtual）。如果你的析构函数什么事也不作，从效果上来说，不声明为virtual也无妨

overload重载：不同的参数列表，在静态编译的时候已经确定了。
override覆盖/重写：同样的参数列表，实现多态。在执行时动态联编

2.2 纯虚函数
   如下声明表示一个函数为纯虚函数：
class A
{
public:
    virtual voidfoo()=0;   //=0标志一个虚函数为纯虚函数
};
   一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！不能被实例化，只能被子类覆盖。纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。