C++虚拟方法的对象大小

Question

我对虚拟对象的大小有一些疑问。

1) 虚函数

class A {
    public:
       int a;
       virtual void v();
    }

A类的大小为8字节....一个整数(4字节)加1个虚指针(4字节) 天气晴朗！

class B: public A{
    public:
       int b;
       virtual void w();
}

B级的尺寸是多少？我使用 sizeof B 进行了测试，它打印 12

B类和A类都有虚函数，是否意味着只有一个vptr？为什么只有一个vptr？

class A {
public:
    int a;
    virtual void v();
};

class B {
public:
    int b;
    virtual void w();
};

class C :  public A, public B {
public:
    int c;
    virtual void x();
};

C的sizeof是20......

看起来在这种情况下，布局中有两个vptr......这是怎么发生的？我认为两个 vptr 一个用于 A 类，另一个用于 B 类......那么 C 类的虚函数没有 vptr 吗？

我的问题是，继承中vptr的数量有什么规则？

2) 虚拟继承

    class A {
    public:
        int a;
        virtual void v();
    };

    class B: virtual public A{                  //virtual inheritance 
    public:
        int b;
        virtual void w();
    };

    class C :  public A {                      //non-virtual inheritance
    public:
        int c;
        virtual void x();
    };

class D: public B, public C {
public:
    int d;
    virtual void y();
};

A 的大小为 8 个字节 -------------- 4(int a) + 4 (vptr) = 8

B 的大小为 16 个字节 - ------------- 没有 virtual 应该是 4 + 4 + 4 = 12。为什么这里还有 4 个字节？ B类的布局是怎样的？

C的大小是12字节。 -------------- 4 + 4 + 4 = 12. 很清楚！

D 的大小是 32 字节 -------------- 应该是 16(class B) + 12(class C) + 4(int d) = 32，对吗？

    class A {
    public:
        int a;
        virtual void v();
    };

    class B: virtual public A{                       //virtual inheritance here
    public:
        int b;
        virtual void w();
    };

    class C :  virtual public A {                    //virtual inheritance here
    public:
        int c;
        virtual void x();
    };

  class D: public B, public C {
   public:
        int d;
        virtual void y();
    };

sizeof A is 8

sizeof B is 16

sizeof C is 16

sizeof D is 28 这是否意味着 28 = 16(class B) + 16(class C) - 8(class A) + 4 （这是什么？）

我的问题是，为什么应用虚拟继承时有多余的空间吗？

在这种情况下，对象大小的基本规则是什么？

当 virtual 应用于所有基类和部分基类时，有什么区别？

Answer 1

这是定义的所有实现。我正在使用 VC10 Beta2。帮助理解这个东西（虚函数的实现）的关键，你需要了解Visual Studio编译器中的一个秘密开关，/d1reportSingleClassLayoutXXX。我稍后会讲到这一点。

基本规则是，对于任何指向对象的指针，vtable 都需要位于偏移量 0 处。这意味着多重继承需要多个虚函数表。

这里有几个问题，我将从顶部开始：

是否意味着即使B类和A类都有虚函数，也只有一个vptr？为什么只有一个vptr？

这就是虚函数的工作原理，您希望基类和派生类共享相同的 vtable 指针（指向派生类中的实现。

在这种情况下，布局中似乎有两个 vptr......这是怎么发生的？我认为两个 vptr 一个用于 A 类，另一个用于 B 类......所以 C 类的虚函数没有 vptr ？

这是 C 类的布局，如 /d1reportSingleClassLayoutC 所报告的：

class C size(20):
        +---
        | +--- (base class A)
 0      | | {vfptr}
 4      | | a
        | +---
        | +--- (base class B)
 8      | | {vfptr}
12      | | b
        | +---
16      | c
        +---

你是对的，有两个 vtable，每个基类一个。这就是多重​​继承的工作原理；如果 C* 转换为 B*，则指针值将调整 8 个字节。 vtable 仍然需要位于偏移量 0 处才能使虚拟函数调用正常工作。

上述 A 类布局中的 vtable 被视为 C 类的 vtable（当通过 C* 调用时）。

B的大小是16字节-------------- 没有virtual应该是4 + 4 + 4 = 12。为什么这里又多了4个字节？ B类的布局是怎样的？

这是本例中类 B 的布局：

class B size(20):
        +---
 0      | {vfptr}
 4      | {vbptr}
 8      | b
        +---
        +--- (virtual base A)
12      | {vfptr}
16      | a
        +---

正如您所看到的，有一个额外的指针来处理虚拟继承。虚拟继承很复杂。

D 的大小是 32 字节 -------------- 应该是 16(class B) + 12(class C) + 4(int d) = 32，对吗？

不，36 字节。同样处理虚拟继承。本例中D的布局：

class D size(36):
        +---
        | +--- (base class B)
 0      | | {vfptr}
 4      | | {vbptr}
 8      | | b
        | +---
        | +--- (base class C)
        | | +--- (base class A)
12      | | | {vfptr}
16      | | | a
        | | +---
20      | | c
        | +---
24      | d
        +---
        +--- (virtual base A)
28      | {vfptr}
32      | a
        +---

我的问题是，为什么应用虚拟继承时会有多余的空格？

