编译器是如何用汇编语言实现C++的虚函数表和隐式传递this指针(二)

最新推荐文章于 2022-08-07 17:43:22 发布
最新推荐文章于 2022-08-07 17:43:22 发布
阅读量1.1k 收藏
点赞数
分类专栏： 原理解析 文章标签： C++ 编译器 汇编语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmm19861210/article/details/9038283
版权 
#include <stdio.h>

class Base{
public: 
    Base(){
        puts("Base()");
    }

    virtual void fun1()
    {
        puts("Base::fun1()");
    }

    virtual void fun2()
    {
        puts("Base::fun2()");
    }

    virtual void fun3()
    {
        puts("Base::fun3()");
    }

    void fun4(){
        printf("Normal Base::fun4()\n");
    }

    ~Base(){
        puts("~Base()");
    }
};



class Derive : public Base
{
public: 
    Derive()
    {
        puts("Derive()");
    }

    void fun1()
    {
        puts("Derive::fun1()");
    }

    void fun2()
    {
        puts("Derive::fun2()");
    }

/*    void fun3()
    {
        puts("Derive::fun3()");
    }

  */  

    void fun4(){
        printf("Normal Derive::fun4()\n");
    }

    ~Derive(){
        puts("~Derive()");
    }
};

typedef void (*FUN) (void);

int main()
{
    FUN pfun1 = NULL;
    FUN pfun2 = NULL;
    FUN pfun3 = NULL;

    Derive b;
    printf("&b = %p\n",(&b));
    printf("vtable = %p\n",(int *)(&b));
    printf("*vtable = %p\n",**(int **)(&b));//取vtable第一个函数的地址
    printf("b = %p\n",*(int*)(&b));

    pfun1 = (FUN)**(int**)(&b);
    printf("fun1 = %p\n",pfun1);
    pfun1();
    pfun2 = (FUN)*(*(int**)(&b)+1);
    printf("fun2 = %p\n",pfun2);
    pfun2();
    //b.fun2();
    pfun3 = (FUN)*(*(int**)(&b)+2);
    printf("fun3 = %p\n",pfun3);
    pfun3();
    b.fun4();

    Base * pb = &b;
    pb->fun2();
    pb->fun3();
    pb->fun4();
    return 0;
}

/* 输出结果如下
Base()
Derive()
&b = 0xbfe919dc
vtable = 0xbfe919dc
*vtable = 0x80487ca
b = 0x80489e8
fun1 = 0x80487ca
Derive::fun1()
fun2 = 0x80487de
Derive::fun2()
fun3 = 0x804874c
Base::fun3()
Normal Derive::fun4()
Derive::fun2()
Base::fun3()
Normal Base::fun4()
~Derive()
~Base()
*/

//看一下汇编代码是如何实现的

