我们都知道C++多态是通过虚函数表来实现的，那具体是什么样的大家清楚吗？开篇依旧提出来几个问题：

• 普通类对象是什么布局？
• 带虚函数的类对象是什么布局？
• 单继承下不含有覆盖函数的类对象是什么布局？
• 单继承下含有覆盖函数的类对象是什么布局？
• 多继承下不含有覆盖函数的类对象是什么布局？
• 多继承下含有覆盖函数的类对象的是什么布局？
• 多继承中不同的继承顺序产生的类对象布局相同吗？
• 虚继承的类对象是什么布局？
• 菱形继承下类对象是什么布局？
• 为什么要引入虚继承？
• 为什么虚函数表中有两个析构函数？
• 为什么构造函数不能是虚函数？
• 为什么基类析构函数需要是虚函数？
  
  

要回答上述问题我们首先需要了解什么是多态。

什么是多态？

多态可以分为编译时多态和运行时多态。

• 编译时多态：基于模板和函数重载方式，在编译时就已经确定对象的行为，也称为静态绑定。
• 运行时多态：面向对象的一大特色，通过继承方式使得程序在运行时才会确定相应调用的方法，也称为动态绑定，它的实现主要是依赖于传说中的虚函数表。
  
  

如何查看对象的布局？

在gcc中可以使用如下命令查看对象布局：

• g++ -fdump-class-hierarchy model.cc后查看生成的文件
  % h( r7 R4 I0 \) }& u* v

在clang中可以使用如下命令：
* ?* F0 L, X, z1 c

1. 
   
2. clang -Xclang -fdump-record-layouts -stdlib=libc++ -c model.cc
   ; t1 W. p& _3 s% K) k& m- v$ Y
3. // 查看对象布局
   8 R8 \$ V; v5 M0 l8 B+ w
4. clang -Xclang -fdump-vtable-layouts -stdlib=libc++ -c model.cc
   5 N( p2 ]7 n; C
5. // 查看虚函数表布局

复制代码

! C0 X6 M/ }! y5 ?& a. a

上面两种方式其实足够了，也可以使用gdb来查看内存布局，这里可以看文末相关参考资料。本文都是使用clang来查看的对象布局。

接下来让我们一起来探秘下各种继承条件下类对象的布局情况吧~

普通类对象的布局

