C++系列总结——多态

释放双眼,带上耳机,听听看~!

前言

封装隐藏了类内部细节,通过继承加虚函数的方式,我们还可以做到隐藏类之间的差异,这就是多态(运行时多态)。多态意味一个接口有多种行为,今天就来说说C++的多态是怎么实现的。

编译时多态感觉没什么好说的,编译时直接绑定了函数地址。

多态

有下面这么一段代码:A有两个虚函数(virtual关键字修饰的函数),B继承了A,还有一个参数为A*的函数foo()

#include <iostream>
class A
{
public:
    A();
    virtual void foo();
    virtual void bar();
private:
    int a;
};
A::A() 
    : a( 1 )
{
}
void A::foo()
{
    std::cout << \"A::foo()\\n\";
    return;
}
void A::bar()
{
    std::cout << \"A::bar()\\n\";
    return;
}

class B : public A
{
public:
    B();
    virtual void foo();
    virtual void bar();
private:
    int b ;
};
B::B()
    : b( 2 )
{
}
void B::foo()
{
    std::cout << \"B::foo()\\n\";
    return;
}
void B::bar()
{
    std::cout << \"B::bar()\\n\";
    return;
}
void foo( A* x )
{
    x->foo();
    x->bar();
    return;
}

我们要先知道,对于虚函数的重写,规则要求编译器必须根据实际类型调用对应的函数,而不是像重写普通成员函数那样,直接调用当前类型的函数。

假设bar()是一个非虚函数,B重写了bar(),那么即使x指向B的对象,在foo()调用x->bar()时也还是输出\"A::bar()\"

这段代码编译成动态库的话,编译器就无法确定foo()的入参x指向的对象是什么类型了(父类指针可以指向自身类型的对象或任意子类的对象),因此编译器就无法直接得出foo()bar()实际的函数地址,无法完成函数调用。这中间肯定发生了什么!

题外话:一旦函数重写,A::foo()B::foo()就是两个函数,两个地址。如果只是单纯继承的话,之前介绍继承的时候说过,子类是不存在B:;foo()这个函数,而只是让编译器允许通过B类型的对象调用A::foo()

如何确定实际函数地址

一旦无法自然地想通一个流程,觉得中间缺了什么东西时,那肯定是编译器干了什么。因此还是要祭出gdb这件大杀器。

// 省略前面那段代码
int main()
{
    B* x = new B;
    foo( x );
    return 0;
}

当我们打印x的内容时,会发现其多了一个位于对象的首地址的_vptr.A,它其实指向了虚函数表

(gdb) p *x
$2 = {<A> = {_vptr.A = 0x400a70 <vtable for B+16>, a = 1}, b = 2}

foo()中的x->foo()x->bar()对应着如下汇编

    # x->foo()
   0x0000000000400815 <+8>: mov    %rdi,-0x8(%rbp) # 将rdi中的对象地址保存到-0x8(%rbp) 中
=> 0x0000000000400819 <+12>:    mov    -0x8(%rbp),%rax            
   0x000000000040081d <+16>:    mov    (%rax),%rax  # 取对象首地址的8个字节也就是_vptr.A 0x400a70保存到rax中
   0x0000000000400820 <+19>:    mov    (%rax),%rax # 再取出0x400a70这个地址存放的4个字节数据保存到rax中,其实就是B::foo()函数地址
   0x0000000000400823 <+22>:    mov    -0x8(%rbp),%rdx # 将对象地址保存到rdx中
   0x0000000000400827 <+26>:    mov    %rdx,%rdi # 将对象地址保存到rdi中,作为虚函数foo()的参数
   0x000000000040082a <+29>:    callq  *%rax  # 调用B::foo()
    # x->bar()
   0x000000000040082c <+31>:    mov    -0x8(%rbp),%rax       
   0x0000000000400830 <+35>:    mov    (%rax),%rax # 取对象首地址的8个字节也就是_vptr.A 0x400a70保存到rax中
   0x0000000000400833 <+38>:    add    $0x8,%rax # 跳过8字节,即0x400a70+8
   0x0000000000400837 <+42>:    mov    (%rax),%rax # 取出B::bar()的地址
   0x000000000040083a <+45>:    mov    -0x8(%rbp),%rdx
   0x000000000040083e <+49>:    mov    %rdx,%rdi
   0x0000000000400841 <+52>:    callq  *%rax # 调用B::bar()