/*	
	.file	"vtable.cpp"
	.section	.rodata
.LC0:
	.string	"Base()"
	.section	.text._ZN4BaseC2Ev,"axG",@progbits,_ZN4BaseC2Ev,comdat
	.align 2
	.weak	_ZN4BaseC2Ev
	.type	_ZN4BaseC2Ev, @function
_ZN4BaseC2Ev:  #Base的构造函数
.LFB1:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	8(%ebp), %eax
	movl	$_ZTV4Base+8, (%eax) #Base的vtable赋值给对象的前4个字节的地址空间
	movl	$.LC0, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE1:
	.size	_ZN4BaseC2Ev, .-_ZN4BaseC2Ev
	.section	.rodata
.LC1:
	.string	"Base::fun1()"
	.section	.text._ZN4Base4fun1Ev,"axG",@progbits,_ZN4Base4fun1Ev,comdat
	.align 2
	.weak	_ZN4Base4fun1Ev
	.type	_ZN4Base4fun1Ev, @function
_ZN4Base4fun1Ev:
.LFB3:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC1, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE3:
	.size	_ZN4Base4fun1Ev, .-_ZN4Base4fun1Ev
	.section	.rodata
.LC2:
	.string	"Base::fun2()"
	.section	.text._ZN4Base4fun2Ev,"axG",@progbits,_ZN4Base4fun2Ev,comdat
	.align 2
	.weak	_ZN4Base4fun2Ev
	.type	_ZN4Base4fun2Ev, @function
_ZN4Base4fun2Ev:
.LFB4:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC2, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE4:
	.size	_ZN4Base4fun2Ev, .-_ZN4Base4fun2Ev
	.section	.rodata
.LC3:
	.string	"Base::fun3()"
	.section	.text._ZN4Base4fun3Ev,"axG",@progbits,_ZN4Base4fun3Ev,comdat
	.align 2
	.weak	_ZN4Base4fun3Ev
	.type	_ZN4Base4fun3Ev, @function
_ZN4Base4fun3Ev:
.LFB5:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC3, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE5:
	.size	_ZN4Base4fun3Ev, .-_ZN4Base4fun3Ev
	.section	.rodata
.LC4:
	.string	"Normal Base::fun4()"
	.section	.text._ZN4Base4fun4Ev,"axG",@progbits,_ZN4Base4fun4Ev,comdat
	.align 2
	.weak	_ZN4Base4fun4Ev
	.type	_ZN4Base4fun4Ev, @function
_ZN4Base4fun4Ev:
.LFB6:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC4, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE6:
	.size	_ZN4Base4fun4Ev, .-_ZN4Base4fun4Ev
	.section	.rodata
.LC5:
	.string	"~Base()"
	.section	.text._ZN4BaseD2Ev,"axG",@progbits,_ZN4BaseD2Ev,comdat
	.align 2
	.weak	_ZN4BaseD2Ev
	.type	_ZN4BaseD2Ev, @function
_ZN4BaseD2Ev:
.LFB8:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	8(%ebp), %eax
	movl	$_ZTV4Base+8, (%eax)
	movl	$.LC5, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE8:
	.size	_ZN4BaseD2Ev, .-_ZN4BaseD2Ev
	.section	.rodata
.LC6:
	.string	"Derive()"
.globl _Unwind_Resume
	.section	.text._ZN6DeriveC1Ev,"axG",@progbits,_ZN6DeriveC1Ev,comdat
	.align 2
	.weak	_ZN6DeriveC1Ev
	.type	_ZN6DeriveC1Ev, @function
_ZN6DeriveC1Ev: #Derive的构造函数
.LFB12:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	.cfi_lsda 0x0,.LLSDA12
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	pushl	%esi
	pushl	%ebx
	subl	$16, %esp
	movl	8(%ebp), %eax
	movl	%eax, (%esp)
.LEHB0:
	.cfi_offset 3, -16
	.cfi_offset 6, -12
	call	_ZN4BaseC2Ev #先调用基类Base的构造函数 得到基类的vtable
.LEHE0:
	movl	8(%ebp), %eax
	movl	$_ZTV6Derive+8, (%eax)  #用子类的vtable覆盖
	movl	$.LC6, (%esp)
.LEHB1:
	call	puts
.LEHE1:
	jmp	.L18
.L17:
.L15:
	movl	%edx, %ebx
	movl	%eax, %esi
	movl	8(%ebp), %eax
	movl	%eax, (%esp)
	call	_ZN4BaseD2Ev
	movl	%esi, %eax
	movl	%ebx, %edx
	movl	%eax, (%esp)
.LEHB2:
	call	_Unwind_Resume
.LEHE2:
.L18:
	addl	$16, %esp
	popl	%ebx
	.cfi_restore 3
	popl	%esi
	.cfi_restore 6
	popl	%ebp
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE12:
	.size	_ZN6DeriveC1Ev, .-_ZN6DeriveC1Ev
.globl __gxx_personality_v0
	.section	.gcc_except_table,"a",@progbits
.LLSDA12:
	.byte	0xff
	.byte	0xff
	.byte	0x1
	.uleb128 .LLSDACSE12-.LLSDACSB12
.LLSDACSB12:
	.uleb128 .LEHB0-.LFB12
	.uleb128 .LEHE0-.LEHB0
	.uleb128 0x0
	.uleb128 0x0
	.uleb128 .LEHB1-.LFB12
	.uleb128 .LEHE1-.LEHB1
	.uleb128 .L17-.LFB12
	.uleb128 0x0
	.uleb128 .LEHB2-.LFB12
	.uleb128 .LEHE2-.LEHB2
	.uleb128 0x0
	.uleb128 0x0
.LLSDACSE12:
	.section	.text._ZN6DeriveC1Ev,"axG",@progbits,_ZN6DeriveC1Ev,comdat
	.section	.rodata
.LC7:
	.string	"Derive::fun1()"
	.section	.text._ZN6Derive4fun1Ev,"axG",@progbits,_ZN6Derive4fun1Ev,comdat
	.align 2
	.weak	_ZN6Derive4fun1Ev
	.type	_ZN6Derive4fun1Ev, @function
_ZN6Derive4fun1Ev:
.LFB13:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC7, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE13:
	.size	_ZN6Derive4fun1Ev, .-_ZN6Derive4fun1Ev
	.section	.rodata
.LC8:
	.string	"Derive::fun2()"
	.section	.text._ZN6Derive4fun2Ev,"axG",@progbits,_ZN6Derive4fun2Ev,comdat
	.align 2
	.weak	_ZN6Derive4fun2Ev
	.type	_ZN6Derive4fun2Ev, @function
_ZN6Derive4fun2Ev:
.LFB14:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC8, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE14:
	.size	_ZN6Derive4fun2Ev, .-_ZN6Derive4fun2Ev
	.section	.rodata
.LC9:
	.string	"Normal Derive::fun4()"
	.section	.text._ZN6Derive4fun4Ev,"axG",@progbits,_ZN6Derive4fun4Ev,comdat
	.align 2
	.weak	_ZN6Derive4fun4Ev
	.type	_ZN6Derive4fun4Ev, @function
_ZN6Derive4fun4Ev:
.LFB15:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$.LC9, (%esp)
	call	puts
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE15:
	.size	_ZN6Derive4fun4Ev, .-_ZN6Derive4fun4Ev
	.section	.rodata
.LC10:
	.string	"~Derive()"
	.section	.text._ZN6DeriveD1Ev,"axG",@progbits,_ZN6DeriveD1Ev,comdat
	.align 2
	.weak	_ZN6DeriveD1Ev
	.type	_ZN6DeriveD1Ev, @function
_ZN6DeriveD1Ev:
.LFB18:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	.cfi_lsda 0x0,.LLSDA18
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	pushl	%esi
	pushl	%ebx
	subl	$16, %esp
	movl	8(%ebp), %eax
	movl	$_ZTV6Derive+8, (%eax)
	movl	$.LC10, (%esp)
.LEHB3:
	.cfi_offset 3, -16
	.cfi_offset 6, -12
	call	puts
.LEHE3:
	movl	8(%ebp), %eax
	movl	%eax, (%esp)
.LEHB4:
	call	_ZN4BaseD2Ev
.LEHE4:
	addl	$16, %esp
	popl	%ebx
	.cfi_remember_state
	.cfi_restore 3
	popl	%esi
	.cfi_restore 6
	popl	%ebp
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
.L29:
	.cfi_restore_state
.L27:
	movl	%edx, %ebx
	movl	%eax, %esi
	movl	8(%ebp), %eax
	movl	%eax, (%esp)
	call	_ZN4BaseD2Ev
	movl	%esi, %eax
	movl	%ebx, %edx
	movl	%eax, (%esp)
.LEHB5:
	call	_Unwind_Resume
.LEHE5:
	.cfi_endproc
.LFE18:
	.size	_ZN6DeriveD1Ev, .-_ZN6DeriveD1Ev
	.section	.gcc_except_table
.LLSDA18:
	.byte	0xff
	.byte	0xff
	.byte	0x1
	.uleb128 .LLSDACSE18-.LLSDACSB18
.LLSDACSB18:
	.uleb128 .LEHB3-.LFB18
	.uleb128 .LEHE3-.LEHB3
	.uleb128 .L29-.LFB18
	.uleb128 0x0
	.uleb128 .LEHB4-.LFB18
	.uleb128 .LEHE4-.LEHB4
	.uleb128 0x0
	.uleb128 0x0
	.uleb128 .LEHB5-.LFB18
	.uleb128 .LEHE5-.LEHB5
	.uleb128 0x0
	.uleb128 0x0
.LLSDACSE18:
	.section	.text._ZN6DeriveD1Ev,"axG",@progbits,_ZN6DeriveD1Ev,comdat
	.section	.rodata
.LC11:
	.string	"&b = %p\n"
.LC12:
	.string	"vtable = %p\n"
.LC13:
	.string	"*vtable = %p\n"
.LC14:
	.string	"b = %p\n"
.LC15:
	.string	"fun1 = %p\n"
.LC16:
	.string	"fun2 = %p\n"
.LC17:
	.string	"fun3 = %p\n"
	.text
.globl main
	.type	main, @function
main:
.LFB19:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	.cfi_lsda 0x0,.LLSDA19
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	andl	$-16, %esp
	pushl	%esi
	pushl	%ebx
	subl	$56, %esp
	movl	$0, 32(%esp)
	movl	$0, 36(%esp)
	movl	$0, 40(%esp)
	leal	28(%esp), %eax
	movl	%eax, (%esp)
.LEHB6:
	.cfi_escape 0x10,0x3,0x8,0x75,0x0,0x9,0xf0,0x1a,0x9,0xf8,0x22
	.cfi_escape 0x10,0x6,0x8,0x75,0x0,0x9,0xf0,0x1a,0x9,0xfc,0x22
	call	_ZN6DeriveC1Ev #调用构造函数
.LEHE6:
	leal	28(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$.LC11, (%esp)
.LEHB7:
	call	printf    #printf("&b = %p\n",(&b));
	leal	28(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$.LC12, (%esp)
	call	printf	#printf("vtable = %p\n",(int *)(&b));
	leal	28(%esp), %eax
	movl	(%eax), %eax
	movl	(%eax), %eax
	movl	%eax, 4(%esp)
	movl	$.LC13, (%esp)
	call	printf	#printf("*vtable = %p\n",**(int **)(&b));
	leal	28(%esp), %eax
	movl	(%eax), %eax
	movl	%eax, 4(%esp)
	movl	$.LC14, (%esp)
	call	printf    #printf("b = %p\n",*(int*)(&b));
	leal	28(%esp), %eax
	movl	(%eax), %eax
	movl	(%eax), %eax
	movl	%eax, 32(%esp)
	movl	32(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$.LC15, (%esp)
	call	printf    #printf("fun1 = %p\n",pfun1);
	movl	32(%esp), %eax
	call	*%eax     #    pfun1(); 
	leal	28(%esp), %eax
	movl	(%eax), %eax
	addl	$4, %eax
	movl	(%eax), %eax
	movl	%eax, 36(%esp)
	movl	36(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$.LC16, (%esp)
	call	printf   #printf("fun2 = %p\n",pfun2);
	movl	36(%esp), %eax
	call	*%eax     #pfun2();
	leal	28(%esp), %eax
	movl	(%eax), %eax
	addl	$8, %eax
	movl	(%eax), %eax
	movl	%eax, 40(%esp)
	movl	40(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$.LC17, (%esp)
	call	printf   # printf("fun3 = %p\n",pfun3);
	movl	40(%esp), %eax
	call	*%eax     #pfun3();
	leal	28(%esp), %eax
	movl	%eax, (%esp)
	call	_ZN6Derive4fun4Ev   # b.fun4();
	leal	28(%esp), %eax      #基类指针指向子类对象
	movl	%eax, 44(%esp)
	movl	44(%esp), %eax
	movl	(%eax), %eax        #经过一系列变幻得到*vtable
	addl	$4, %eax            #加4 得到_ZN6Derive4fun2Ev 即fun2。虽然都是fun2 基类是_ZN4Base4fun2Ev 与子类是不同的
	movl	(%eax), %edx
	movl	44(%esp), %eax
	movl	%eax, (%esp)
	call	*%edx     #pb->fun2();
	movl	44(%esp), %eax
	movl	(%eax), %eax
	addl	$8, %eax            #加8_ZN4Base4fun3Ev，因为子类没有重写所以这是基类Base的函数原型
	movl	(%eax), %edx
	movl	44(%esp), %eax
	movl	%eax, (%esp)
	call	*%edx    #pb->fun3();
	movl	44(%esp), %eax
	movl	%eax, (%esp)
	call	_ZN4Base4fun4Ev #  pb->fun4();;
.LEHE7:
	movl	$0, %ebx
	leal	28(%esp), %eax
	movl	%eax, (%esp)
.LEHB8:
	call	_ZN6DeriveD1Ev
.LEHE8:
	movl	%ebx, %eax
	addl	$56, %esp
	popl	%ebx
	.cfi_remember_state
	.cfi_restore 3
	popl	%esi
	.cfi_restore 6
	movl	%ebp, %esp
	.cfi_def_cfa_register 4
	popl	%ebp
	.cfi_restore 5
	.cfi_def_cfa_offset 4
	ret
.L33:
	.cfi_restore_state
.L31:
	movl	%edx, %ebx
	movl	%eax, %esi
	leal	28(%esp), %eax
	movl	%eax, (%esp)
	call	_ZN6DeriveD1Ev
	movl	%esi, %eax
	movl	%ebx, %edx
	movl	%eax, (%esp)
.LEHB9:
	call	_Unwind_Resume
.LEHE9:
	.cfi_endproc
.LFE19:
	.size	main, .-main
	.section	.gcc_except_table
.LLSDA19:
	.byte	0xff
	.byte	0xff
	.byte	0x1
	.uleb128 .LLSDACSE19-.LLSDACSB19
.LLSDACSB19:
	.uleb128 .LEHB6-.LFB19
	.uleb128 .LEHE6-.LEHB6
	.uleb128 0x0
	.uleb128 0x0
	.uleb128 .LEHB7-.LFB19
	.uleb128 .LEHE7-.LEHB7
	.uleb128 .L33-.LFB19
	.uleb128 0x0
	.uleb128 .LEHB8-.LFB19
	.uleb128 .LEHE8-.LEHB8
	.uleb128 0x0
	.uleb128 0x0
	.uleb128 .LEHB9-.LFB19
	.uleb128 .LEHE9-.LEHB9
	.uleb128 0x0
	.uleb128 0x0
.LLSDACSE19:
	.text
	.weak	_ZTV6Derive
	.section	.rodata._ZTV6Derive,"aG",@progbits,_ZTV6Derive,comdat
	.align 8
	.type	_ZTV6Derive, @object
	.size	_ZTV6Derive, 20
_ZTV6Derive:
	.long	0
	.long	_ZTI6Derive
	.long	_ZN6Derive4fun1Ev        #Derive vtable
	.long	_ZN6Derive4fun2Ev
	.long	_ZN4Base4fun3Ev
	.weak	_ZTV4Base
	.section	.rodata._ZTV4Base,"aG",@progbits,_ZTV4Base,comdat
	.align 8
	.type	_ZTV4Base, @object
	.size	_ZTV4Base, 20
_ZTV4Base:
	.long	0
	.long	_ZTI4Base      
	.long	_ZN4Base4fun1Ev         #Base vtable
	.long	_ZN4Base4fun2Ev
	.long	_ZN4Base4fun3Ev
	.weak	_ZTS6Derive
	.section	.rodata._ZTS6Derive,"aG",@progbits,_ZTS6Derive,comdat
	.type	_ZTS6Derive, @object
	.size	_ZTS6Derive, 8
_ZTS6Derive:
	.string	"6Derive"
	.weak	_ZTI6Derive
	.section	.rodata._ZTI6Derive,"aG",@progbits,_ZTI6Derive,comdat
	.align 4
	.type	_ZTI6Derive, @object
	.size	_ZTI6Derive, 12
_ZTI6Derive:
	.long	_ZTVN10__cxxabiv120__si_class_type_infoE+8
	.long	_ZTS6Derive
	.long	_ZTI4Base
	.weak	_ZTS4Base
	.section	.rodata._ZTS4Base,"aG",@progbits,_ZTS4Base,comdat
	.type	_ZTS4Base, @object
	.size	_ZTS4Base, 6
_ZTS4Base:
	.string	"4Base"
	.weak	_ZTI4Base
	.section	.rodata._ZTI4Base,"aG",@progbits,_ZTI4Base,comdat
	.align 4
	.type	_ZTI4Base, @object
	.size	_ZTI4Base, 8
_ZTI4Base:
	.long	_ZTVN10__cxxabiv117__class_type_infoE+8
	.long	_ZTS4Base
	.ident	"GCC: (GNU) 4.4.2 20091027 (Red Hat 4.4.2-7)"
	.section	.note.GNU-stack,"",@progbits

可以看出每个类都会通过继承链准备好自己的虚函数列表，所谓的基类指针指向子类对象的多态特性，是通过保存在子类对象的虚函数表实现的
而非虚函数的调用，如最后的 pb->fun4(); 无法通过pb保存的对象的地址空间的信息确定调用哪个，所以只能根据pb的类型来确定 如果这样调用 ((Derive*)pb)->fun4();
则会输出Normal Derive::fun4()，调用Derive::fun4()。
由此可知普通函数调用编译器根据指针类型来确定，虚函数调用编译器根据对应类的虚函数表确定。
*/

