在 C++ 中如何确定对象的大小？

Question

例如，假设我有一个 Temp 类：

class Temp
{
    public:
        int function1(int foo) { return 1; }
        void function2(int bar) { foobar = bar; }

    private:
        int foobar;
};

当我创建 Temp 类的对象时，我将如何计算它需要多少空间，以及它在内存中如何表示（例如| foobar 为 4 个字节| function1 为 8 个字节 | 等等| )

Answer 1

对于一阶近似，对象的大小是其组成数据成员的大小之和。 您可以确定它永远不会比这个小。

更准确地说，编译器有权在数据成员之间插入填充空间，以确保每个数据成员满足平台的对齐要求。 一些平台对对齐非常严格，而其他平台（x86）则更宽松，但通过正确的对齐会表现得更好。 因此，即使编译器优化设置也会影响对象大小。

继承和虚函数增加了额外的复杂性。 正如其他人所说，类本身的成员函数不占用“每个对象”空间，但该类接口中虚拟函数的存在通常意味着虚拟表的存在，本质上是一个用于函数指针的查找表动态解析正确的函数实现以在运行时调用。 虚拟表（vtbl）通常通过存储在每个对象中的指针来访问。

派生类对象还包括其基类的所有数据成员。

最后，访问说明符（公共、私有、受保护）为编译器提供了打包数据成员的一定余地。

简短的答案是 sizeof(myObj) 或 sizeof(MyClass) 总是会告诉您对象的正确大小，但其结果并不总是容易预测。

Answer 2

我一直想知道这个问题，所以我决定给出一个完整的答案。 这与您可能期望的内容有关，并且是可预测的（是的）！ 因此，根据以下信息，您应该能够预测班级的规模。

