為什么不要在構造函數中調用虛函數

先看一段在構造函數中直接調用虛函數的代碼：

#include <iostream>

class Base
{
public:
    Base() { Foo(); }   ///< 打印 1

    virtual void Foo()
    {
        std::cout << 1 << std::endl;
    }
};

class Derive : public Base
{
public:
    Derive() : Base(), m_pData(new int(2)) {}
    ~Derive() { delete m_pData; }

    virtual void Foo()
    {
        std::cout << *m_pData << std::endl;
    }
private:
    int* m_pData;
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

　　這里的結果將打印：1。

　　這表明第6行執行的的是Base::Foo()而不是Derive::Foo()，也就是說：虛函數在構造函數中“不起作用”。為什么？

　　當實例化一個派生類對象時，首先進行基類部分的構造，然后再進行派生類部分的構造。即創建Derive對象時，會先調用Base的構造函數，再調用Derive的構造函數。

　　當在構造基類部分時，派生類還沒被完全創建，從某種意義上講此時它只是個基類對象。即當Base::Base()執行時Derive對象還沒被完全創建，此時它被當成一個Base對象，而不是Derive對象，因此Foo綁定的是Base的Foo。

　　C++之所以這樣設計是為了減少錯誤和Bug的出現。假設在構造函數中虛函數仍然“生效”，即Base::Base()中的Foo();所調用的是Derive::Foo()。當Base::Base()被調用時派生類中的數據m_pData還未被正確初始化，這時執行Derive::Foo()將導致程序對一個未初始化的地址解引用，得到的結果是不可預料的，甚至是程序崩潰（訪問非法內存）。

　　總結來說：基類部分在派生類部分之前被構造，當基類構造函數執行時派生類中的數據成員還沒被初始化。如果基類構造函數中的虛函數調用被解析成調用派生類的虛函數，而派生類的虛函數中又訪問到未初始化的派生類數據，將導致程序出現一些未定義行為和bug。

　　對於這一點，一般編譯器會給予一定的支持。如果將基類中的Foo聲明成純虛函數時（看下面代碼），編譯器可能會：在編譯時給出警告、鏈接時給出符號未解析錯誤（unresolved external symbol）。如果能生成可執行文件，運行時一定出錯。因為Base::Base()中的Foo總是調用Base::Foo，而此時Base::Foo只聲明沒定義。大部分編譯器在鏈接時就能識別出來。

#include <iostream>

class Base
{
public:
    Base() { Foo(); }   ///< 可能的結果：編譯警告、鏈接出錯、運行時錯誤

    virtual void Foo() = 0;
};

class Derive : public Base
{
public:
    Derive() : Base(), m_pData(new int(2)) {}
    ~Derive() { delete m_pData; }

    virtual void Foo()
    {
        std::cout << *m_pData << std::endl;
    }
private:
    int* m_pData;
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

　　如果編譯器都能夠在編譯或鏈接時識別出這種錯誤調用，那么我們犯錯的機會將大大減少。只是有一些比較不直觀的情況（看下面代碼），編譯器是無法判斷出來的。這種情況下它可以生成可執行文件，但是當程序運行時會出錯。

#include <iostream>

class Base
{
public:
    Base() { Subtle(); }   ///< 運行時錯誤(pure virtual function call)

    virtual void Foo() = 0;
    void Subtle() { Foo(); }
};

class Derive : public Base
{
public:
    Derive() : Base(), m_pData(new int(2)) {}
    ~Derive() { delete m_pData; }

    virtual void Foo()
    {
        std::cout << *m_pData << std::endl;
    }
private:
    int* m_pData;
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

　　從編譯器開發人員的角度上看，如何實現上述的“特性”呢？

　　我的猜測是在虛函數表地址的綁定上做文章：在“當前類”（正在被構造的類）的構造函數被調用時，將“當前類”的虛函數表地址綁定到對象上。當基類部分被構造時，“當前類”是基類，這里是Base，即當Base::Base()的函數體被調用時，Base的虛函數表地址會被綁定到對象上。而當Derive::Derive()的函數體被調用時，Derive的虛函數表地址被綁定到對象上，因此最終對象上綁定的是Derive的虛函數表。

　　這樣編譯器在處理的時候就會變得很自然。因為每個類在被構造時不用去關心是否有其他類從自己派生，而不需要關心自己是否從其他類派生，而只要按照一個統一的流程，在自身的構造函數執行之前把自身的虛函數表地址綁定到當前對象上（一般是保存在對象內存空間中的前4個字節）。因為對象的構造是從最基類部分（比如A<-B<-C，A是最基類，C是最派生類）開始構造，一層一層往外構造中間類（B），最后構造的是最派生類（C），所以最終對象上綁定的就自然而然就是最派生類的虛函數表。

　　也就是說對象的虛函數表在對象被構造的過程中是在不斷變化的，構造基類部分(Base)時被綁定一次，構造派生類部分(Derive)時，又重新綁定一次。基類構造函數中的虛函數調用，按正常的虛函數調用規則去調用函數，自然而然地就調用到了基類版本的虛函數，因為此時對象綁定的是基類的虛函數表。

　　下面要給出在WIN7下的Visual Studio2010寫的一段程序，用以驗證“對象的虛函數表在對象被構造的過程中是在不斷變化的”這個觀點。

　　這個程序在類的構造函數里做了三件事：1.打印出this指針的地址；2.打印虛函數表的地址；3.直接通過虛函數表來調用虛函數。

　　打印this指針，是為了表明創建Derive對象是，不管是執行Base::Base()還是執行Derive::Derive()，它們構造的是同一個對象，因此兩次打印出來的this指針必定相等。

　　打印虛函數表的地址，是為了表明在創建Derive對象的過程中，虛函數表的地址是有變化的，因此兩次打印出來的虛函數表地址必定不相等。

　　直接通過函數表來調用虛函數，只是為了表明前面所打印的確實是正確的虛函數表地址，因此Base::Base()的第19行將打印Base，而Derive::Derive()的第43行將打印Derive。

　　注意：這段代碼是編譯器相關的，因為虛函數表的地址在對象中存儲的位置不一定是前4個字節，這是由編譯器的實現細節來決定的，因此這段代碼在不同的編譯器未必能正常工作，這里所使用的是Visual Studio2010。

#include <iostream>

class Base
{
public:
    Base() { PrintBase(); }