尘世一小猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++虚函数实现原理和虚函数表
菁华如风的博客
12-09 752
C++规定了虚函数的行为，但将实现方法留给了编译器作者。通常，编译器处理虚函数的方法是：给每个对象添加一个隐藏成员。隐藏成员中保存了一个指向函数地址数组的指针。这种数组称为虚函数表（virtual function table, vtbl）。虚函数表中存储了为类对象进行声明的虚函数的地址。 例如，基类对象包含这样一个指针，该指针指向基类中所有虚函数的地址表。派生类对象将包含一个指向独立地址表的指针。如果派生类提供了虚函数的新定义，该虚函数表将保存新函数的地址；如果派生类没有重新定义虚函数，该vtbl将保.
编译器处理虚函数的原理
u012359674的博客
08-01 1848
1）通常，编译器给类的每个对象添加一个隐藏的成员，这个成员保存了一个指向虚函数表（virtual function table，vtbl）的指针，而虚函数表中保存了类对象进行声明的虚函数的地址。也就是说我们可以通过这个隐藏成员访问虚函数表，进而访问被声明的虚函数的的地址，从而调用虚函数。 2）现在来看基类和派生类虚函数表的区别和联系，首先需要知道，基类和派生类的虚函数表是两个东西，保存在不同位置...
汇编视角分析C++虚函数实现原理
GetnextWindow的专栏
08-07 641
虚函数是c++语言非常重要的机制，日常的c++编程工作中经常使用虚函数，通过汇编视角来探究虚函数的实现原理，有助于深刻理解虚函数的内部机制。c++语法规范并没有规定虚函数的具体实现方案，不同的编译器实现方式可以不同，本文基于arm32平台，g++编译器来分析虚函数表的实现机制，基本主流编译器的原理基本是相似的，所以理解g++实现方案再去分析其他编译器的实现也是类似的。......
虚函数机制
与时俱进的专栏
12-10 469
先说一下类继承的内存分布和this指针： 子类的对象内存布局包括两部分：父类和子类派生部分，所以执行父类的构造函数只不过是在构造子类对象的父类部分。因此子类对象的this指针当然是指向子类对象自己了。所谓基类子类是一个大结构体，this指向了该大结构体的地址，其中this指针开头的四个字节存放虚函数表头指针。 理解虚函数( virtual function )的几个关键点： 1.
C++虚函数的实现细节、虚析构函数 汇编解析
山穷水尽疑无路，柳暗花明又一村！
10-24 1805
   C++里多态的实现，依靠的是虚函数的运行时函数地址确定，不过真正的实现过程，还是在编译阶段。编译器究竟对虚函数做了怎样的处理？这就是本文所描述的。然后又对虚函数中最特殊的虚析构函数的运行情况进行了分析。   1、类的存储空间   在INTEL 32 CPU，VC6环境下，空类的一个实例占一个字节（特例）；   一个C++类本身（注意：不是对象）,在内存里是有信息的, 比如虚函数表、静态成员变