虚基类指针，比较复杂。基类在虚拟继承中被“组合”。该类将具有指向布局中基类对象的指针，而不是将基类嵌入到类中。如果您有两个使用虚拟继承（“钻石”类层次结构）的基类，它们都将指向对象中的同一个虚拟基类，而不是拥有该基类的单独副本。

在这种情况下，对象大小的基本规则是什么？

重要的一点；没有规则：编译器可以做任何它需要做的事情。

最后一个细节；为了制作我正在编译的所有这些类布局图：

cl test.cpp /d1reportSingleClassLayoutXXX

其中 XXX 是您想要查看其布局的结构/类的子字符串匹配。使用它，您可以自己探索各种继承方案的影响，以及添加填充的原因/位置等。

Answer 2

报价>我的问题是，继承中vptr的数量有什么规则？

没有规则，每个编译器供应商都可以按照他认为合适的方式实现继承语义。

class B：public A {}，size = 12。这很正常，B 的一个 vtable 具有两个虚拟方法，vtable 指针 + 2*int = 12

class C：public A，public B {}，size = 20。C可以任意扩展 A 或 B 的 vtable。 2*vtable 指针 + 3*int = 20

虚拟继承：这就是您真正触及未记录行为边缘的地方。例如，在 MSVC 中，#pragma vtordisp 和 /vd 编译选项变得相关。 本文中提供了一些背景信息。我研究了几次，并认为编译选项缩写词代表了如果我使用它的话我的代码可能会发生什么。

Answer 3

思考这个问题的一个好方法是了解必须采取哪些措施来处理向上转换。我将尝试通过显示您描述的类的对象的内存布局来回答您的问题。

代码示例 #2

内存布局如下：

vptr | A::a | B::b

将指向 B 的指针向上转换为类型 A 将产生相同的地址，并使用相同的 vptr。这就是为什么这里不需要额外的 vptr。

代码示例 #3

vptr | A::a | vptr | B::b | C::c

正如您所看到的，这里有两个 vptr，正如您所猜测的那样。为什么？因为确实，如果我们从 C 向上转换到 A，我们不需要修改地址，因此可以使用相同的 vptr。但是，如果我们从 C 向上转换到 B，我们确实需要进行修改，相应地，我们在结果对象的开头需要一个 vptr。

因此，除了第一个类之外的任何继承类都需要额外的 vptr（除非该继承类没有虚方法，在这种情况下它没有 vptr）。

代码示例 #4 及其他

当您进行虚拟派生时，您需要一个新指针（称为基指针）来指向派生类的内存布局中的位置。当然，可以有多个基指针。

那么内存布局是怎样的呢？这取决于编译器。在您的编译器中，它可能类似于

vptr | base pointer | B::b | vptr | A::a | C::c | vptr | A::a
          \-----------------------------------------^

但其他编译器可能会在虚拟表中合并基指针（通过使用偏移量 - 这值得另一个问题）。

您需要一个基指针，因为当您以虚拟方式派生时，派生类只会在内存布局中出现一次（如果它也是正常派生的，则可能会出现多次，如您的示例所示），因此它的所有子级都必须指向完全相同的位置。

编辑：澄清 - 这完全取决于编译器，我显示的内存布局在不同的编译器中可能不同。

Answer 4

所有这一切都是您意识到的完全实现定义的。你不能指望其中任何一个。没有“规则”。

在继承示例中，类 A 和 B 的虚拟表可能如下所示：

      class A
+-----------------+
| pointer to A::v |
+-----------------+

      class B
+-----------------+
| pointer to A::v |
+-----------------+
| pointer to B::w |
+-----------------+

正如您所看到的，如果您有一个指向类 B 的虚拟表的指针，那么它作为类 A 的虚拟表也是完全有效的。

在你的 C 类示例中，如果你想一想，没有办法创建一个对于 C 类、A 类和 B 类都有效的虚拟表。因此编译器会创建两个。一个虚拟表对 A 类和 C 类有效（很可能），另一个虚拟表对 A 类和 B 类有效。

Answer 5

这显然取决于编译器的实现。
无论如何，我认为我可以从下面链接的经典论文给出的实现中总结出以下规则，该规则给出了示例中获得的字节数（D 类除外，它是 36 个字节而不是 32 个字节！！！） ：

类 T 的对象的大小为：

• 其字段的大小加上 T 继承的每个对象的大小总和加上 T 虚拟继承的每个对象的 4 个字节加上 4 个字节（仅当 T 需要另一个 v- 时）注意
• ：如果一个类 K 实际上被继承了多次（在任何级别），那么您只需添加一次 K 的大小

所以我们必须回答另一个问题：一个类何时需要另一个 v 表？

• 不从其他类继承的类只有在具有一个或多个虚拟方法时才需要 v 表。
• 否则，只有当它非虚拟继承的类都没有 v 表时，该类才需要另一个 v 表

规则的结尾（我认为可以应用它来匹配 Terry Mahaffey 在他的答案中解释的内容）:)

无论如何，我的建议是阅读 Bjarne Stroustrup（C++ 的创建者）的以下论文，它准确地解释了这些事情：如何许多虚拟表需要虚拟或非虚拟继承......为什么！

这确实是一本很好的读物：
http://www.hpc.unimelb.edu.au/nec/ g1af05e/chap5.html

Answer 6

我不确定，但我认为这是因为指向 虚拟方法表 的指针