如下代码：
; C( n; W/ L- q0 ~/ h2 X6 ?1 N

1. 
   6 ?- N, I3 R* [& J. w
2. struct Base {
   
3.    Base() = default;
   
4.    ~Base() = default;
   
5.    
   9 C; @. ?( [8 q
6.    void Func() {}
   
7. 
   
8.    int a;
   7 A* L  ]* J: K! C8 ~  q
9.    int b;
   ' Z$ C" C& S  J0 x. L
10. };
    , T2 M# n7 Y9 m+ `+ |
11. 
    / B; v; m/ j% W* b" n
12. int main() {
    ! g5 c7 h. v- R  ~" T  h% `  g
13.    Base a;
    / u+ {7 I. U/ n% y6 t# t& t
14.    return 0;
    6 H6 x' ?& ^5 I9 h# `+ w; J9 u7 R- t
15. }
    
16. 
    0 E0 d# ~( s: w5 j# u7 |
17. // 使用clang -Xclang -fdump-record-layouts -stdlib=libc++ -c model.cc查看

复制代码

输出如下：
" M7 D# L& V) W6 r+ X; o0 b

1. 
   
2. *** Dumping AST Record Layout
   - `& G- Q6 ]" H: d( S3 z
3.         0 | struct Base
   
4.         0 |   int a
   4 N- o( z+ g/ h4 s$ K8 U6 y
5.         4 |   int b
     r$ _8 t7 C' T- f) P% D
6.           | [sizeof=8, dsize=8, align=4,
   6 f, F# E' v# Z- W$ n' C4 c& ]
7.           |  nvsize=8, nvalign=4]
   
8. 
   , c# D( v( g9 q: X7 A& q2 n' J
9. *** Dumping IRgen Record Layout

复制代码

画出图如下：

从结果中可以看见，这个普通结构体Base的大小为8字节，a占4个字节，b占4个字节。
8 c. L& P) C% }+ d( B

带虚函数的类对象布局

1. 
   
2. struct Base {
   
3.    Base() = default;
   9 _; w) H: ?2 _) e0 |
4.    virtual ~Base() = default;
   
5.    
   
6.    void FuncA() {}
   
7. 
   
8.    virtual void FuncB() {
   
9.        printf("FuncB\n");
   
10.   }
    ' U2 ^9 [$ ~2 c& _5 p
11. 
    + {) |/ S  o' r/ K* w( {
12.    int a;
    9 Y' P  j' Q! p
13.    int b;
    
14. };
    # U9 i+ D$ C' M0 S; [
15. 
    
16. int main() {
    
17.    Base a;
    
18.    return 0;
      s9 ~; y) t( g4 g/ e4 V1 F# ?
19. }
    
20. 
    
21. // 这里可以查看对象的布局和相应虚函数表的布局
    8 R  X# s* l/ }1 F! M0 B
22. clang -Xclang -fdump-record-layouts -stdlib=libc++ -c model.cc
    : u$ C& E5 U5 \4 d
23. clang -Xclang -fdump-vtable-layouts -stdlib=libc++ -c model.cc

复制代码

对象布局如下：

1. 
   
2. *** Dumping AST Record Layout
   
3.         0 | struct Base
   
4.         0 |   (Base vtable pointer)
   
5.         8 |   int a
   # W5 ^, ~8 [) q5 C- h! r2 {' @
6.        12 |   int b
   ! `5 T5 A2 _5 G0 r6 M, n# A
7.           | [sizeof=16, dsize=16, align=8,
   8 p1 V: x/ H% A( y( N  ?
8.           |  nvsize=16, nvalign=8]
   1 Z7 p: {& A1 m7 \+ v
9. 
   8 Y( P  N+ Q" V* A* V
10. *** Dumping IRgen Record Layout

复制代码

这个含有虚函数的结构体大小为16，在对象的头部，前8个字节是虚函数表的指针，指向虚函数的相应函数指针地址，a占4个字节，b占4个字节，总大小为16。
% P8 }# Z5 ~" \, k7 o6 o% [" j' ^

虚函数表布局：

1. 
   ' N) n6 q: r$ c3 Z, K% M* A# b
2. Vtable for 'Base' (5 entries).
   
3.   0 | offset_to_top (0)
   ! g/ J* a& O( i' ]9 ]
4.   1 | Base RTTI
   : }5 ]1 e" X+ ~3 A
5.       -- (Base, 0) vtable address --
   
6.   2 | Base::~Base() [complete]
   
7.   3 | Base::~Base() [deleting]
   ( e. P- V7 {7 g3 Y2 l1 e. U- J# p2 J- [
8.   4 | void Base::FuncB()

复制代码

5 F! m' E$ d. l

画出对象布局图如下：

我们来探秘下传说中的虚函数表：

offset_to_top(0)：表示当前这个虚函数表地址距离对象顶部地址的偏移量，因为对象的头部就是虚函数表的指针，所以偏移量为0。

RTTI指针：指向存储运行时类型信息(type_info)的地址，用于运行时类型识别，用于typeid和dynamic_cast。

RTTI下面就是虚函数表指针真正指向的地址啦，存储了类里面所有的虚函数，至于这里为什么会有两个析构函数，大家可以先关注对象的布局，最下面会介绍。

单继承下不含有覆盖函数的类对象的布局

1. 
   $ P% P- m$ X  j0 U% ~- S, y% `4 s
2. struct Base {
   
3.    Base() = default;
   9 i* c: X% J; U: C1 Q
4.    virtual ~Base() = default;
   " M8 F: W0 g4 w  o. t2 G
5.    
   " s/ e+ A+ ~, w
6.    void FuncA() {}
   
7. 
   
8.    virtual void FuncB() {
   + T. L9 {- \: I4 }! l- O# P
9.        printf("Base FuncB\n");
   , f# L/ s! B6 {2 F2 `, A- v. I
10.   }
    
11. 
    
12.    int a;
    9 k  t2 \- ^' \; H( z
13.    int b;
    3 G. b: y9 j  h6 t2 s6 b- t
14. };
    
15. 
    
16. struct Derive : public Base{
    & _$ H( `: |* A2 Z; O- g
17. };
    - X. x; c8 Q3 [" ?' n* c
18. 
    
19. int main() {
    # ]& c% M) P5 Z- g+ d$ T* V
20.    Base a;
    
21.    Derive d;
    
22.    return 0;
      q) t5 Q* R3 b% z
23. }

复制代码

" ?) }8 X; t" B% [# r& n

子类对象布局：
, {7 u  r: z) E$ X# q) i

1. 
   
2. *** Dumping AST Record Layout
   
3.         0 | struct Derive
   
4.         0 |   struct Base (primary base)
   
5.         0 |     (Base vtable pointer)
   
6.         8 |     int a
   ; K6 f) `5 [# O( A
7.        12 |     int b
   4 L3 @& K% X, M5 I4 _) `  X
8.           | [sizeof=16, dsize=16, align=8,
   
9.           |  nvsize=16, nvalign=8]
   
10. 
    
11. *** Dumping IRgen Record Layout

复制代码

和上面相同，这个含有虚函数的结构体大小为16，在对象的头部，前8个字节是虚函数表的指针，指向虚函数的相应函数指针地址，a占4个字节，b占4个字节，总大小为16。
. S: g0 \" Q7 @4 q3 G9 @

子类虚函数表布局：

1. 
   
2. Vtable for 'Derive' (5 entries).
   % Q" \& h, h, S! h0 w- }/ Z
3.   0 | offset_to_top (0)
   % x, u+ ^) c6 a0 N& e0 w" n
4.   1 | Derive RTTI
   ( P8 K5 C2 w  I. y4 B( l$ n
5.       -- (Base, 0) vtable address --
   7 W! a1 m& G+ r- h# E  Q6 g! z5 d
6.       -- (Derive, 0) vtable address --
   
7.   2 | Derive::~Derive() [complete]
   % d0 J7 \6 l" e: Y
8.   3 | Derive::~Derive() [deleting]
   * E% ]0 |$ v; _( w: u. p
9.   4 | void Base::FuncB()

复制代码

画图如下：

这个和上面也是相同的，注意下虚函数表这里的FuncB函数，还是Base类中的FuncB，因为在子类中没有重写这个函数，那么如果子类重写这个函数后对象布局是什么样的，请继续往下看哈。

单继承下含有覆盖函数的类对象的布局
, v1 ^) k+ M1 L  t7 Y3 O

1. 
   $ X$ R. x  I* ~# ^
2. struct Base {
   
3.    Base() = default;
   
4.    virtual ~Base() = default;
   4 y$ s( n3 O( D- ]- P( W7 O
5.    
   ) D; ~. }0 N7 J, S# r4 l3 i! q
6.    void FuncA() {}
   ( O( Y: }% I" h7 q
7. 
   2 f7 M# V: h+ V3 H
8.    virtual void FuncB() {
   
9.        printf("Base FuncB\n");
   
10.   }
    
11. 
    
12.    int a;
    
13.    int b;
    ; ^4 }3 y' e4 Q5 y( l. e
14. };
    ) A2 N% |4 g  g" A
15. 
    0 ?6 s+ b0 d* V4 A. V' ~' a! X
16. struct Derive : public Base{
    ' ^3 |1 T! Z. i. R4 P7 X5 W$ o
17.    void FuncB() override {
    
18.        printf("Derive FuncB \n");
    
19.   }
    4 H4 D' Y, p3 R5 M
20. };
      J, u0 B% ^" `% ]3 o
21. 
    
22. int main() {
    
23.    Base a;
    
24.    Derive d;
    ; a3 \% T9 z' I3 @
25.    return 0;
    4 P8 i* t5 A4 c; s% x- y9 v
26. }

复制代码

子类对象布局：

1. 
   ; G3 b6 }/ i/ ]! D/ @5 g
2. *** Dumping AST Record Layout
   
3.         0 | struct Derive
   
4.         0 |   struct Base (primary base)
   " x9 {% Z; Q/ I) V! h0 H! B* f
5.         0 |     (Base vtable pointer)
   
6.         8 |     int a
   
7.        12 |     int b
   ) W4 g, E$ o  w' i5 v( Y- E4 T
8.           | [sizeof=16, dsize=16, align=8,
   & U) |7 Y3 ^7 Q! E7 ~# a: t
9.           |  nvsize=16, nvalign=8]
   
10. 
    
11. *** Dumping IRgen Record Layout

复制代码

依旧和上面相同，这个含有虚函数的结构体大小为16，在对象的头部，前8个字节是虚函数表的指针，指向虚函数的相应函数指针地址，a占4个字节，b占4个字节，总大小为16。
3 w7 L9 P! B, ~1 ^

子类虚函数表布局：

1. 
   
2. Vtable for 'Derive' (5 entries).
   
3.   0 | offset_to_top (0)
   
4.   1 | Derive RTTI
   
5.       -- (Base, 0) vtable address --
   4 k9 k1 R4 v6 r( K
6.       -- (Derive, 0) vtable address --
   
7.   2 | Derive::~Derive() [complete]
   & B, n& @1 a/ B' l( C! T: D% S
8.   3 | Derive::~Derive() [deleting]
   2 d  i# z. h$ Z( R2 w( D5 g
9.   4 | void Derive::FuncB()

复制代码

注意这里虚函数表中的FuncB函数已经是Derive中的FuncB啦，因为在子类中重写了父类的这个函数。

再注意这里的RTTI中有了两项，表示Base和Derive的虚表地址是相同的，Base类里的虚函数和Derive类里的虚函数都在这个链条下，这里可以继续关注下面多继承的情况，看看有何不同。

多继承下不含有覆盖函数的类对象的布局

1. 
   
2. struct BaseA {
   4 y0 V) @. F! K# @+ r0 d
3.    BaseA() = default;
   
4.    virtual ~BaseA() = default;
   7 X' U, G8 d! q" k* \0 e8 n! o" i) h
5.    
   % H) M; S. u) u( d: W1 {) G1 w
6.    void FuncA() {}
   $ x/ ~9 C4 z5 `1 S0 g3 \
7. 
   - r% ]' W: Y3 r$ b
8.    virtual void FuncB() {
   
9.        printf("BaseA FuncB\n");
   - w3 C. ]' K( t4 l1 }
10.   }
    # A; ~* v+ S0 _7 I
11. 
    
12.    int a;
    
13.    int b;
    . ]! Z' U4 k  A% M/ \1 I3 G
14. };
    4 ~6 n% w( l3 ]( O  N
15. 
    , ~. y, \1 R3 ~" ^
16. struct BaseB {
    
17.    BaseB() = default;
    
18.    virtual ~BaseB() = default;
    
19.    
    
20.    void FuncA() {}
    
21. 
    5 V  ~+ U3 w+ D: Y6 n. b
22.    virtual void FuncC() {
    
23.        printf("BaseB FuncC\n");
    ' N* m7 d) f2 |4 f+ m; e/ t1 D( z
24.   }
    % ~* X# G; y1 b: s# U
25. 
    
26.    int a;
    
27.    int b;
    
28. };
    6 E) k' n* V, q
29. 
    ' ?7 f) J7 e/ `# _
30. struct Derive : public BaseA, public BaseB{
    
31. };
    ! O/ L% D+ F/ Z  ]+ X, Y9 X- d
32. 
    + \/ @5 c) ]$ f3 c/ @
