“多态性”是C++最关键和核心的一个特性,“动态绑定技术”是C++编译器最重要的一个技术!欢迎C++高手进来指正我的粗浅理解

原创 2005年05月08日 21:41:00

我的一些粗浅理解,如下,理解错了,欢迎大家指正

程序,就是通过CPU指令,对内存中数据资源的操作,操作,也就是改变内存的二进制数,也是改变高低电平。

内存中,都是二进制数据,哪是指令,哪是数据,PC指令计数器所指向的内存单元,就是指令。

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

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

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

编译器,负责收集CPP文件(H文件被包含)中出现的所有标识或符号,负责形成逻辑、语法正确的代码

连接器,负责形成和调整函数的相对地址,并保证在CPP中,每次函数调用(也就是地址转移),都是有效的,每个对内存数据的访问的地址,是有效的。

最终翻译成汇编代码或机器代码。

为收集标识和符号,编译器维护一个符号映射表,有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->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(),

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

}

}

软件开发最重要的是技术吗?

    最近在写毕业论文,胡思乱想的东西多了些,看的东西也杂了一些。虽然我还没毕业,有些想法太过于理想化或太幼稚,但总觉得既然有想法还是写下来好,即使没什么用也聊以自娱。    最近一直在想的问题之一...
  • Witwind
  • Witwind
  • 2004年01月29日 12:53
  • 1653

C++重要的几个概念

1、虚继承 在默认情况下,派生类对象中应该包含子类那部分。如果某个类在派生过程中出现了多次,则应该有包含该类的多个子对象。但是这样显然对iostream是行不通的,一个iostream对...
  • ouyangjinbin
  • ouyangjinbin
  • 2016年04月06日 23:30
  • 521

Java四大核心技术思想详解

此篇博客是我在腾讯兴趣部落上无意中看到的,觉得有必要收藏一下,奈何不知道如何分享过来,就施展了乾坤大挪移Copy了过来,并无抄袭之意,相反,谢谢原创作者,我会仔细品读回味,Thanks 。...
  • CSDN_Terence
  • CSDN_Terence
  • 2016年11月03日 16:42
  • 1795

面向对象技术的基础概念和特点

对象的产生方式:             1,以原型对象为基础产生新对象;             2,以类为基础产生新对象。     几个重要概念:             1,对象。对象不...
  • yAodoNg_y
  • yAodoNg_y
  • 2012年11月01日 11:02
  • 1979

C++多态性的理解和举例

多态性是面向对象c'x'de
  • lanzhihui_10086
  • lanzhihui_10086
  • 2014年08月05日 20:43
  • 810

C++ 多态性有哪些

C++多态性有哪些?       概念:指相同的对象收到不同的消息或者不同的对象收到相同的消息时产生的不同的实现动作。 C++支持两种多态:编译时多态(静态)、运行时多态(动态) (1)编译时多态...
  • YF_Li123
  • YF_Li123
  • 2017年07月03日 21:50
  • 1467

C++ 动态绑定的实现机制

1.为每一个包含虚函数的类设置一个虚表(VTABLE)每当创建一个包含有虚函数的类或从包含虚函数的类派生一个类时,编译器就会为这个类创建一个VTABLE。在VTABLE中,编译器放置了这个类中,或者它...
  • u012942555
  • u012942555
  • 2016年03月06日 07:36
  • 644

直方图均衡化原理及c++代码

//对图像进行灰度线性bianh BOOL CDibImage::LinerTrans(LPSTR lpDIBBits, LONG lWidth, LONG lHeight,    FLOAT f...
  • u010418035
  • u010418035
  • 2014年09月15日 11:41
  • 4357

c++中比较难于理解的部分。未完待续

1.指针。包括变量指针、函数指针等。可以计算。2.引用。包括变量的引用、函数的引用等。3.自由函数。4.类。包括具体类和抽象类。5.重载。包括函数重载和操作符重载。6.成员数据。包括static和非s...
  • jetcui1
  • jetcui1
  • 2007年06月14日 17:17
  • 1145

c++之多态性(动态绑定)

多态性    指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性:编译时多态性,运行时多态性。    a、编译时多态性:通过重载函数实现    b、运行时多态性:通...
  • mmshixing
  • mmshixing
  • 2016年05月11日 11:39
  • 826
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:“多态性”是C++最关键和核心的一个特性,“动态绑定技术”是C++编译器最重要的一个技术!欢迎C++高手进来指正我的粗浅理解
举报原因:
原因补充:

(最多只允许输入30个字)