    void PrintBase()
    {
        std::cout << "Address of Base: " << this << std::endl;

        // 虛表的地址存在對象內存空間里的頭4個字節
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Base Vtable: " << vt << std::endl;

        // 通過vt來調用Foo函數，以證明vt指向的確實是虛函數表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[0];
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void  Foo() { std::cout << "Base" << std::endl; }
};

class Derive : public Base
{
public:
    Derive() : Base() { PrintDerive(); }

    void PrintDerive()
    {
        std::cout << "Address of Derive: " << this << std::endl;

        // 虛表的地址存在對象內存空間里的頭4個字節
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Derive Vtable: " << vt << std::endl;

        // 通過vt來調用Foo函數，以證明vt指向的確實是虛函數表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[0];
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void Foo() { std::cout << "Derive" << std::endl; }
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

輸出的結果跟預料的一樣：

Address of Base: 002E7F98
Address of Base Vtable: 01387840
Call Foo by vt -> Base

Address of Derive: 002E7F98
Address of Derive Vtable: 01387834
Call Foo by vt -> Derive

　　在析構函數中調用虛函數，和在構造函數中調用虛函數一樣。

　　析構函數的調用跟構造函數的調用順序是相反的，它從最派生類的析構函數開始的。也就是說當基類的析構函數執行時，派生類的析構函數已經執行過，派生類中的成員數據被認為已經無效。假設基類中虛函數調用能調用得到派生類的虛函數，那么派生類的虛函數將訪問一些已經“無效”的數據，所帶來的問題和訪問一些未初始化的數據一樣。而同樣，我們可以認為在析構的過程中，虛函數表也是在不斷變化的。

　　將上面的代碼增加析構函數的調用，並稍微修改一下，就能驗證這一點：

#include <iostream>

class Base
{
public:
    Base() { PrintBase(); }
    virtual ~Base() { PrintBase(); }

    void PrintBase()
    {
        std::cout << "Address of Base: " << this << std::endl;

        // 虛表的地址存在對象內存空間里的頭4個字節
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Base Vtable: " << vt << std::endl;

        // 通過vt來調用Foo函數，以證明vt指向的確實是虛函數表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[1];   ///< 注意這里索引變成 1 了，因為析構函數定義在Foo之前
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void  Foo() { std::cout << "Base" << std::endl; }
};

class Derive : public Base
{
public:
    Derive() : Base() { PrintDerive(); }
    virtual ~Derive() { PrintDerive(); }

    void PrintDerive()
    {
        std::cout << "Address of Derive: " << this << std::endl;

        // 虛表的地址存在對象內存空間里的頭4個字節
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Derive Vtable: " << vt << std::endl;

        // 通過vt來調用Foo函數，以證明vt指向的確實是虛函數表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[1];   ///< 注意這里索引變成 1 了，因為析構函數定義在Foo之前
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void Foo() { std::cout << "Derive" << std::endl; }
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

下面是打印結果，可以看到構造和析構是順序相反的兩個過程：

Address of Base: 001E7F98
Address of Base Vtable: 01297844
Call Foo by vt -> Base

Address of Derive: 001E7F98
Address of Derive Vtable: 01297834
Call Foo by vt -> Derive

Address of Derive: 001E7F98
Address of Derive Vtable: 01297834
Call Foo by vt -> Derive

Address of Base: 001E7F98
Address of Base Vtable: 01297844
Call Foo by vt -> Base

　　最終結論：

　　　　1. 不要在構造函數和析構函數中調用虛函數，因為這種情況下的虛函數調用不會調用到外層派生類的虛函數（參考：http://www.artima.com/cppsource/nevercall.html、http://www.parashift.com/c%2B%2B-faq-lite/strange-inheritance.html#faq-23.5）。

　　　　2. 對象的虛函數表地址在對象的構造和析構過程中會隨着部分類的構造和析構而發生變化，這一點應該是編譯器實現相關的。

注：以上的討論是基於簡單的單繼承，對於多重繼承或虛繼承會有一些細節上的差別。