看一下0x400a70这个地址的内容,更容易理解上面的汇编。

(gdb) x /4x 0x400a70
0x400a70 <_ZTV1B+16>:   0x0040095e  0x00000000  0x0040097c  0x00000000
(gdb) x 0x0040095e
0x40095e <B::foo()>:    0xe5894855          # 0x0040095e就是B::foo()的首地址
(gdb) x 0x0040097c
0x40097c <B::bar()>:    0xe5894855          # 0x0040097c就是B::bar()的首地址

从上面可以看出,虚函数表类似于一个数组,其中每个元素是该类实现的虚函数地址,利用虚函数表,就执行正确的函数了。

何时设置虚函数表

既然虚函数表是类数据结构里的一部分,那它的初始化肯定就是在类的构造函数里了,让我们去找找。
下面是B::B()的一部分汇编,A::A()也类似只不过是将A的虚函数表地址赋值给_vptr.A

   0x0000000000400941 <+19>:    callq  0x4008d2 <A::A()>        # 先构造父类
   0x0000000000400946 <+24>:    mov    -0x8(%rbp),%rax
   0x000000000040094a <+28>:    movq   $0x400a70,(%rax)       # 将B的虚函数表地址0x400a70保存到对象的首地址中,即给_vptr.A赋值
   0x0000000000400951 <+35>:    mov    -0x8(%rbp),%rax
   0x0000000000400955 <+39>:    movl   $0x2,0xc(%rax)           # 初始化列表

题外话:在更新虚函数表和初始化列表之后,才执行我们显式写在B::B()中的代码。

每个类都有一个自己的虚函数表,这在编译时就确定了。如果子类没有实现虚函数,虚函数表里对应位置的函数地址就还是父类的函数地址。

隐晦的错误

从上面我们知道

  • 虚函数表中的元素顺序就是函数声明的顺序,这在编译时就固定了。
  • 执行虚函数时,只是取了虚函数表中对应偏移的元素(即函数地址)去执行,并没有做符号绑定。这个偏移是由虚函数声明顺序决定的。
    基于这两点,如果我们在真正构造B的地方修改了虚函数的声明顺序,就会导致函数调用出错。
    简单验证一下,将最开始的那段代码编译为动态库(liba.so),并在main.cpp中调换其函数声明顺序
class A
{
public:
    A();
    virtual void bar();  
    virtual void foo();
private:
    int a;
};

class B : public A
{
public:
    B();
    virtual void bar();
    virtual void foo();
    int b;
};
void bar( A* x )
{
    x->foo();
    x->bar();
    return;
}
int main()
{
    B* b = new B;
    bar( b );
    return 0;
}

上面代码的输出是

B::bar()
B::foo()

与预期结果刚好相反

B::foo()
B::bar()

出现这样错误的原因就是在编译main.cpp时,编译器认为B::foo()是虚函数表的第二个元素,但实际在liba.so中B::foo()是虚函数表中的第一个元素。

强烈建议虚函数的声明顺序必须保持一致,而且增加虚函数时,只在尾部增加

结语

了解C++的多态实现后,对于理解其他语言的多态实现也是有益处的,本质都应当是在通过一个中间结构确定实际函数的地址。

除了以上内容外,还有

  • 不论是否能通过上下文判断出实际类型,只要是以指针方式调用虚函数,都会以虚函数表跳转的方式来调用函数。
  • 在构造函数中调用虚函数,并不会使用多态,而是直接调用函数地址。
    这两点通过上面的调试方法很容易就能确认。

gcc version 4.8.5

人已赞赏
随笔日记

公司随便开除人能够解决问题吗?

2020-11-9 4:13:03

随笔日记

SSH服务与tcp wrappers实验

2020-11-9 4:13:05

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索