（原创）深入剖析：C++“多态性”在编译器中的实现

理论

如下内容，属个人的理解．与大家共享．错误之处，请指正

程序，就是通过CPU指令（CPU指令就是CPU能识别的二进制流，CPU通过解释指令，能发出各种电流脉冲，以达到控制其他电子电路的状态），对内存中数据资源的操作，也就是改变内存的二进制数，也是改变高低电平。

内存中，都是二进制数据，哪是指令，哪是数据?

PC指令计数器所指向的内存单元，就是指令。

PC指向哪,哪就是指令,所以数据也是指令，指令也是数据，程序只要管好PC寄存器就可以了.

语言级上，程序，是由函数和数据组成，函数调用，实际上也是改变PC值，地址转移。

数据又分为两种:

一种就是在编译时,就分配地址空间.如全局数据

一种是在运行时,靠编译器所维护的栈顶指针,相对栈顶指针的偏移量,来分配地址空间.如局部数据.

(另一种就是在堆中动态分配的)

-------------------------------------------------------------------------------------------------------------------------------------

一个VC工程中，由许多H和CPP文件组成，

编译器，负责收集CPP文件（H文件被包含在CPP内）中出现的所有标识或符号，并负责形成逻辑、语法正确的二进制代码（obj文件）

连接器，负责确定、调整函数的相对地址，并保证在CPP中，每次函数调用（也就是地址转移），都是有效的，每个对内存数据的访问的地址，是有效的。

最终由连接器形成翻译成汇编代码或机器代码。（DLL和EXE可执行的文件）

为收集标识和符号，编译器维护一个符号映射表,有3栏（或3个字段）：
1。类型栏（变量类型或函数类型，在编译时，由编译器负责填写）
2。名字栏（变量名或函数名，在编译时，由编译器负责填写）
3。地址栏（是相对地址，成员变量类型的这一栏就放偏移值，加载后，由操作系统重新调整，也就是地址重定位，在连接时，由连接器负责填写）

-------------------------------------------------------------------------------------------------------------------------------------

实际应用

每声明定义一个变量或成员函数时，编译器就生成一个映射元素

如：

int a;

class A   

{

int m_a;

int m_b;

void fun1();

}

生成的两条映射表记录为：

名字栏  |    类型栏    |  地址栏()

   a          |     int           |   指向a的声明定义处，相对地址，加载后，由操作系统重新调整

  A::m_a |  int             |  偏移地址0,运行时，实际地址：this + 0

  A::m_b |  int             |   偏移地址4,运行时，实际地址：this + 4

  A::fun1 | A::fun1    |   指向A::fun1()定义处，相对地址，加栽后，由操作系统重新调整

有关编译器动态绑定技术，请看如下列：

class a
{

public:
  virtual fun1();

 virtual fun6();

  void fun2();

/*

出现virtual 关键字，编译器为该类创建虚表

  索引           |         函数指针

  0                |     指向 a::fun1()定义处

  1               |     指向 a::fun6()定义处

出现成员函数声明，编译器填写映射表

名字栏       |    类型栏    |  地址栏

a::fun2()    |   a::fun2      | (由连接器填写)指向a::fun2()定义处

*/
}

//b继承自a

class b :public a

{

public:
  virtual fun1();

  void fun3();

/*

虚函数fun1()：

重新定义，创建虚表，并继承了父类的虚表项，

修改了虚表中第一项（“a::fun1()函数”）的指针，使指向自己定义b::fun1()函数

  索引           |         函数指针

  0                |     指向 b::fun1()定义处（重定义）

 1                |     指向 a::fun6()定义处(没有重定义)

出现成员函数fun3()声明，映射表中增加一栏：

名字栏       |    类型栏    |  地址栏

b::fun3()    |   b::fun3     | 指向b::fun3()定义处

从父类中继承的成员函数fun2()

映射表中增加一栏：记录从a继承的fun2()函数

名字栏       |    类型栏    |  地址栏

b::fun2()    |   a::fun2    | 指向父类a::fun2()定义处

*/
}

//c继承自a
class c :public a

{

public:
  virtual fun6();