33. int main() {
    
34.    BaseA a;
    
35.    Derive d;
    " m4 N6 g4 P6 F5 s) h* P
36.    return 0;
    
37. }

复制代码

6 @1 a; s: k0 P9 u, G

类对象布局：
; }: B/ u& F/ ]+ @

1. 
   
2. *** Dumping AST Record Layout
   
3.         0 | struct Derive
   - m% b9 ^; U& [7 s( v/ B4 V
4.         0 |   struct BaseA (primary base)
   
5.         0 |     (BaseA vtable pointer)
   
6.         8 |     int a
   
7.        12 |     int b
   ; n% x; Q# S/ l1 h/ _% p: B  l9 k, T
8.        16 |   struct BaseB (base)
   0 o7 K" J$ W, o, T- L
9.        16 |     (BaseB vtable pointer)
   0 C7 w* z9 ^% M7 o. C% `
10.        24 |     int a
    
11.       28 |     int b
    1 |7 V( V) v0 ~3 {& X
12.          | [sizeof=32, dsize=32, align=8,
    
13.          |  nvsize=32, nvalign=8]

复制代码

9 O3 ^" O5 S& {3 y

Derive大小为32，注意这里有了两个虚表指针，因为Derive是多继承，一般情况下继承了几个带有虚函数的类，对象布局中就有几个虚表指针，并且子类也会继承基类的数据，一般来说，不考虑内存对齐的话，子类（继承父类）的大小=子类（不继承父类）的大小+所有父类的大小。
' Q5 x" a! G# t& w

虚函数表布局：

1. 
   & ~: [) V. J( q( F
2. Vtable for 'Derive' (10 entries).
   
3.   0 | offset_to_top (0)
   + n8 n! w! V# }9 o+ {. h- j$ `% S* r6 d5 o
4.   1 | Derive RTTI
   
5.       -- (BaseA, 0) vtable address --
   
6.       -- (Derive, 0) vtable address --
   : p; D/ H# L0 @$ k1 P  F
7.   2 | Derive::~Derive() [complete]
   - a) i/ X5 Q9 _2 |: R
8.   3 | Derive::~Derive() [deleting]
   
9.   4 | void BaseA::FuncB()
   " N8 p1 k+ k( U% d) f1 I; h& b+ [
10.   5 | offset_to_top (-16)
    
11.   6 | Derive RTTI
    7 B& E6 H+ y: ~4 R
12.       -- (BaseB, 16) vtable address --
    
13.   7 | Derive::~Derive() [complete]
    
14.       [this adjustment: -16 non-virtual]
    
15.   8 | Derive::~Derive() [deleting]
    : Z, A% ?: N6 K) Y
16.       [this adjustment: -16 non-virtual]
    
17.   9 | void BaseB::FuncC()

复制代码

