轉載：http://blog.csdn.net/haoel/article/details/1948051/
轉載的內容是具有很高的參考價值，但是這里，我們需要尋求另外的一些事情，就是虛函數表存在的意義。
其實，如果你在學習虛函數的時候感到迷茫，那是因為很多的書籍并沒有解釋虛函數的實現原理和意義，原因我想是因為如果展開來說這部分的內容可能會涉及的編譯器實現的部分，所以這里，我也只是簡單的闡述我的個人猜想，讀者只能作為一種借鑒。
首先我要吹下牛B，C++真是一門好語言，初學的時候痛苦萬分，學會了真的覺得自己鼠目寸光。
實例1代碼如下：
#include <iostream>
using namespace std;
class A
{
public:
void Output() { cout << "A::Output()" << endl; }
};
int main(int argc, char ** argv)
{
A a;
a.Output();
return 0;
}
這是一個很基本的C++程序，我假設讀者能夠明白這個簡單程序。
我們現在對這個程序做一個很小的改動
實例2代碼如下：
#include <iostream>
using namespace std;
class A
{
public:
void Output() { cout << "A::Output()" << endl; }
};
int main(int argc, char ** argv)
{
A a;
a.A::Output();
return 0;
}
我們發現，我們在main函數中僅僅是使用了一個‘A::’，但是輸出結果和實例1是相同的。這個說明一個問題，實例1的寫法是實例2的寫法的一個簡單寫法，或者這么說，實例1的寫法默認了含有‘A::’，也就是說實例1含有一種默認行為。
有了上面的一個基本假設，我們現在來看看當子類和父類含有相同的函數名的時候會是一種什么現象。
實例3代碼如下：
#include <iostream>
using namespace std;
class A
{
public:
void Output() { cout << "A::Output()" << endl; }
};
class B : public A
{
public:
void Output() { cout << "B::Output()" << endl; }
};
int main(int argc, char ** argv)
{
B b;
b.Output(); // 1
b.B::Output(); // 2
b.A::Output(); // 3
b.B::A::Output(); // 4
return 0;
}
我們看到1和2的輸出是一致的，3和4的輸出是一致的，我們可以推測，1是2的簡寫形式，3是4的一種簡寫形式（其實3不是4的一種簡化形式，目前而言我只能猜測）。
我們可以從4的形式上發現，B是繼承自A的，否則不可能會有這種形式的存在。
我們還可以從2的形式上發現，函數Output一定是一個成員函數，否則不會有此種形式的存在。
C++語言為了簡化我們的行為，做了很多后臺的行為，用來簡化形式，這是我覺得C++語言偉大的地方，但是它隱藏的東西又沒有人告訴你，所以初學的時候只能依葫蘆畫瓢，不知道怎么回事，看到一些C++代碼總感到疑惑，覺得這種范式我并沒有見過。
實例4代碼如下：
#include <iostream>
using namespace std;
class A
{
public:
virtual void Output() { cout << "A::Output()" << endl; }
};
class B : public A
{
public:
void Output() { cout << "B::Output()" << endl; }
};
int main(int argc, char ** argv)
{
B b;
A * a = &b;
(*a).Output(); // 1
// (*a).B::Output(); // 2
(*a).A::Output(); // 3
(*a).B::A::Output(); // 4
return 0;
}
我們發現2是沒有通過編譯的，原因我猜測是因為Output是成員函數，而成員函數的第一個形參是一個this指針，this指針的類型是B *，a的類型是A *，但是 A *是無法自動轉換成B *的，所以語句2是無法通過編譯的。
不過3和4的輸出是一致的。現在我們來查看一下3和4的函數指針的值
實例5代碼如下：
#include <iostream>
#include <stdio.h>
using namespace std;
class A
{
public:
virtual void Output() { cout << "A::Output()" << endl; }
};
class B : public A
{
public:
void Output() { cout << "B::Output()" << endl; }
};
int main(int argc, char ** argv)
{
B b;
A * a = &b;
(*a).Output(); // 1
// (*a).B::Output(); // 2
(*a).A::Output(); // 3
(*a).B::A::Output(); // 4
printf("%p\n", &(A::Output));
printf("%p\n", &(B::A::Output));
return 0;
}
我們發現他們的指針值是相同的。我們可以明白同一個函數的如果地址只有一個副本，但是他的訪問方式可以有多種形式。
實例6代碼如下：
#include <iostream>
#include <stdio.h>
using namespace std;
class A
{
public:
virtual void Output() { cout << "A::Output()" << endl; }
};
class B : public A
{
public:
void Output() { cout << "B::Output()" << endl; }
};
class C : public A
{
};
int main(int argc, char ** argv)
{
B b;
A * a = &b;
(*a).Output(); // 1
// (*a).B::Output(); // 2
(*a).A::Output(); // 3
(*a).B::A::Output(); // 4
(*a).C::A::Output(); // 5
return 0;
}
從4和5的輸出是一致的情況下，我們可以推斷函數4和5的函數地址是一致的。
以上所有的代碼僅僅是針對成員函數的情況，對于成員變量的情況后文繼續闡述。
我們可以總結，虛函數的出現，僅僅是為了實現語句2，而虛函數是通過虛函數表實現的，也就是說，虛函數表是多態機制的根本。
我們可以看出基類對象是無法訪問子類對象的特有的成員函數！！！這是語句2編譯不通過的主要原因。基類不包含子類，但是子類是包含基類的。
下面讓我們來看看類的成員變量。
實例7代碼如下
#include <iostream>
#include <stdio.h>
using namespace std;
class A
{
public:
A() : m_mem(0) {}
A(int x) : m_mem(x) {}
int m_mem;
};
class B : public A
{
public:
B() : A(1) {}
};
class C : public A
{
public:
C() : A(2) {}
};
class D : public B, public C
{
};
int main(int argc, char ** argv)
{
D b;
// cout << b.m_mem << endl; // 1
cout << b.A::m_mem << endl; // 2
cout << b.B::m_mem << endl; // 3
cout << b.B::A::m_mem << endl; // 4
cout << b.C::m_mem << endl; // 5
cout << b.C::A::m_mem << endl; // 6
return 0;
}
1是無法通過編譯的，因為存在二義性，2,3,4的結果是一致的，5,6的結果是一致的，從這個例子，我們知道，如果出現多次繼承同一個基類的時候，我們會產生多個成員變量的副本，這個在實現上我們可以通過域名訪問去除二義性，但是在實際的使用的時候，我們可能會覺得這是一個冗余的副本，我們并不希望存在這種情況，所以我們會有虛繼承的方式來去達到我們的目的
實例8代碼如下：
#include <iostream>
#include <stdio.h>
using namespace std;
class A
{
public:
A() : m_mem(0) {}
A(int x) : m_mem(x) {}
int m_mem;
};
class B : virtual public A
{
public:
B() : A(1) {}
};
class C : virtual public A
{
public:
C() : A(2) {}
};
class D : public B, public C
{
};
int main(int argc, char ** argv)
{
D b;
cout << b.m_mem << endl; // 1
cout << b.A::m_mem << endl; // 2
cout << b.B::m_mem << endl; // 3
cout << b.B::A::m_mem << endl; // 4
cout << b.C::m_mem << endl; // 5
cout << b.C::A::m_mem << endl; // 6
return 0;
}
我們發現1是可以通過編譯的了，而且所有的輸出都是0，說明此時的類A的構造函數是直接通過D發起的，并不是間接的通過B或者C發起的。相反，實例7上面的結果說明類A的構造函數一共執行了兩次，一次是通過B發起的，一次是通過C發起的。另外實例8說明了一個問題，如果類A已經執行過構造函數，B或者C不在調用類A的構造函數了。
這兩個例子都有點繞，主要的原因是多重繼承對于基類的構造函數的調用順序，在有虛繼承和沒有虛繼承的情況下是不同的。