C++中this指针用法详解及实例
01-01
在类中，this指针作为一个变量通过编译器隐式传递给非暂存(non-static)成员函数。因为this指针不是对象本身，因此sizeof函数并不能用于确定this指针所对应的对象大小。this指针的具体类型与具体对象的类型以及对象...
java及C++中传值传递、引用传递和指针方式的理解
09-04
C++则提供了值传递、引用传递和指针传递，让程序员可以根据需求选择最适合的方式来操作函数参数。值传递确保了函数的不可变性，引用传递和指针传递则提供了更高的灵活性，允许直接修改原始对象。在编写代码时，理解...
从汇编角度看虚函数和普通成员函数的调用过程
12-20
调用时，编译器会隐式地传递一个隐藏的`this`指针，指向调用该函数的对象，以便访问对象的数据成员。例如，假设有一个类`MyClass`和一个正常成员函数`func()`，调用方式可能是这样的： ```cpp MyClass obj; obj.func...
C++ 虚函数表解析
08-13
在C++编程语言中，虚函数表（Virtual Function Table，简称vtable）是实现多态性的一个关键机制。本文将深入探讨C++虚函数表的工作原理、用途以及如何解析它。 虚函数表是一个由编译器自动生成的隐式数据结构，通常...
C++虚函数知识点详解
lizfs_csdn的博客
06-20 381
1.虚函数的作用是什么？C++中的虚函数的作用主要是实现了多态的机制。基类定义虚函数，子类可以重写该函数；在派生类中对基类定义的虚函数进行重写时，需要在派生类中声明该方法为虚方法（virtual关键字）。函数的重载也可以认为是多态，但是是静态的，是编译时决定的，叫做静态联编。而虚函数是运行时决定的，是动态的，叫做动态联编。2.虚函数的底层实现机制是什么？实现原理：虚函数表+虚函数表指针。编译器处理虚函数的方法是：为每个类对象添加一个隐藏成员，隐藏成员中保存了一个指向函数地址数组的指针，称为虚表指针（vptr
类虚函数表原理实现分析
谢绝留言与私信
12-19 1188
原理分析 当调用一个虚函数时, 编译器生成的代码会调用 虚表地址[0](param1, param2)这样的函数. 已经不是在调用函数名了. 当我们将虚表地址[n]中的函数实现改为另外的函数, 虚函数的实现就由我们来控制了. 实验 根据虚表原理, 实验一下修改自己程序的虚函数表项地址.  使编译器生成的代码执行一个虚函数A时, 执行的是我们自己定义的非虚函数B. 知识点
C++虚函数与虚函数表
weixin_30914981的博客
05-15 102
多态性可分为两类：静态多态和动态多态。函数重载和运算符重载实现的多态属于静态多态，动态多态性是通过虚函数实现的。 每个含有虚函数的类有一张虚函数表(vtbl)，表中每一项是一个虚函数的地址， 也就是说，虚函数表的每一项是一个虚函数的指针。 没有虚函数的C++类，是不会有虚函数表的。 两张图： 简单例子： 1 #include <iostre...
C++编译器对虚函数和普通成员函数的处理方式
carltraveler的专栏
07-08 927
//现在的疑问是：既然虚函数表的访问指针已经被破坏，那怎么又会调到虚的析构函数呢。#include using namespace std;class CPoint {public:  int m_ix;  int m_iy;  CPoint(const int p_ix = 0
虚函数的工作原理
weixin_44788175的博客
03-27 1475
虚函数，虚函数表
虚函数的作用及其底层实现机制
热门推荐
iFuMI的博客
04-07 1万+
1. C++中虚函数的作用和多态虚函数： 实现类的多态性关键字：虚函数；虚函数的作用；多态性；多态公有继承；动态联编C++中的虚函数的作用主要是实现了多态的机制。基类定义虚函数，子类可以重写该函数；在派生类中对基类定义的虚函数进行重写时，需要再派生类中声明该方法为虚方法。当子类重新定义了父类的虚函数后，当父类的指针指向子类对象的地址时，[即B b; A a = &b;] 父类指针根据赋给它的不同子类
不同编译器虚函数的实现方式的区别
a3192048的博客
08-31 808
class base { virtual void f1() {} }; base bs; 问：“为什么bs虚函数表的地址（int*）(&amp;bs)与虚函数f1()地址（int*）*(int*)(&amp;bs) 不是同一个？” 注：题主理解错了，其实（int*）(&amp;bs)是对象bs的地址，即虚函数表的地址的地址。（int*）*(int*)(&amp;bs)才是虚函数表地址...
关于虚函数表的一些讨论
杨领well的专栏
04-07 1万+
关于虚函数表的一些讨论
从汇编代码分析c++虚函数表真正原理
u011569253的博客
07-07 1656
记得当年刚入行的时候经常看一些别人讲C++虚函数表，当时也不理解，别人怎么说就怎么信了。后来知道多了，发现以前的帖子很有问题，不知道你是否看过这样的图片。现在我用汇编分析真正虚函数是如何实现动态，如何生存虚函数表。如果你觉得有什么不对的地方欢迎交流。这个图片问题很大，我只是指出些这样帖子的人一些错误。下面来看我写的一对父子类class MyPreant { public: MyPreant();...
几秒读懂C++虚函数调用的汇编代码实现
dvlinker的技术专栏
10-30 6487
本文详细讲述C++虚函数调用的汇编代码实现。
C++函数堆栈的第一个栈 是this指针？
最新发布
06-01
this指针是一个指向类实例的指针，它指向当前正在执行的成员函数所属的对象，在函数内部可以使用this指针来访问对象的成员变量和成员函数。 this指针在C++编译器中是一个隐式的参数，它被自动添加到成员函数的参数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值