使用 Visual Studio Community 2017（版本 15.2），处于禁用所有优化和 RTTI 的发布模式 (运行时类型信息）关闭，我确定了以下内容：

---

简短答案：

首先：

• 在 32 (x86) 位中，== 4 字节
• 在 64 (x64) 位中，<指针大小> == 8 bytes
• 当我说“虚拟类继承”时，我的意思是： class ChildClass: virtual public ParentClass

现在，我的发现是：

• 空类是
• 空类的 1 字节继承类仍然是 1 个字节，
• 带有函数的空类仍然是 1 个字节（？！参见下面的注意解释）
• 带有函数的空类的继承仍然是 1 个字节，
• 向空类添加变量是 < code><变量大小> 字节
• 继承一个带有变量的类并添加另一个变量是 <变量大小> 字节
• 继承一个类并覆盖其函数添加一个 vtable（进一步在结论部分中提供了解释），并且是 <指针大小> 字节，
• 简单地将函数声明为虚拟，还添加了一个 vtable，使其<指针大小> bytes
• 虚拟类继承空类（带或不带成员函数）还会添加一个 vtable，并且使得类 bytes
• 虚拟类继承成为非空类还添加了一个 vtable，但它变得有些复杂：它添加 <指针大小> 字节到总数，包装所有成员变量以尽可能多的 <指针大小> 字节增量来覆盖 <成员变量的总大小> - 是的，你没看错。 （请参阅我对结论中发生的情况的猜测...）

注意我什至尝试使用 function() 计算一些文本，创建该类的实例，并调用该函数； 它不会改变函数类的大小（这不是优化）！ 我有点惊讶，但这实际上是有道理的：成员函数不会改变，因此它们可以存储在类本身的外部。

结论：

• 空类为 1 个字节，因为这是它存在于内存中所需的最小值。 一旦添加数据或 vtable 数据，就从 0 字节开始计数。
• 添加（非虚拟）成员函数对大小没有任何影响，因为成员函数是存储在外部。
• 将成员函数声明为虚拟的（即使该类没有被重写！）或重写子类中的成员函数会添加所谓的 “vtable”或“虚拟函数表”，允许动态调度 （这确实超级好用，我强烈推荐使用它）。 该虚函数表消耗<指针大小>字节，向所述类添加<指针大小>字节。 当然，这个虚函数表在每个类中只能存在一次（要么存在，要么不存在）。
• 添加成员变量会通过该成员变量增加类的大小，无论所述成员变量是在父类还是子类中（当然，父类仍然保持其自己的大小）。
• 虚拟类继承是唯一变得复杂的部分......所以......我认为经过一些实验后发生的事情是：类的大小实际上以 字节递增一次，即使它不需要消耗那么多内存，我猜测是因为它为每个<指针大小>字节内存或其他东西添加了一个vtable“辅助块” ...

---

长答案：

我使用以下代码确定了所有这些：

#include <iostream>

using namespace std;

class TestA
{

};

class TestB: public TestA
{

};

class TestC: virtual public TestA
{

};

class TestD
{
    public:
        int i;
};

class TestE: public TestD
{
    public:
        int j;
};

class TestF: virtual public TestD
{
    public:
        int j;
};

class TestG
{
    public:
        void function()
        {

        }
};

class TestH: public TestG
{
    public:
        void function()
        {

        }
};

class TestI: virtual public TestG
{
    public:
        void function()
        {

        }
};

class TestJ
{
    public:
        virtual void function()
        {

        }
};

class TestK: public TestJ
{
    public:
        void function() override
        {

        }
};

class TestL: virtual public TestJ
{
    public:
        void function() override
        {

        }
};

void main()
{
    cout << "int:\t\t" << sizeof(int) << "\n";
    cout << "TestA:\t\t" << sizeof(TestA) << "\t(empty class)\n";
    cout << "TestB:\t\t" << sizeof(TestB) << "\t(inheriting empty class)\n";
    cout << "TestC:\t\t" << sizeof(TestC) << "\t(virtual inheriting empty class)\n";
    cout << "TestD:\t\t" << sizeof(TestD) << "\t(int class)\n";
    cout << "TestE:\t\t" << sizeof(TestE) << "\t(inheriting int + int class)\n";
    cout << "TestF:\t\t" << sizeof(TestF) << "\t(virtual inheriting int + int class)\n";
    cout << "TestG:\t\t" << sizeof(TestG) << "\t(function class)\n";
    cout << "TestH:\t\t" << sizeof(TestH) << "\t(inheriting function class)\n";
    cout << "TestI:\t\t" << sizeof(TestI) << "\t(virtual inheriting function class)\n";
    cout << "TestJ:\t\t" << sizeof(TestJ) << "\t(virtual function class)\n";
    cout << "TestK:\t\t" << sizeof(TestK) << "\t(inheriting overriding function class)\n";
    cout << "TestL:\t\t" << sizeof(TestL) << "\t(virtual inheriting overriding function class)\n";

    cout << "\n";
    system("pause");
}

---

输出：

32 (x86) 位：

int:            4
TestA:          1       (empty class)
TestB:          1       (inheriting empty class)
TestC:          4       (virtual inheriting empty class)
TestD:          4       (int class)
TestE:          8       (inheriting int + int class)
TestF:          12      (virtual inheriting int + int class)
TestG:          1       (function class)
TestH:          1       (inheriting function class)
TestI:          4       (virtual inheriting function class)
TestJ:          4       (virtual function class)
TestK:          4       (inheriting overriding function class)
TestL:          8       (virtual inheriting overriding function class)

64 (x64) 位：

int:            4
TestA:          1       (empty class)
TestB:          1       (inheriting empty class)
TestC:          8       (virtual inheriting empty class)
TestD:          4       (int class)
TestE:          8       (inheriting int + int class)
TestF:          24      (virtual inheriting int + int class)
TestG:          1       (function class)
TestH:          1       (inheriting function class)
TestI:          8       (virtual inheriting function class)
TestJ:          8       (virtual function class)
TestK:          8       (inheriting overriding function class)
TestL:          16      (virtual inheriting overriding function class)

---

如果您想要有关多重继承的信息，去弄清楚你该死的自己！ -.-

Answer 3

方法属于类，而不属于任何特定的实例化对象。

除非有虚方法，否则对象的大小是其非静态成员的大小之和，加上成员之间用于对齐的可选填充。 成员可能会在内存中按顺序排列，但规范不保证具有不同访问规范的部分之间的排序，也不保证相对于超类布局的排序。

如果存在虚拟方法，vtable 和其他 RTTI 信息可能会占用额外的空间。

在大多数平台上，可执行代码位于可执行文件或库的只读 .text （或类似名称）部分，并且永远不会复制到任何地方。 当 class Temp 具有方法 public: int function1(int) 时，Temp 元数据可能具有指向 _ZN4Temp9function1Ei 的指针code>（损坏的名称可能会因编译器而异）函数用于实际实现，但肯定它永远不会包含嵌入的可执行代码。

Answer 4

sizeof(Temp)

会给你尺寸。 最有可能的是，它是 4 个字节（考虑到很多假设），并且这只适用于 int。 这些函数在每个对象的基础上不占用任何空间，它们被编译一次，并在每次使用时由编译器链接。

不可能确切地说出对象布局是什么，但是，该标准没有定义对象的二进制表示形式。

对于二进制表示，需要注意一些事情，比如它们不一定是数据成员的字节总和，因为 结构填充

Answer 5

成员函数不考虑特定类的对象的大小。 对象的大小仅取决于成员变量。 如果类包含虚函数，VPTR 将添加到对象布局中。 所以对象的大小基本上是成员变量的大小+ VPTR 的大小。 有时这可能不是真的，因为编译器尝试在 DWORD 边界定位成员变量。

Answer 6

如果您想了解有关对象在运行时如何在内存中表示的详细信息，ABI（应用程序二进制接口) 规范是要查看的地方。 您需要确定您的编译器实现了哪种 ABI； 例如，GCC 版本 3.2 及更高版本实现 Itanium C++ ABI。