( u$ L$ V3 x; U5 }/ i0 O) `! e

可画出对象布局图如下：

offset_to_top(0)：表示当前这个虚函数表（BaseA，Derive）地址距离对象顶部地址的偏移量，因为对象的头部就是虚函数表的指针，所以偏移量为0。
. n0 @5 H# u' o. i" k

再注意这里的RTTI中有了两项，表示BaseA和Derive的虚表地址是相同的，BaseA类里的虚函数和Derive类里的虚函数都在这个链条下，截至到offset_to_top(-16)之前都是BaseA和Derive的虚函数表。

offset_to_top(-16)：表示当前这个虚函数表（BaseB）地址距离对象顶部地址的偏移量，因为对象的头部就是虚函数表的指针，所以偏移量为-16，这里用于this指针偏移，下一小节会介绍。

注意下后面的这个RTTI：只有一项，表示BaseB的虚函数表，后面也有两个虚析构函数，为什么有四个Derive类的析构函数呢，又是怎么调用呢，请继续往下看~

多继承下含有覆盖函数的类对象的布局

1. 
   1 O1 Z4 g0 F2 L7 A$ ]
2. struct BaseA {
   
3.    BaseA() = default;
   
4.    virtual ~BaseA() = default;
   
5.    
   
6.    void FuncA() {}
   0 W) c: f6 N# o* k
7. 
   
8.    virtual void FuncB() {
   & O# `2 j7 S# H* E/ `2 t; L! d
9.        printf("BaseA FuncB\n");
   1 `# r* V8 s% Z: u9 Y
10.   }
    
11. 
    
12.    int a;
    
13.    int b;
    , N% K1 }$ s) S8 n
14. };
    + Z4 x; ]/ U- D7 i' p( y7 d8 G
15. 
      v4 D. H! q' u2 d
16. struct BaseB {
    
17.    BaseB() = default;
    
18.    virtual ~BaseB() = default;
    ! a0 W* J$ G2 j, ]& z
19.    
    
20.    void FuncA() {}
    
21. 
    + M1 x) i& H& I. s' ^' v
22.    virtual void FuncC() {
    / H* w# @; [5 k7 s1 a* p
23.        printf("BaseB FuncC\n");
    
24.   }
    1 z& M0 `" j3 c  h( v
25. 
    , Q8 I# P" D( {+ Z, K3 \
26.    int a;
    / `: P) U- S" J+ a7 v( B
27.    int b;
    & }( s% ~& Q! Q/ r
28. };
    
29. 
    + ~$ N9 p( D$ P* _: u1 K* s; b
30. struct Derive : public BaseA, public BaseB{
    6 C/ l% t) ?) q. {  ^* c
31.    void FuncB() override {
    8 A( h5 e5 R- V; R& V
32.        printf("Derive FuncB \n");
    
33.   }
    ! r0 {) @5 s2 E" N" e. j" b
34. 
    
35.    void FuncC() override {
      c5 J+ x2 W) @7 l) B" D$ S
36.        printf("Derive FuncC \n");
    
37.   }
    
38. };
    
39. 
    
40. int main() {
    
41.    BaseA a;
    
42.    Derive d;
    
43.    return 0;
    # u. p0 [7 I6 ^% G
44. }

复制代码

+ k0 }. `9 ^1 o# ]8 F

对象布局：

