【1】虛成員函數和非虛成員函數調用方式有什么不同？
        非虛成員函數是靜態確定的。也就是說，該成員函數（在編譯時）被靜態地選擇，該選擇基于指向對象的指針（或引用）的類型。相比而言，虛成員函數是動態確定的（在運行時）。也就是說，成員函數（在運行時）被動態地選擇，該選擇基于對象的類型，而不是指向該對象的指針/引用的類型。這被稱作“動態綁定/動態聯編”。大多數的編譯器使用以下的一些的技術，也就是所謂的“VTABLE”機制：
        編譯器發現一個類中有被聲明為virtual的函數，就會為其搞一個虛函數表，也就是VTABLE。VTABLE實際上是一個函數指針的數組，每個虛函數占用這個數組的一個slot。一個類只有一個VTABLE，不管它有多少個實例。派生類有自己的VTABLE，但是派生類的VTABLE與基類的 VTABLE有相同的函數排列順序，同名的虛函數被放在兩個數組的相同位置上。在創建類實例的時候，編譯器還會在每個實例的內存布局中增加一個vfptr 字段，該字段指向本類的VTABLE。通過這些手段，編譯器在看到一個虛函數調用的時候，就會將這個調用改寫，在分發一個虛函數時，運行時系統跟隨對象的 v-pointer找到類的 v-table，然后跟隨v-table中適當的項找到方法的代碼。
         以上技術的空間開銷是存在的：每個對象一個額外的指針（僅僅對于需要動態綁定的對象），加上每個方法一個額外的指針（僅僅對于虛方法）。時間開銷也是有的：和普通函數調用比較，虛函數調用需要兩個額外的步驟（得到v-pointer的值，得到方法的地址）。由于編譯器在編譯時就通過指針類型解決了非虛函數的調用，所以這些開銷不會發生在非虛函數上。

【2】析構函數也可以是虛的，甚至是純虛的，但是構造函數不能是虛的
     純虛的析構函數并沒有什么作用，是虛的就夠了。通常只有在希望將一個類變成抽象類（不能實例化的類），而這個類又沒有合適的函數可以被純虛化的時候，可以使用純虛的析構函數來達到目的。構造函數不能是虛的（為什么？因為在一個構造函數調用期間，虛機制并不工作），但是你可以可能通過虛函數 virtual clone()（對于拷貝構造函數）或虛函數 virtual create()（對于默認構造函數），得到虛構造函數產生的效果。如下：
class Shape {
public:
   virtual ~Shape() { }                 // 虛析構函數
   virtual void draw() = 0;             // 純虛函數
   virtual void move() = 0;
   // ...
   virtual Shape* clone() const = 0;   // 使用拷貝構造函數
   virtual Shape* create() const = 0;   // 使用默認構造函數
};

class Circle : public Shape {
public:
   Circle* clone() const { return new Circle(*this); }
   Circle* create() const { return new Circle();      }
   // ...
};
    在 clone() 成員函數中，代碼 new Circle(*this) 調用 Circle 的拷貝構造函數來復制this的狀態到新創建的Circle對象。在 create()成員函數中，代碼 new Circle() 調用Circle的默認構造函數。
用戶將它們看作“虛構造函數”來使用它們：
void userCode(Shape& s)
{
   Shape* s2 = s.clone();
   Shape* s3 = s.create();
   // ...
   delete s2;    // 在此處，你可能需要虛析構函數
   delete s3;
}
    這個函數將正確工作，而不管 Shape 是一個Circle，Square，或是其他種類的 Shape，甚至它們還并不存在。

【3】 構造函數和析構函數中的虛函數調用
         一個類的虛函數在它自己的構造函數和析構函數中被調用的時候，它們就變成普通函數了，不“虛”了。也就是說不能在構造函數和析構函數中讓自己“多態”。例如：
class A
{
public:
    A() { foo();}        // 在這里，無論如何都是A::foo()被調用！
    ~A() { foo();}       // 同上
    virtual void foo();
};

class B: public A
{
public:
    virtual void foo();
};

void bar()
{
    A * a = new B;
    delete a;
}
    如果你希望delete a的時候，會導致B::foo()被調用，那么你就錯了。同樣，在new B的時候，A的構造函數被調用，但是在A的構造函數中，被調用的是A::foo()而不是B::foo()。為什么會有這樣的規定呢，原因如下：
         當基類被構造時，對象還不是一個派生類的對象，所以如果 Base::Base()調用了虛函數 virt()，則 Base::virt() 將被調用，即使 Derived::virt()（派生類重寫該虛函數）存在。
         同樣，當基類被析構時，對象已經不再是一個派生類對象了，所以如果 Base::~Base()調用了virt()，則 Base::virt()得到控制權，而不是重寫的 Derived::virt() 。
    當你可以想象到如果 Derived::virt() 涉及到派生類的某個成員對象將造成的災難的時候，你很快就能看到這種方法的明智。詳細來說，如果 Base::Base()調用了虛函數 virt()，這個規則使得 Base::virt()被調用。如果不按照這個規則，Derived::virt()將在派生對象的派生部分被構造之前被調用，此時屬于派生對象的派生部分的某個成員對象還沒有被構造，而 Derived::virt()卻能夠訪問它。這將是災難。

【4】私有private的虛函數是否具有多態性？
    考慮下面的例子：
class A
{
public:
    void foo() { bar();}
private:
    virtual void bar() { ...}
};

class B: public A
{
private:
    virtual void bar() { ...}
};
    在這個例子中，雖然bar()在A類中是private的，但是仍然可以出現在派生類中，并仍然可以與public或者protected的虛函數一樣產生多態的效果。并不會因為它是private的，就發生A::foo()不能訪問B::bar()的情況，也不會發生B::bar()對A::bar() 的override不起作用的情況。
    這種寫法的語意是：A告訴B，你最好override我的bar()函數，但是你不要管它如何使用，也不要自己調用這個函數。