用汇编的角度剖析c++的virtual
多态是c++的关键技术，背后的机制就是有一个虚函数表，那么这个虚函数表是如何存在的，又是如何工作的呢？
当然不用的编译器会有不同的实现机制，本文只剖析vs2015的实现。
单串继承
首先看一段简单的代码：
class A {
private:
int a_value;
public:
A() {};
virtual ~A() {};
virtual void my_echo() { std::cout << "A::my_echo" << std::endl; };
virtual void echo() { std::cout << "A::echo" << std::endl; };
virtual void print() { std::cout << "A::print" << std::endl; };
};
class B :public A {
public:
B() {};
~B() {};
int b_value;
virtual void echo()override { std::cout << "B::echo" << std::endl; };
virtual void print()override { std::cout << "B::print" << std::endl; };
void B_Fun() { std::cout << "B::B_Fun" << std::endl; };
};
class C :public B {
private:
int c_value;
public:
C() {};
~C() {};
virtual void echo()override { std::cout << "C::echo" << std::endl; };
virtual void my_print() { std::cout << "C::print" << std::endl; };
};
C继承B，B继承A。
先回顾下类的内存布局，看类C的内存布局。
class C size(16):
+---
0 | +--- (base class B)
0 | | +--- (base class A)
0 | | | {vfptr}
4 | | | a_value
| | +---
8 | | b_value
| +---
12 | c_value
+---
C::$vftable@:
| &C_meta
| 0
0 | &C::{dtor}
1 | &A::my_echo
2 | &C::echo
3 | &B::print
4 | &C::my_print
如上所示，虚函数表指针在首地址，占用一个指针大小，值得注意的是虚函数表首位指针是D的析构函数，那是因为基类有虚析构函数。
来个简单调用。
A* b = new C();
b->print();//输出为 B::print
print这个虚函数到底是怎么执行的？又是如何达到多态效果的呢？
再看print调用的汇编代码。
32位系统
b->print();
00EF6306 mov eax,dword ptr [b]
00EF6309 mov edx,dword ptr [eax]
00EF630B mov esi,esp
00EF630D mov ecx,dword ptr [b]
00EF6310 mov eax,dword ptr [edx+0Ch]
00EF6313 call eax
64位系统
b->print();
00007FF6336D2CBD mov rax,qword ptr [b]
00007FF6336D2CC1 mov rax,qword ptr [rax]
00007FF6336D2CC4 mov rcx,qword ptr [b]
00007FF6336D2CC8 call qword ptr [rax+18h]
32位解析
00EF6306 mov eax, dword ptr[b]
#将指针b变量指向内存地址的dword大小赋值给eax，实际就是获得b指向的地址，之后eax为b对象的实际地址，
00EF6309 mov edx, dword ptr[eax]
#将地址eax指向的内存地址，取出一个dword赋值给edx，之后edx就是虚函数表的首地址，
00EF630D mov ecx, dword ptr[b]
#同上，将b实际指向的地址赋值给ecx，这句话作用是为了成员函数活得所需的this指针，为call做参数
00EF6310 mov eax, dword ptr[edx+0Ch]
#这里是将edx +12，因为是32位，所以这里是在虚函数表头地址向后偏移了4个函数指针，此时的地址就是虚函数print的指针地址了
#然后将print指针赋值给eax
00EF6313 call eax
#调用print函数
64的汇编与32位相差不大，值得注意的是64位系统指针是8字节，所以是18h大小。可以看出在简单继承情况下，虚函数指针都是在首位的，而且虚函数表事一个共用表。
比如上面的单继承C=>B=>A，在new出C后，转换为基类B或者A时，是共用的一个虚函数表，接下来用一段代码来证明。
#ifndef _WIN64
typedef unsigned int pointer;//32位指针
#else
typedef unsigned long long pointer;//64位指针
#endif
//------------------------------
B b;
B* b1 = new B();
A* a = new A();
A *a1 = dynamic_cast <A*>(b1);
B* b2 = dynamic_cast<B*>(a1);
pointer vfptr_b = *(pointer*)&b;
pointer vfptr_b1 = *(pointer*)b1;
pointer vfptr_a = *(pointer*)a;
pointer vfptr_a1 = *(pointer*)a1;
pointer vfptr_b2 = *(pointer*)b2;
std::cout
<< vfptr_b << "\n"
<< vfptr_b1 << "\n"
<< vfptr_a << "\n"
<< vfptr_a1 << "\n"
<< vfptr_b2 << std::endl;
上面的代码意思就是将各种类型强行转换为指针，得到虚函数表的地址，从结果我们看到，只有vfptr_a不一样，也就是new A的虚函数表不一样，其余的，特比是dynamic_cast <A*>转换类型的虚函数表地址，还是为B的虚函数表地址。
我们就可以得到一个简单结论，当是单继承时，子类指针转换为父类指针，指针地址不变，虚函数表不变，父类指针只用虚函数表的前半段。接下来从汇编结合虚函数表来分析单继承多态实现的原理。
B* b = new C();
b->print();
A *a = dynamic_cast <A*>(b);
a->echo();
B* b2 = new B();
b2->echo();
B* b = new C();
008B660D push 10h
008B660F call operator new (08B131Bh) //new 开辟内存
...........
008B6633 call C::C (08B14D3h) //调用构造
...........
00C06663 mov dword ptr [b],ecx //赋值给b
b->print();
008B6666 mov eax,dword ptr [b] //得到对象地址
008B6669 mov edx,dword ptr [eax] //得到虚函数表首地址
008B666D mov ecx,dword ptr [b] //this 指针
008B6670 mov eax,dword ptr [edx+0Ch] //虚函数表中的print函数实际地址
008B6673 call eax //调用print
A *a = dynamic_cast <A*>(b);
008B667C mov eax,dword ptr [b]
008B667F mov dword ptr [a],eax //编译器知道B是A的子类，所以，b指针转换为a指针，直接copy指针地址。
a->echo();
008B6682 mov eax,dword ptr [a]
008B6685 mov edx,dword ptr [eax]
008B6689 mov ecx,dword ptr [a] //this指针
008B668C mov eax,dword ptr [edx+8] //echo在表里的偏移
008B668F call eax //执行call
B* b2 = new B();
...........
00E5669A call operator new (0E5131Bh)
...........
00E566EE mov dword ptr [b2],ecx
b2->echo();
00E566F1 mov eax,dword ptr [b2]
00E566F4 mov edx,dword ptr [eax]
00E566F8 mov ecx,dword ptr [b2]
00E566FB mov eax,dword ptr [edx+8] //echo函数在表里的偏移，
00E566FE call eax
new的对象C转换基类B，再转换为基类A，a->echo如何输出C::echo?下面画个图，描述了单一继承时候的虚函数表运行机制。
多继承
多继承和单继承在虚函数表处理上有很大不同，先看代码。
class Base {
private:
int base_value;
public:
Base() {};
virtual ~Base() {};
virtual void base_echo() { std::cout << "Base::base_echo" << std::endl; };
};
class A {
private:
int a_value;
public:
A() {};
virtual ~A() {};
virtual void a_echo() { std::cout << "A::a_echo" << std::endl; };
virtual void a_print() { std::cout << "A::a_print" << std::endl; };
};
class B {
public:
B() {};
virtual ~B() {};
int b_value;
virtual void b_echo() { std::cout << "B::b_echo" << std::endl; };
virtual void b_print() { std::cout << "B::b_print" << std::endl; };
};
class C :public A,public B, public Base {
private:
int c_value;
public:
C() { };
~C() {};
virtual void a_echo()override { std::cout << "C::a_echo" << std::endl; };
virtual void b_print()override { std::cout << "C::b_print" << std::endl; };
virtual void c_echo() { std::cout << "C::c_echo" << std::endl; };
};
C类同时继承了A,B,Base三个类，此时内存和虚函数是怎样的呢？
A,B,Base原有固定各自虚函数表：
Base::$vftable@:
| &Base_meta
| 0
0 | &Base::{dtor}
1 | &Base::base_echo
A::$vftable@:
| &A_meta
| 0
0 | &A::{dtor}
1 | &A::a_echo
2 | &A::a_print
B::$vftable@:
| &B_meta
| 0
0 | &B::{dtor}
1 | &B::b_echo
2 | &B::b_print
然后再看C类的内存布局和虚函数表：
class C size(28):
+---
0 | +--- (base class A)
0 | | {vfptr}
4 | | a_value
| +---
8 | +--- (base class B)
8 | | {vfptr}
12 | | b_value
| +---
16 | +--- (base class Base)
16 | | {vfptr}
20 | | base_value
| +---
24 | c_value
+---
C::$vftable@A@:
| &C_meta
| 0
0 | &C::{dtor}
1 | &C::a_echo
2 | &A::a_print
3 | &C::c_echo
C::$vftable@B@:
| -8
0 | &thunk: this-=8; goto C::{dtor}
1 | &B::b_echo
2 | &C::b_print
C::$vftable@Base@:
| -16
0 | &thunk: this-=16; goto C::{dtor}
1 | &Base::base_echo
非常惊讶的发现C类竟然有三个虚函数表，C::$vftable@A@:, C::$vftable@B@:, C::$vftable@Base@:，在同时继承的了A,B,Base三个基类里，各自都有一个虚函数表。
而三个各自的虚函数表和源了A,B,Base三个基类虚函数表是不同的!！是单独属于C类的虚函数。更值得注意的是，C::c_echo是C的虚函数，但是却在C::$vftable@A@:表里面。
从内存布局和虚函数布局可以得出简单结论，多继承时候，一般来说，对象会有同时继承类个数的虚函数表和表指针，子类的新虚函数会存在于第一个继承类的新虚函数，
未完待续！！！！！！！