1. 
   : V- J: y* v( @0 y' F( A( c( P
2. *** Dumping AST Record Layout
   
3.         0 | struct Derive
   4 e* J& @7 ~  |  Y# B3 h# y
4.         0 |   struct BaseA (primary base)
   
5.         0 |     (BaseA vtable pointer)
   $ ?' Y$ R$ [4 F7 K7 c
6.         8 |     int a
   3 [: y0 N0 }" H7 t  [: Q) V" g
7.        12 |     int b
   
8.        16 |   struct BaseB (base)
   5 J; s, ?& R! j: c% R0 \
9.        16 |     (BaseB vtable pointer)
   
10.        24 |     int a
    7 P; N7 i# i* B
11.        28 |     int b
    / o: H4 y/ u9 A
12.           | [sizeof=32, dsize=32, align=8,
    
13.           |  nvsize=32, nvalign=8]
    " u/ ]) n# i5 j5 S5 W( Y, X$ n
14. 
    & \* p5 \3 w8 u
15. *** Dumping IRgen Record Layout

复制代码

类大小仍然是32，和上面一样。
$ y: s4 c( f) |4 v! [

虚函数表布局：

1. 
   
2. Vtable for 'Derive' (11 entries).
   
3.   0 | offset_to_top (0)
     |8 h9 {$ Z* d7 P: r
4.   1 | Derive RTTI
   3 E; @: A( p; f7 o
5.       -- (BaseA, 0) vtable address --
   
6.       -- (Derive, 0) vtable address --
   
7.   2 | Derive::~Derive() [complete]
   
8.   3 | Derive::~Derive() [deleting]
   
9.   4 | void Derive::FuncB()
   
10.   5 | void Derive::FuncC()
    5 h! K+ W5 l* I, L2 a6 m
11.   6 | offset_to_top (-16)
    / `9 B/ {  G( y, s# p! w
12.   7 | Derive RTTI
    2 d0 O- [( q4 t2 F3 Y/ O, N3 k
13.       -- (BaseB, 16) vtable address --
    
14.   8 | Derive::~Derive() [complete]
    
15.       [this adjustment: -16 non-virtual]
    
16.   9 | Derive::~Derive() [deleting]
    
17.       [this adjustment: -16 non-virtual]
    ( O/ B* A. V: ?1 k5 g( p8 l
18. 10 | void Derive::FuncC()
    
19.       [this adjustment: -16 non-virtual]

复制代码

offset_to_top(0)：表示当前这个虚函数表（BaseA，Derive）地址距离对象顶部地址的偏移量，因为对象的头部就是虚函数表的指针，所以偏移量为0。

再注意这里的RTTI中有了两项，表示BaseA和Derive的虚表地址是相同的，BaseA类里的虚函数和Derive类里的虚函数都在这个链条下，截至到offset_to_top(-16)之前都是BaseA和Derive的虚函数表。

offset_to_top(-16)：表示当前这个虚函数表（BaseB）地址距离对象顶部地址的偏移量，因为对象的头部就是虚函数表的指针，所以偏移量为-16。当基类BaseB的引用或指针base实际接受的是Derive类型的对象，执行base->FuncC()时候，由于FuncC()已经被重写，而此时的this指针指向的是BaseB类型的对象，需要对this指针进行调整，就是offset_to_top(-16)，所以this指针向上调整了16字节，之后调用FuncC()，就调用到了被重写后Derive虚函数表中的FuncC()函数。这些带adjustment标记的函数都是需要进行指针调整的。至于上面所说的这里虚函数是怎么调用的，估计您也明白了吧~

多重继承不同的继承顺序导致的类对象的布局相同吗？
' n7 J, u/ F2 M$ C8 y

1. 
   
2. struct BaseA {
   # `$ W0 B4 E- x
3.    BaseA() = default;
   
4.    virtual ~BaseA() = default;
   ; e- `# t# ^6 M6 x- y
5.    
   ( H% y% g( w3 r( ?% ^' v
6.    void FuncA() {}
   7 ~% x! {5 v& j. f
7. 
   
8.    virtual void FuncB() {
   
9.        printf("BaseA FuncB\n");
   
10.   }
    / E% {% g9 |/ M* d! D/ f% n+ O
11. 
    
12.    int a;
    7 A2 Y9 a5 C4 F6 s- w
13.    int b;
    / g7 @) u( G+ a; }3 l3 ~0 q+ B
14. };
    
15. 
    
16. struct BaseB {
    
17.    BaseB() = default;
    - z' U3 ]3 ?+ q7 L* j
18.    virtual ~BaseB() = default;
    6 `8 x: l* H# W; Q/ p! f
19.    
    
20.    void FuncA() {}
    
21. 
    ( X! |4 o% A- M& V
22.    virtual void FuncC() {
    
23.        printf("BaseB FuncC\n");
      f" e& ~1 f* x: o. }, }) I9 C2 ~
24.   }
    0 ^0 |6 I" Z9 o) G) \5 R
25. 
    # P! h, ?& t0 i. |5 C; ?6 H
26.    int a;
    
27.    int b;
    6 ]5 I8 R$ e7 t0 c0 w% A% Q& S* P! x
28. };
    ; g+ a( ]7 f" e. ^# Z+ v% o
29. 
    
30. struct Derive : public BaseB, public BaseA{
    0 J( K2 x; F3 K6 [9 {! n
31.    void FuncB() override {
    
32.        printf("Derive FuncB \n");
    
33.   }
    
34. 
    
35.    void FuncC() override {
    
36.        printf("Derive FuncC \n");
    0 H5 t7 y  }7 D. d4 R+ R. b2 q- E
37.   }
    0 A4 b! F; n% R5 x- G
38. };
    
39. 
    6 E! s; ?+ ?# e- e( y
40. int main() {
      y* t8 a, u2 `/ p6 |  k2 Q, x7 J
41.    BaseA a;
    
42.    Derive d;
    - O  U" R3 @9 \; [9 X( `8 s
43.    return 0;
    ) o0 i* S" ^5 J, ^1 u% _
44. }

复制代码

对象布局：

1. 
   
2. *** Dumping AST Record Layout
   ; o2 F3 d8 ?* J- v5 ~
3.         0 | struct Derive
   
4.         0 |   struct BaseB (primary base)
   
5.         0 |     (BaseB vtable pointer)
   ( ~- r5 x& Z, n; x! I* o+ J
6.         8 |     int a
   ' Q  Q8 w% L4 d* C  V) N! }/ u
7.        12 |     int b
   
8.        16 |   struct BaseA (base)
   ) C% o% ]6 Y; P& a
9.        16 |     (BaseA vtable pointer)
   
10.        24 |     int a
    ) C, C! t* c0 a& c& P4 Q8 h1 E
11.        28 |     int b
    ! H0 e3 s* N; C1 @. P3 G
12.           | [sizeof=32, dsize=32, align=8,
    7 m+ M; d: {' f2 O" Z6 @
13.           |  nvsize=32, nvalign=8]
    
14. 
    9 V! ]; U+ k& n& U( j4 {
15. *** Dumping IRgen Record Layout

复制代码

, ~; ?. J6 o- n0 Q

这里可见，对象布局和上面的不相同啦，BaseB的虚函数表指针和数据在上面，BaseA的虚函数表指针和数据在下面，以A，B的顺序继承，对象的布局就是A在上B在下，以B，A的顺序继承，对象的布局就是B在上A在下。

虚函数表布局：

1. 
   ( M& U0 A0 M% p- L* p
2. Vtable for 'Derive' (11 entries).
   4 A3 _& R  a# v. B2 [4 J8 {/ U
3.   0 | offset_to_top (0)
   
4.   1 | Derive RTTI
   2 |+ |  n2 c4 K' V8 I, X( |
5.       -- (BaseB, 0) vtable address --
   ( Q7 a) E" {/ C# a: Z3 d
6.       -- (Derive, 0) vtable address --
   0 @9 G0 D' M% p4 F7 k
7.   2 | Derive::~Derive() [complete]
   ; a4 y$ f" G( F. C1 u3 p
8.   3 | Derive::~Derive() [deleting]
   5 x2 Q5 _2 S# J
9.   4 | void Derive::FuncC()
   4 f0 A& [. U8 U8 L+ l! ?
10.   5 | void Derive::FuncB()
    
11.   6 | offset_to_top (-16)
    8 h$ |, [* t* H3 v8 `7 b
12.   7 | Derive RTTI
    4 |6 x8 s1 t: f1 z, k! y
13.       -- (BaseA, 16) vtable address --
    : f( ?' Y6 C- J$ E% Y3 X
14.   8 | Derive::~Derive() [complete]
    ; m3 m8 F* N4 t- ]% a
15.       [this adjustment: -16 non-virtual]
    
16.   9 | Derive::~Derive() [deleting]
    
17.       [this adjustment: -16 non-virtual]
    ( h4 r: {# n$ W. u
18. 10 | void Derive::FuncB()
    ' ]* X5 V6 Y! P2 \& l
19.       [this adjustment: -16 non-virtual]

复制代码

. o  V" _4 ?. Z5 k" p

对象布局图如下：

虚函数表的布局也有所不同，BaseB和Derive共用一个虚表地址，在整个虚表布局的上方，而布局的下半部分是BaseA的虚表，可见继承顺序不同，子类的虚表布局也有所不同。

虚继承的布局

1. 
   : U0 D  ]# k- s. ^
2. struct Base {
   
3.    Base() = default;
   
4.    virtual ~Base() = default;
   
5.    
   ' o$ b* R, Y; U& ]3 f4 C
6.    void FuncA() {}
   6 a- T5 E0 A* P& \5 X! C% A- n$ S
7. 
   
8.    virtual void FuncB() {
   1 c1 G0 E' Z% o8 `% t
9.        printf("BaseA FuncB\n");
   
10.   }
    
11. 
    
12.    int a;
      I6 ?9 i3 W2 p; H
13.    int b;
    
14. };
    
15. 
    7 e0 o+ U9 `4 Q5 D3 w. u* u
16. struct Derive : virtual public Base{
    : e$ l9 B$ T& I7 D
17.    void FuncB() override {
    ' s4 j+ P' @" j  g+ T# i
18.        printf("Derive FuncB \n");
    
19.   }
    
20. };
    
21. 
    3 ^0 H7 K/ I% x3 e
22. int main() {
      e  U5 @# a5 U5 x/ L- X! N) f
23.    Base a;
    
24.    Derive d;
    
25.    return 0;
    
26. }

复制代码

对象布局：

1. 
   
2. *** Dumping AST Record Layout
   
3.         0 | struct Derive
   
4.         0 |   (Derive vtable pointer)
   
5.         8 |   struct Base (virtual base)
   
6.         8 |     (Base vtable pointer)
   
7.        16 |     int a
   & t2 h$ ~% v9 }: _0 Y
8.        20 |     int b
   0 c/ K) Q9 N2 T; K* t5 _
9.           | [sizeof=24, dsize=24, align=8,
   
10.           |  nvsize=8, nvalign=8]
    / F4 j7 C. {" b
11. 
    9 p. i3 z: ^: {1 C1 [% W
12. *** Dumping IRgen Record Layout

复制代码

虚继承下，这里的对象布局和普通单继承有所不同，普通单继承下子类和基类共用一个虚表地址，而在虚继承下，子类和虚基类分别有一个虚表地址的指针，两个指针大小总和为16，再加上a和b的大小8，为24。

虚函数表：

1. 
   
2. Vtable for 'Derive' (13 entries).
   
3.   0 | vbase_offset (8)
   # h- g* x( x- N0 L
4.   1 | offset_to_top (0)
   ( _  x% }+ L' s% A3 w# s
5.   2 | Derive RTTI
   
6.       -- (Derive, 0) vtable address --
   
7.   3 | void Derive::FuncB()
   : o# A. J+ e+ v* E
8.   4 | Derive::~Derive() [complete]
   
9.   5 | Derive::~Derive() [deleting]
   ( `, k) L! o3 P9 x$ L
10.   6 | vcall_offset (-8)
    
11.   7 | vcall_offset (-8)
    ) p! f/ }7 k; ^) s+ g. l0 s
12.   8 | offset_to_top (-8)
    
13.   9 | Derive RTTI
    2 y( a' [0 U7 @' b! @
14.       -- (Base, 8) vtable address --
    1 n5 G+ h8 K. Z) h! c- [
15. 10 | Derive::~Derive() [complete]
      O& J6 Y4 w2 L5 l! x6 j! ~% `
16.       [this adjustment: 0 non-virtual, -24 vcall offset offset]
    % A# z* ]. X) G2 X0 @
17. 11 | Derive::~Derive() [deleting]
    
18.       [this adjustment: 0 non-virtual, -24 vcall offset offset]
    . g3 W/ g6 [( C% t
19. 12 | void Derive::FuncB()
    
20.       [this adjustment: 0 non-virtual, -32 vcall offset offset]

复制代码

对象布局图如下：

vbase_offset(8)：对象在对象布局中与指向虚基类虚函数表的指针地址的偏移量

vcall_offset(-8)：当虚基类Base的引用或指针base实际接受的是Derive类型的对象，执行base->FuncB()时候，由于FuncB()已经被重写，而此时的this指针指向的是Base类型的对象，需要对this指针进行调整，就是vcall_offset(-8)，所以this指针向上调整了8字节，之后调用FuncB()，就调用到了被重写后的FuncB()函数。

虚继承带未覆盖函数的对象布局
8 Y# i* t/ `$ K' e! D; e* R

1. 
   ! w+ E" r6 N2 ?; _& t8 p1 g! h
2. struct Base {
   
3.    Base() = default;
   
4.    virtual ~Base() = default;
   
5.    
   
6.    void FuncA() {}
   % q6 n$ I5 _+ e# L
7. 
   
8.    virtual void FuncB() {
   
9.        printf("Base FuncB\n");
   
10.   }
    
11. 
    
12.    virtual void FuncC() {
    ) ^( i& X" n7 v) T+ L; ?- E
13.        printf("Base FuncC\n");
    8 r8 U$ c+ P# O
14.   }
    # E' v  m$ X  S
15. 
    
16.    int a;
    " I9 r" E* q0 Y( u" _" O8 |6 R& e( A" L5 Q
17.    int b;
    
18. };
    
19. 
    
20. struct Derive : virtual public Base{
    : o' k! C( p6 T5 [9 H4 U. j, I
21.    void FuncB() override {
    
22.        printf("Derive FuncB \n");
    
23.   }
    ( s. N( R: E; [2 N3 [
24. };
    . H7 B2 T3 d: l( W3 K( i1 q! h3 n
25. 
    8 ~6 Y2 E2 B/ v. k
26. int main() {
    5 [' p7 |3 }9 R4 m1 \$ A0 d- t
27.    Base a;
    
28.    Derive d;
    
29.    return 0;
    % }/ Z1 o% I6 Q+ J) @
30. }

复制代码

对象布局：
, s8 v) V. K4 r

1. 
   
2. *** Dumping AST Record Layout
   
3.         0 | struct Derive
   8 Y, c6 X  M  A& l' q5 s
4.         0 |   (Derive vtable pointer)
   & z4 R1 E2 |4 j( ]" H2 W
5.         8 |   struct Base (virtual base)
   # R. A- f9 m0 a1 k! u
6.         8 |     (Base vtable pointer)
   
7.        16 |     int a
   4 N1 Z: W; x, {2 [* O+ R" z4 V+ ^
8.        20 |     int b
   
9.           | [sizeof=24, dsize=24, align=8,
   
10.           |  nvsize=8, nvalign=8]
    - X& G7 b3 i4 ^# {: o
11. 
    
12. *** Dumping IRgen Record Layout

复制代码

6 i6 O- `" F% I7 V  [2 T9 q

和上面虚继承情况下相同，普通单继承下子类和基类共用一个虚表地址，而在虚继承下，子类和虚基类分别有一个虚表地址的指针，两个指针大小总和为16，再加上a和b的大小8，为24。
; c7 X: }& o" N$ y8 Y7 D4 {( [

虚函数表布局：

1. 
   ; `2 h+ d. z) p2 g  O
2. Vtable for 'Derive' (15 entries).
   
3.   0 | vbase_offset (8)
   ; G$ \4 x- k( q; M) N/ W: d
4.   1 | offset_to_top (0)
   ; U4 k- m# D& ]+ z: \& @7 G
5.   2 | Derive RTTI
   
6.       -- (Derive, 0) vtable address --
     Q5 w# j8 W& p2 Q
7.   3 | void Derive::FuncB()
   
8.   4 | Derive::~Derive() [complete]
   
9.   5 | Derive::~Derive() [deleting]
   8 `; ]/ j3 A% P: w+ O, K; U
10.   6 | vcall_offset (0)
    
11.   7 | vcall_offset (-8)
    ( A' \5 e" Z/ n! }$ [1 z- z
12.   8 | vcall_offset (-8)
    
13.   9 | offset_to_top (-8)
    ; G9 h- D4 F7 }
14. 10 | Derive RTTI
    7 _) F' p0 z4 Z, [
15.       -- (Base, 8) vtable address --
    9 h/ S8 ~. R4 l# o- \' c
16. 11 | Derive::~Derive() [complete]
    4 u  e& |" s- [- B$ i* h
17.       [this adjustment: 0 non-virtual, -24 vcall offset offset]
    ! K, a5 Q! j" [. D) [
18. 12 | Derive::~Derive() [deleting]
    
19.       [this adjustment: 0 non-virtual, -24 vcall offset offset]
    ( b1 S% }, W  O0 c9 T; x: \4 r$ t
20. 13 | void Derive::FuncB()
    
21.       [this adjustment: 0 non-virtual, -32 vcall offset offset]
    
22. 14 | void Base::FuncC()

复制代码

% ?: _) {& v. |) z3 G

对象布局图如下：

vbase_offset(8)：对象在对象布局中与指向虚基类虚函数表的指针地址的偏移量
! M3 a: k# q' t  d- d& ]

vcall_offset(-8)：当虚基类Base的引用或指针base实际接受的是Derive类型的对象，执行base->FuncB()时候，由于FuncB()已经被重写，而此时的this指针指向的是Base类型的对象，需要对this指针进行调整，就是vcall_offset(-8)，所以this指针向上调整了8字节，之后调用FuncB()，就调用到了被重写后的FuncB()函数。

vcall_offset(0)：当Base的引用或指针base实际接受的是Derive类型的对象，执行base->FuncC()时候，由于FuncC()没有被重写，所以不需要对this指针进行调整，就是vcall_offset(0)，之后调用FuncC()。

菱形继承下类对象的布局

1. 
   0 w) Z8 D) T. o  y
2. struct Base {
   ; }2 v. A9 `  g" O# ~* ~
3.    Base() = default;
   & Z9 n% U- E! w
4.    virtual ~Base() = default;
   4 M$ q; ?) D) Y2 n8 x: e
5.    
   1 i# \) z+ _  c1 h& [8 L
6.    void FuncA() {}
   
7. 
   $ [8 n( e6 m9 u: c# Z+ F/ M; k( X
8.    virtual void FuncB() {
   
9.        printf("BaseA FuncB\n");
     [% m3 t  J( _/ n
10.   }
    & `5 B  M% o- z, A
11. 
    
12.    int a;
    
13.    int b;
    6 F1 u9 {; [5 p) F% z
14. };
    
15. 
    
16. struct BaseA : virtual public Base {
    
17.    BaseA() = default;
    * E/ }. ?/ l4 m: N- y' A
18.    virtual ~BaseA() = default;
    
19.    
    : O+ X; Q0 n: k/ T6 y
20.    void FuncA() {}
    
21. 
    
22.    virtual void FuncB() {
    
23.        printf("BaseA FuncB\n");
    6 E# U  J8 _: _* Q
24.   }
    
25. 
    & y7 z' Q0 ~( a
26.    int a;
    ) x6 i9 D" s" Q8 [- Z5 n
27.    int b;
    5 }- k1 d% }' p4 B2 }
28. };
    9 I1 {( @3 @' h+ u
29. 
    
30. struct BaseB : virtual public Base {
    
31.    BaseB() = default;
    
32.    virtual ~BaseB() = default;
    
33.    
    ( x0 w3 R( f9 g: X3 o1 Y7 n
34.    void FuncA() {}
    
35. 
    ) |) W! }, k( |- O
36.    virtual void FuncC() {
    # E* }& Q; |3 D( E' ?; G: {. p
37.        printf("BaseB FuncC\n");
    - H; ^; {) }& c1 q- _+ }) F9 k; Y- l
38.   }
    / v3 _! J& x# w! `; W2 I4 P3 U
39. 
    
40.    int a;
    
41.    int b;
    
42. };
    ' q; j: x9 H6 }
43. 
    
44. struct Derive : public BaseB, public BaseA{
    4 e! n" A8 B7 P3 @' H$ o
45.    void FuncB() override {
    
46.        printf("Derive FuncB \n");
    ) u- S: m$ d  s- J* ^
47.   }
    $ S! Q. K  B/ c8 v4 t
48. 
    4 _- `: H, e& `- b% r
49.    void FuncC() override {
    5 \2 c9 ^2 E, N% r
50.        printf("Derive FuncC \n");
    & ]  }. o0 \1 @5 r! j+ A4 a5 q
51.   }
    
52. };
    ' v- b% q% x( g. E4 g! Y
53. 
    ' A+ z6 ~% v  ]; S, Z0 }
54. int main() {
    
55.    BaseA a;
    
56.    Derive d;
    6 ?# q. e! u& c: ~4 |
57.    return 0;
    
58. }

复制代码

类对象布局：

1. 
   8 m& M1 {# X8 \6 I2 r! U
2. *** Dumping AST Record Layout
   7 ?: n2 {6 ~2 c* l7 `9 X
3.         0 | struct Derive
   
4.         0 |   struct BaseB (primary base)
   - q( F0 Y+ K8 d* X
5.         0 |     (BaseB vtable pointer)
     @9 o; h" Q& S. O5 D( \
6.         8 |     int a
   
7.        12 |     int b
   
8.        16 |   struct BaseA (base)
   
9.        16 |     (BaseA vtable pointer)
   
10.        24 |     int a
    
11.        28 |     int b
    
12.        32 |   struct Base (virtual base)
    
13.        32 |     (Base vtable pointer)
    
14.        40 |     int a
    
15.        44 |     int b
    9 F7 Q# ?7 {3 D! `: V6 \4 q& f0 A
16.           | [sizeof=48, dsize=48, align=8,
    
17.           |  nvsize=32, nvalign=8]
    / k3 i( f7 T9 k' g) O/ B
18. 
    " q& \, K) }6 u
19. *** Dumping IRgen Record Layout

复制代码

4 {7 k2 c- c( X. x2 `# {

大小为48，这里不用做过多介绍啦，相信您已经知道了吧。

虚函数表：

1. 
   
2. Vtable for 'Derive' (20 entries).
   
3.   0 | vbase_offset (32)
   
4.   1 | offset_to_top (0)
   5 I  v9 _' q/ }$ X0 c
5.   2 | Derive RTTI
   4 @2 e% m+ _" A8 l: I$ _( U
6.       -- (BaseB, 0) vtable address --
   - g( I( o  k1 {
7.       -- (Derive, 0) vtable address --
   / E, A$ F5 m' h' z) F
8.   3 | Derive::~Derive() [complete]
   
9.   4 | Derive::~Derive() [deleting]
   # {: m6 @0 H5 J  W7 c, E2 e! \
10.   5 | void Derive::FuncC()
    : L& W6 J: e7 W+ R, O3 U9 L+ e
11.   6 | void Derive::FuncB()
    $ R/ I! d$ @' C  g* _- S6 K2 E9 q
12.   7 | vbase_offset (16)
    
13.   8 | offset_to_top (-16)
    
14.   9 | Derive RTTI
    
15.       -- (BaseA, 16) vtable address --
    2 O6 O8 Q+ x/ l9 H+ j* q
16. 10 | Derive::~Derive() [complete]
    
17.       [this adjustment: -16 non-virtual]
    
18. 11 | Derive::~Derive() [deleting]
    * M9 o- Q) Q' H8 _3 F2 w7 j2 b6 \
19.       [this adjustment: -16 non-virtual]
    ( D" Z6 x* _9 o- T# f/ h
20. 12 | void Derive::FuncB()
    
21.       [this adjustment: -16 non-virtual]
    0 Y* O/ `) X2 a( h2 o
22. 13 | vcall_offset (-32)
    7 ]# m- E# V/ f% L
23. 14 | vcall_offset (-32)
    
24. 15 | offset_to_top (-32)
    . h/ m( n% B+ R* |# B3 G
25. 16 | Derive RTTI
    
26.       -- (Base, 32) vtable address --
    9 l' T: c7 h0 q
27. 17 | Derive::~Derive() [complete]
    ) ~2 s3 K/ ?- D* m
28.       [this adjustment: 0 non-virtual, -24 vcall offset offset]
    
29. 18 | Derive::~Derive() [deleting]
    
30.       [this adjustment: 0 non-virtual, -24 vcall offset offset]
    8 L; H% ~$ Y  N; y0 Y7 ~4 |1 e* V
31. 19 | void Derive::FuncB()
    
32.       [this adjustment: 0 non-virtual, -32 vcall offset offset]

复制代码

2 K! ?5 I" o; v# I$ J# g1 `

对象布局图如下：

vbase_offset (32)

vbase_offset (16)：对象在对象布局中与指向虚基类虚函数表的指针地址的偏移量

offset_to_top (0)

offset_to_top (-16)

offset_to_top (-32)：指向虚函数表的地址与对象顶部地址的偏移量。

vcall_offset(-32)：当虚基类Base的引用或指针base实际接受的是Derive类型的对象，执行base->FuncB()时候，由于FuncB()已经被重写，而此时的this指针指向的是Base类型的对象，需要对this指针进行调整，就是vcall_offset(-32)，所以this指针向上调整了32字节，之后调用FuncB()，就调用到了被重写后的FuncB()函数。

为什么要虚继承？

如图：

非虚继承时，显然D会继承两次A，内部就会存储两份A的数据浪费空间，而且还有二义性，D调用A的方法时，由于有两个A，究竟时调用哪个A的方法呢，编译器也不知道，就会报错，所以有了虚继承，解决了空间浪费以及二义性问题。在虚拟继承下，只有一个共享的基类子对象被继承，而无论该基类在派生层次中出现多少次。共享的基类子对象被称为虚基类。在虚继承下，基类子对象的复制及由此而引起的二义性都被消除了。

为什么虚函数表中有两个析构函数？

前面的代码输出中我们可以看到虚函数表中有两个析构函数，一个标志为deleting，一个标志为complete，因为对象有两种构造方式，栈构造和堆构造，所以对应的实现上，对象也有两种析构方式，其中堆上对象的析构和栈上对象的析构不同之处在于，栈内存的析构不需要执行 delete 函数，会自动被回收。

为什么构造函数不能是虚函数？

构造函数就是为了在编译阶段确定对象的类型以及为对象分配空间，如果类中有虚函数，那就会在构造函数中初始化虚函数表，虚函数的执行却需要依赖虚函数表。如果构造函数是虚函数，那它就需要依赖虚函数表才可执行，而只有在构造函数中才会初始化虚函数表，鸡生蛋蛋生鸡的问题，很矛盾，所以构造函数不能是虚函数。

为什么基类析构函数要是虚函数？

一般基类的析构函数都要设置成虚函数，因为如果不设置成虚函数，在析构的过程中只会调用到基类的析构函数而不会调用到子类的析构函数，可能会产生内存泄漏。

小总结

offset_to_top：对象在对象布局中与对象顶部地址的偏移量。

RTTI指针：指向存储运行时类型信息(type_info)的地址，用于运行时类型识别，用于typeid和dynamic_cast。

vbase_offset：对象在对象布局中与指向虚基类虚函数表的指针地址的偏移量。

vcall_offset：父类引用或指针指向子类对象，调用被子类重写的方法时，用于对虚函数执行指针地址调整，方便成功调用被重写的方法。

thunk: 表示上面虚函数表中带有adjustment字段的函数调用需要先进行this指针调整，才可以调用到被子类重写的函数。

最后通过两张图总结一下对象在Linux中的布局：

• A *a = new Derive(); // A为Derive的基类
  

如图：

a作为对象指针存储在栈中，指向在堆中的类A的实例内存，其中实例内存布局中有虚函数表指针，指针指向的虚函数表存放在数据段中，虚函数表中的各个函数指针指向的函数在代码段中。
) M6 T& ^7 a8 V4 I5 n. W- s

虚表结构大体如上图，正常的虚表结构中都含有后三项，当有虚继承情况下会有前两个表项。

0 l! S+ Z3 d6 C  }1 N7 q# X
" N% o2 v$ p$ s3 l+ X5 r/ Y! X