Answer 7

如果您想检查特定结构的布局，offsetof(s,member) 宏也可能有用。 它告诉您特定成员距结构基地址有多远：

struct foo {
  char *a;
  int b;
};

// Print placement of foo's members
void printFoo() {
  printf("foo->a is %zu bytes into a foo\n", offsetof(struct foo, a));
  printf("foo->b is %zu bytes into a foo\n", offsetof(struct foo, b));
}

int main() {
  printFoo();
  return 0;
}

在典型的 32 位机器上将打印：

foo->a is 0 bytes into a foo
foo->b is 4 bytes into a foo

而在典型的 64 位机器上，它将打印

foo->a is 0 bytes into a foo
foo->b is 8 bytes into a foo

Answer 8

如果您使用的是 Microsoft Visual C++，有一个编译器选项可以告诉您对象的实际大小： /d1reportSingleClassLayout

除了 Lavavej 的这段视频之外，它没有任何文档记录 http://channel9.msdn.com/Shows/Going+Deep/C9-Lectures-斯蒂芬-T-Lavavej-高级-STL-3-of-n

Answer 9

这可能会有所帮助。

此外，类函数的表示方式与任何其他函数一样。 C++ 对函数所做的唯一魔法是修改函数名称，以使用特定类中的一组特定参数来唯一标识特定函数。

Answer 10

有一个实用程序调用 pahole （用于 'Poke-A- HOLE'），名义上是为了研究如何填充对象布局，但通常对于可视化对象大小和布局非常有用。

Answer 11

类的对象的大小等于该类的所有数据成员的大小之和。 例如，如果我

class student
{
private:   
   char name[20];
   int rollno, admno;
   float marks;

public:
  float tmarks, percentage;

  void getdata();

  void putdata();
};

现在有一个类，如果我创建该类的一个对象，例如 s1，那么该对象的大小将为 36 个字节：

[20(name)+2(rollno)+2(admno)+4(marks)+4(tmarks)+4(percentage)]