 void fun4();

/*

虚函数fun1()：

重新定义，创建虚表，并继承了父类的虚表项，

修改了虚表中第二项（“a::fun6()函数”）的指针，使指向自己定义c::fun6()函数

  索引           |         函数指针

  0                |     指向 a::fun1()定义处

  1                |     指向 c::fun6()定义处(改写)

出现 成员函数fun4()，映射表中增加一栏：

名字栏       |    类型栏    |  地址栏

c::fun4()    |   c::fun4     | 指向c::fun4()定义处

从父类中继承的成员函数fun2()

映射表中增加一栏：记录从a继承的fun2()函数

名字栏       |    类型栏    |  地址栏

c::fun2()    |   a::fun2    | 指向父类a::fun2()定义处

*/

}

调用
main()
{
  b     var1;
  c     var2;
  a*    p;
 
 p = &var1;
 

var1.fun2();

/*

var1.fun2()调用，静态绑定：

编译到此处时，编译器到映射表中找名字栏，找到b::fun2()名字（由于var1为b类型），其对应的类型栏为“函数类型，类型名为a::fun2（因为此函数由a类型定义）”，其地址栏的指针值为“指向a::fun2()定义处”，所以，此处函数调用，被编译器替换为“转向：地址栏的指针值”，实际上可理解为是修改指令记数器的值为“地址栏的指针值”

*/

*/

p->fun2();

/*

p->fun2()，静态绑定：这个容易理解，编译时，是找“a::fun2（）”名字（因为p是a类型）

*/

p->fun2()，静态绑定：这个容易理解，编译时，是找“a::fun2（）”名字（因为p是a类型）

*/

p->fun2()，静态绑定：这个容易理解，编译时，是找“a::fun2（）”名字（因为p是a类型）

*/

p->fun2()，静态绑定：这个容易理解，编译时，是找“a::fun2（）”名字（因为p是a类型）

*/

p->fun3();

/*

 p->fun3()，这个调用，可能要发生编译错误，因为类型a没有声明和定义fun3()函数，找不到a::fun3()名字，只有b::fun3()名字

*/

p->fun1();

/*
p->fun1();fun1()是个虚函数，同理，编译到此处时，编译器是不是也到映射表中找“a::fun1()”名字呢？不是的。
因为，在映射表中，是找不到a::fun1()”这个名字的，因为，fun1()名字声明前有关键字"virtual"，
在类声明和定义时，编译器，为每个出现virtual关键字的类，维护一个全局数据结构“虚表”

虚表：

1。索引；2。函数指针（这值在子类重写虚函数后，发生相应变化）

所以上面调用，在编译器发现调用的是“虚函数”时，
编译器做了如下处理：

将p->fun1()  替换为：p->vptr[offset],

vptr名字为虚表指针：
由编译器维护（上面提到），每个含虚函数的类，其生成对象，在内存中，首先的四个字节就是vptr，这个值是静态的，同一个类型的所有对象的vptr值相同，指向同一个虚表；

offset值随虚函数声明次序而定，如果第一个声明，索引则为0，出现在虚表的第一项，第二个声明则为1，以次。。。（此时offset 为 0 即是：p->vptr[0]）

p为基类，可指向子类的任何对象

（附加：

1。类型转换实际是：内存切割，管辖内存从大变小，从大变小，现实世界中，是允许，在C++中，也是允许的；编译器不允许基类对象向子类对象的转化，因为从小变大，会导致内存访问越界。

  2。指针的类型，实际上决定了通过该指针能访问的内存范围

），

所指向对象的类型不同，vptr不同
 所以，p->vptr[0],函数调用地址值在编译时，是不可能确定，主要因为
p指针所指向对象不能确定（p是指向b，还是指向c?还是其他。。，但offset是可以确定的）
从而，vptr值不能确定，
直到程序运行时，p->vptr[0]调用的函数地址，视p所指向对象类型而定
如果p指向b子类，则p指向内存中的首4字节的vptr指向b的虚表，虚表第一项的指针指向自己函数定义的地址处
如果p指向c子类，则。。。。
这种直到运行时，才能确定函数调用地址的方式，即为：“动态绑定”

*/

p->fun6();

/*

同上，由于b类未改写需函数fun6(),所以该处调用，实际调用a::fun6()，编译器做如下处理：

p->fun6() 变为  p->vptr[1],由于，fun6为第二声明，此时，offset为1

*/

p = &var2;
 p->fun1();//动态绑定，同上, 调用a::fun1()
 p->fun2();//静态，同上

p->fun6();//调用c::fun6()
 p->fun4();
//编译出错，因为fun4()非虚函数，编译器在映射表中找不到a::fun4()名字，
//除非强行转换：(（c*）p)->fun4()，}

虚表：

1。索引；2。函数指针（这值在子类重写虚函数后，发生相应变化）

所以上面调用，在编译器发现调用的是“虚函数”时，
编译器做了如下处理：

将p->fun1()  替换为：p->vptr[offset],

vptr名字为虚表指针：
由编译器维护（上面提到），每个含虚函数的类，其生成对象，在内存中，首先的四个字节就是vptr，这个值是静态的，同一个类型的所有对象的vptr值相同，指向同一个虚表；

offset值随虚函数声明次序而定，如果第一个声明，索引则为0，出现在虚表的第一项，第二个声明则为1，以次。。。（此时offset 为 0 即是：p->vptr[0]）

p为基类，可指向子类的任何对象

（附加：

1。类型转换实际是：内存切割，管辖内存从大变小，从大变小，现实世界中，是允许，在C++中，也是允许的；编译器不允许基类对象向子类对象的转化，因为从小变大，会导致内存访问越界。

  2。指针的类型，实际上决定了通过该指针能访问的内存范围

），

所指向对象的类型不同，vptr不同
 所以，p->vptr[0],函数调用地址值在编译时，是不可能确定，主要因为
p指针所指向对象不能确定（p是指向b，还是指向c?还是其他。。，但offset是可以确定的）
从而，vptr值不能确定，
直到程序运行时，p->vptr[0]调用的函数地址，视p所指向对象类型而定
如果p指向b子类，则p指向内存中的首4字节的vptr指向b的虚表，虚表第一项的指针指向自己函数定义的地址处
如果p指向c子类，则。。。。
这种直到运行时，才能确定函数调用地址的方式，即为：“动态绑定”

*/

p->fun6();

/*

同上，由于b类未改写需函数fun6(),所以该处调用，实际调用a::fun6()，编译器做如下处理：

p->fun6() 变为  p->vptr[1],由于，fun6为第二声明，此时，offset为1

*/

p = &var2;
 p->fun1();//动态绑定，同上, 调用a::fun1()
 p->fun2();//静态，同上

p->fun6();//调用c::fun6()
 p->fun4();
//编译出错，因为fun4()非虚函数，编译器在映射表中找不到a::fun4()名字，
//除非强行转换：(（c*）p)->fun4()，}

虚表：

1。索引；2。函数指针（这值在子类重写虚函数后，发生相应变化）

所以上面调用，在编译器发现调用的是“虚函数”时，
编译器做了如下处理：

将p->fun1()  替换为：p->vptr[offset],

vptr名字为虚表指针：
由编译器维护（上面提到），每个含虚函数的类，其生成对象，在内存中，首先的四个字节就是vptr，这个值是静态的，同一个类型的所有对象的vptr值相同，指向同一个虚表；

offset值随虚函数声明次序而定，如果第一个声明，索引则为0，出现在虚表的第一项，第二个声明则为1，以次。。。（此时offset 为 0 即是：p->vptr[0]）

p为基类，可指向子类的任何对象

（附加：

1。类型转换实际是：内存切割，管辖内存从大变小，从大变小，现实世界中，是允许，在C++中，也是允许的；编译器不允许基类对象向子类对象的转化，因为从小变大，会导致内存访问越界。

  2。指针的类型，实际上决定了通过该指针能访问的内存范围

），

所指向对象的类型不同，vptr不同
 所以，p->vptr[0],函数调用地址值在编译时，是不可能确定，主要因为
p指针所指向对象不能确定（p是指向b，还是指向c?还是其他。。，但offset是可以确定的）
从而，vptr值不能确定，
直到程序运行时，p->vptr[0]调用的函数地址，视p所指向对象类型而定
如果p指向b子类，则p指向内存中的首4字节的vptr指向b的虚表，虚表第一项的指针指向自己函数定义的地址处
如果p指向c子类，则。。。。
这种直到运行时，才能确定函数调用地址的方式，即为：“动态绑定”

*/

p->fun6();

/*

同上，由于b类未改写需函数fun6(),所以该处调用，实际调用a::fun6()，编译器做如下处理：

p->fun6() 变为  p->vptr[1],由于，fun6为第二声明，此时，offset为1

*/

p = &var2;
 p->fun1();//动态绑定，同上, 调用a::fun1()
 p->fun2();//静态，同上

p->fun6();//调用c::fun6()
 p->fun4();
//编译出错，因为fun4()非虚函数，编译器在映射表中找不到a::fun4()名字，
//除非强行转换：(（c*）p)->fun4()，}