对 C++ 基类布局感到困惑

Question

这是我的代码

#include <bits/stdc++.h>


class A{
    int val;
    char c;
};
class B:public A{
    char val;
};

struct C{
    int val;
    char c;
};
struct D:public C{
    char val;
};


int main()
{
    std::cout<<sizeof(B)<<std::endl; //8
    std::cout<<sizeof(D)<<std::endl; //12

}

为什么class 与struct 有不同的对齐方式

*** Dumping AST Record Layout
   0 | class A
   0 |   int val
   4 |   char c
     | [sizeof=8, dsize=5, align=4
     |  nvsize=5, nvalign=4]


*** Dumping AST Record Layout
   0 | class B
   0 |   class A (base)
   0 |     int val
   4 |     char c
   5 |   char val
     | [sizeof=8, dsize=6, align=4
     |  nvsize=6, nvalign=4]


*** Dumping AST Record Layout
   0 | struct C
   0 |   int val
   4 |   char c
     | [sizeof=8, dsize=8, align=4
     |  nvsize=8, nvalign=4]


*** Dumping AST Record Layout
   0 | struct D
   0 |   struct C (base)
   0 |     int val
   4 |     char c
   8 |   char val
     | [sizeof=12, dsize=9, align=4
     |  nvsize=9, nvalign=4]

Answer 1

在struct 的情况下考虑这个程序：

void f(C& cx)
{
    cx.c = 'x';
}

int main()
{
    D d{};
    d.D::val = 'y';
    f(d);
    std::cout << d.D::val << '\n';
}

此代码必须输出y。

在您的系统上，A 和C 结构的大小为8，因为有一个大小为4 和一个字符的成员，并且该结构必须与其最大成员正确对齐。这些结构体有 4 个字节的 int、1 个字节的 char 和 3 个填充字节。

赋值cx.c = 5;允许修改填充（任何结构体赋值都可以修改结构体填充）。因此，该填充不能用于存储基类元素。

但是，A 和 B 不可能有类似的示例，因为 A 的数据成员是私有的。不可能有函数void f(A& ax) { ax.c = 'x'; }，因此不会出现这种问题，编译器可以使用A 的填充区域来存储派生类成员。

---

注意：由于基类和派生类中都有数据成员，这两个类都不是 standard layout。

Answer 2

添加到@MM 答案，看起来即使您有A 类的公共constructor 和setter 成员函数，编译器仍将类B 数据成员存储在类A 的填充区域中（我试图强制编译器不要使用 A 类的尾部填充，但无法成功）。

可以在class.mem/19 中找到一条注释：

[ 注意：具有相同访问控制和非零大小（[intro.object]）的（非联合）类的非静态数据成员被分配，以便后面的成员在类对象中具有更高的地址。未指定具有不同访问控制的非静态数据成员的分配顺序。实现对齐要求可能会导致两个相邻的成员不能立即分配；管理虚拟功能（[class.virtual]）和虚拟基类（[class.mi]）的空间要求也是如此。 ——尾注]

从this添加更多答案：

该标准要求在内存中将具有相同访问控制的成员分组在一起。该分组决定了对象如何被填充，因此改变它可以/将会改变对象的大小。

更多来自this的回答：

这些类型的 dsize、nvsize 和 nvalign 被定义为它们的普通大小和对齐方式。这些属性仅对用作基类的非空类类型很重要。我们忽略 POD 的尾部填充，因为该标准的早期版本不允许我们将它用于其他任何事情，而且它有时允许更快地复制类型。

因此，在您的第一个示例中，A 不是用于布局目的的 POD，其尾部填充可用于 B::val，但在您的第二个示例中，它是 POD，其尾部填充不能重复使用。

#include <iostream>


class A {
    int val;
    char c;
public:
    A(int a, char b): val(a), c(b)
    {

    }
public:
    void setC(int a)
    {
        c = a;
    }
    char getC(void) const
    {
        return c;
    }
};

class B: public A {
    char val;
public:
    B(void): A(1,'2'), val('2')
    {

    }
public:
    char getVal(void) const
    {
        return val;
    }
};

struct C {
    int val;
    char c;
};
struct D: public C {
    char val;
};


int main()
{
    B a;
    a.setC(2370);
    std::cout << a.getVal() << " & " << a.getC() << std::endl;
    std::cout << sizeof(B) << std::endl; // 8
    std::cout << sizeof(D) << std::endl; // 12
    return 0;
}

输出：

2 & B
8
12 

要了解memory order and alignment 的课程，请参阅this。