什么是聚合和普通类型/POD，以及它们如何/为何特殊？

Question

此常见问题解答是关于聚合和 POD 的，涵盖以下内容：

• 什么是聚合？
• 什么是POD（普通旧数据）？
• 最近，什么是平凡或平凡可复制类型？
• 它们有何关系？
• 它们如何以及为何如此特别？
• C++11 有哪些变化？

Answer 1

如何阅读：

这篇文章相当长。如果您想了解聚合和 POD（普通旧数据），请花时间阅读。如果您只对聚合感兴趣，请仅阅读第一部分。如果您只对 POD 感兴趣，那么您必须首先阅读聚合的定义、含义和示例，然后您可以跳转到 POD，但我仍然建议您完整阅读第一部分。聚合的概念对于定义 POD 至关重要。如果您发现任何错误（即使是很小的错误，包括语法、文体、格式、语法等），请发表评论，我会编辑。

这个答案适用于C++03。有关其他 C++ 标准，请参阅：

• C++11 更改
• C++14 更改
• C++17 更改
• C++20 变化

什么是聚合以及为什么它们很特殊

来自 C++ 标准的正式定义 (C++03 8.5.1 §1)< /强>：

聚合是一个数组或一个类（第 9 条），没有用户声明
构造函数 (12.1)，没有私有或受保护的非静态数据成员（第 11 条），
没有基类（第 10 条），也没有虚函数（10.3）。

那么，好吧，让我们解析一下这个定义。首先，任何数组都是聚合。一个类也可以是一个聚合，如果……等等！没有提到结构或联合，它们不能是聚合吗？是的，他们可以。在 C++ 中，术语class 指所有类、结构和联合。因此，当且仅当类（或结构或联合）满足上述定义的条件时，它才是聚合。这些标准意味着什么？

• 这并不意味着聚合类不能有构造函数，事实上它可以有默认构造函数和/或复制构造函数，只要它们是由编译器隐式声明的，而不是由用户显式声明的

• 没有私有或受保护< em>非静态数据成员。您可以根据需要拥有任意数量的私有和受保护的成员函数（但不能是构造函数）以及私有或受保护的静态数据成员和成员函数，并且不违反聚合类的规则

• 聚合类可以具有用户声明/用户定义的复制赋值运算符和/或析构函数

• 数组是聚合，即使它是非聚合类类型的数组。

现在让我们看一些例子：

class NotAggregate1
{
  virtual void f() {} //remember? no virtual functions
};

class NotAggregate2
{
  int x; //x is private by default and non-static 
};

class NotAggregate3
{
public:
  NotAggregate3(int) {} //oops, user-defined constructor
};

class Aggregate1
{
public:
  NotAggregate1 member1;   //ok, public member
  Aggregate1& operator=(Aggregate1 const & rhs) {/* */} //ok, copy-assignment  
private:
  void f() {} // ok, just a private function
};

您明白了。现在让我们看看聚合有何特殊之处。与非聚合类不同，它们可以使用大括号 {} 进行初始化。这种初始化语法对于数组来说是众所周知的，我们刚刚了解到它们是聚合。那么，让我们从他们开始吧。

类型 array_name[n] = {a1, a2, …, am};

if(m == n)
数组的第 i 个元素用_i
初始化
else if(m < n)
数组的前 m 个元素使用 a₁、a₂、...、a_m 和其他 n - m 进行初始化 元素，如果可能的话，值初始化（参见下面的术语解释）
else if(m > n)
编译器将发出错误
else （这是根本没有指定 n 的情况，例如 int a[] = {1, 2, 3};)
假设数组 (n) 的大小等于 m，因此 int a[] = {1, 2, 3}; 相当于 int a[3] = { 1, 2, 3};

当标量类型的对象 (bool, int, char, double< /code>、指针等）是值初始化的，这意味着它是用 0 对该类型进行初始化的（false 对于 bool、0.0 表示 double 等）。当具有用户声明的默认构造函数的类类型的对象被值初始化时，将调用其默认构造函数。如果隐式定义默认构造函数，则所有非静态成员都会递归地进行值初始化。这个定义不精确并且有点不正确，但它应该为您提供基本概念。不能对引用进行值初始化。例如，如果类没有适当的默认构造函数，则非聚合类的值初始化可能会失败。

数组初始化的示例：

class A
{
public:
  A(int) {} //no default constructor
};
class B
{
public:
  B() {} //default constructor available
};
int main()
{
  A a1[3] = {A(2), A(1), A(14)}; //OK n == m
  A a2[3] = {A(2)}; //ERROR A has no default constructor. Unable to value-initialize a2[1] and a2[2]
  B b1[3] = {B()}; //OK b1[1] and b1[2] are value initialized, in this case with the default-ctor
  int Array1[1000] = {0}; //All elements are initialized with 0;
  int Array2[1000] = {1}; //Attention: only the first element is 1, the rest are 0;
  bool Array3[1000] = {}; //the braces can be empty too. All elements initialized with false
  int Array4[1000]; //no initializer. This is different from an empty {} initializer in that
  //the elements in this case are not value-initialized, but have indeterminate values 
  //(unless, of course, Array4 is a global array)
  int array[2] = {1, 2, 3, 4}; //ERROR, too many initializers
}

现在让我们看看如何使用大括号初始化聚合类。几乎是一样的方式。我们将按照非静态数据成员在类定义中出现的顺序（根据定义它们都是公共的）来初始化非静态数据成员，而不是数组元素。如果初始值设定项少于成员，则其余的将进行值初始化。如果无法对未显式初始化的成员之一进行值初始化，则会出现编译时错误。如果初始化程序多于必要的数量，我们也会收到编译时错误。

struct X
{
  int i1;
  int i2;
};
struct Y
{
  char c;
  X x;
  int i[2];
  float f; 
protected:
  static double d;
private:
  void g(){}      
}; 

Y y = {'a', {10, 20}, {20, 30}};

在上面的示例中，yc 使用 'a' 初始化，yxi1 使用 10 初始化，yxi2 初始化code> 与 20、yi[0] 与 20、yi[1] 与 30< /code>和yf是值初始化的，即用0.0初始化。受保护的静态成员d根本没有初始化，因为它是static。

聚合联合的不同之处在于，您只能用大括号初始化它们的第一个成员。我认为，如果您在 C++ 方面足够先进，甚至可以考虑使用联合（它们的使用可能非常危险，必须仔细考虑），您可以自己在标准中查找联合规则:)。

现在我们知道了聚合的特殊之处，让我们尝试了解类的限制；也就是说，他们为什么在那里。我们应该理解，用大括号进行成员初始化意味着该类只不过是其成员的总和。如果存在用户定义的构造函数，则意味着用户需要做一些额外的工作来初始化成员，因此大括号初始化将不正确。如果存在虚函数，则意味着该类的对象（在大多数实现上）有一个指向该类所谓的 vtable 的指针，该指针在构造函数中设置，因此大括号初始化是不够的。您可以通过与练习类似的方式找出其余的限制:)。

关于聚合就足够了。现在我们可以定义一组更严格的类型，即 POD

什么是 POD 以及它们为何特殊

来自 C++ 标准的正式定义 (C++03 9 §4)：

POD 结构是一个聚合类
没有非静态数据成员
类型非 POD 结构、非 POD 联合（或
此类类型的数组）或引用，以及
没有用户定义的副本分配
运算符且无用户定义
析构函数。类似地，POD 联合是
没有的聚合联合
类型的非静态数据成员
非 POD 结构、非 POD 联合（或
此类类型的数组）或引用，以及
没有用户定义的副本分配
运算符且无用户定义
析构函数。 POD 类是一个类
这是一个 POD 结构或
POD-联盟。

哇，这个更难解析，不是吗？ :) 让我们把联合排除在外（基于与上面相同的理由）并以更清晰的方式重新表述：

如果满足以下条件，聚合类称为 POD：
它没有用户定义的复制分配
运算符和析构函数，并且没有一个
它的非静态成员是非 POD
类、非 POD 数组或
参考。

这个定义意味着什么？ （我有没有提到POD代表普通旧数据？）

• 所有POD类都是聚合，或者，换句话说，如果类不是聚合，那么它肯定不是 POD
• 类，就像结构一样，可以是 POD，即使这两种情况的标准术语都是 POD-struct
• 就像聚合的情况一样，静态成员是什么并不重要该类有

示例：

struct POD
{
  int x;
  char y;
  void f() {} //no harm if there's a function
  static std::vector<char> v; //static members do not matter
};

struct AggregateButNotPOD1
{
  int x;
  ~AggregateButNotPOD1() {} //user-defined destructor
};

struct AggregateButNotPOD2
{
  AggregateButNotPOD1 arrOfNonPod[3]; //array of non-POD class
};

POD 类、POD 联合、标量类型和此类类型的数组统称为POD 类型。
POD 在很多方面都很特殊。我将仅提供一些示例。

• POD 类最接近 C 结构。与它们不同的是，POD 可以具有成员函数和任意静态成员，但这两者都不会改变对象的内存布局。因此，如果您想编写一个可在 C 甚至 .NET 中使用的或多或少可移植的动态库，您应该尝试使所有导出函数仅接受和返回 POD 类型的参数。

• 非 POD 类类型的对象的生命周期从构造函数完成时开始，到析构函数开始时结束。对于 POD 类，生命周期从对象的存储空间被占用时开始，到存储空间被释放或重用时结束。

• 对于 POD 类型的对象，标准保证当您将对象的内容 memcpy 转换为 char 或 unsigned char 数组，然后 memcpy内容返回到您的对象中，该对象将保留其原始值。请注意，对于非 POD 类型的对象没有这样的保证。此外，您还可以使用 memcpy 安全地复制 POD 对象。以下示例假设 T 是 POD 类型：

   #define N sizeof(T)
   字符缓冲区[N];
   T 对象； // obj 初始化为其原始值
   memcpy(buf, &obj, N); // 在这两次对 memcpy 的调用之间，
   // obj 可能被修改
   memcpy(&obj, buf, N); // 此时，标量类型的 obj 的每个子对象
   // 保持其原始值
  

• goto 语句。您可能知道，通过 goto 从某个变量尚未在范围内的点跳转到它已在范围内的点是非法的（编译器应该发出错误）。仅当变量为非 POD 类型时，此限制才适用。在以下示例中，f() 格式错误，而 g() 格式良好。请注意，Microsoft 的编译器对此规则过于宽松 — 它只是在这两种情况下发出警告。

  <前><代码> int f()
  {
  结构 NonPOD {NonPOD() {}};
  转到标签；
  非POD x；
  标签：
  返回0；
  }

  整数 g()
  {
  结构 POD {int i;字符 c;};
  转到标签；
  PODx；
  标签：
  返回0；
  }

• 保证 POD 对象的开头不会有任何填充。换句话说，如果 POD 类 A 的第一个成员是 T 类型，您可以安全地从 A* 到 T* 进行 reinterpret_cast 并得到指向第一个成员的指针，反之亦然。

这样的例子不胜枚举……

结论

了解 POD 到底是什么非常重要，因为如您所见，许多语言功能对它们的行为有所不同。

Answer 2

C++11 有哪些变化？

聚合

聚合的标准定义略有变化，但仍然几乎相同：

聚合是一个数组或一个类（第 9 条），没有用户提供的构造函数 (12.1)，
非静态数据成员 (9.2) 没有大括号或等于初始化器，没有私有或受保护
非静态数据成员（第 11 条）、无基类（第 10 条）和无虚函数（10.3）。

好吧，什么改变了？

1. 以前，聚合不能有用户声明的构造函数，但现在它不能有用户提供的构造函数。有区别吗？是的，有，因为现在您可以声明构造函数并默认它们：

   结构聚合{
       聚合（）=默认值； // 要求编译器生成默认实现
   };
   

   这仍然是一个聚合，因为第一个声明中默认的构造函数（或任何特殊成员函数）不是用户提供的。

2. 现在，对于非静态数据成员，聚合不能有任何大括号或等于初始化器。这意味着什么？嗯，这只是因为有了这个新标准，我们可以直接在类中初始化成员，如下所示：

   struct NotAggregate {
       整数x=5； // 在 C++11 中有效
       std::vector s{1,2,3}； // 也有效
   };
   

   使用此功能使类不再是聚合，因为它基本上相当于提供您自己的默认构造函数。

所以，什么是聚合根本没有太大变化。它仍然是相同的基本思想，适应了新功能。

POD 怎么样？

POD 经历了很多变化。在这个新标准中，许多以前有关 POD 的规则都得到了放宽，并且标准中提供定义的方式也发生了根本性的改变。

POD 的想法基本上是捕获两个不同的属性：

1. 它支持静态初始化，并且
2. 在 C++ 中编译 POD 为您提供与在 C 中编译的结构相同的内存布局。

因此，定义已分为两个不同的概念：琐碎类和标准布局类，因为它们比 POD 更有用。该标准现在很少使用术语 POD，而是更喜欢更具体的“琐碎”和“标准布局”概念。

新定义基本上表明 POD 是一个既简单又具有标准布局的类，并且此属性必须递归地适用于所有非静态数据成员：

POD 结构是一个非联合类，它既是一个普通类，又是一个标准布局类，
并且没有非 POD 结构、非 POD 联合（或此类类型的数组）类型的非静态数据成员。
类似地，POD 联合是一个既是普通类又是标准布局类的联合，并且具有
没有非 POD 结构、非 POD 联合（或此类类型的数组）类型的非静态数据成员。
POD 类是一个 POD 结构体或 POD 联合体的类。

让我们分别详细讨论这两个属性。

平凡类

Trivial 是上面提到的第一个属性：平凡类支持静​​态初始化。
如果一个类是普通可复制的（普通类的超集），则可以使用诸如memcpy之类的东西将其表示形式复制到该位置，并期望结果相同。

该标准定义了一个普通类，如下所示：

普通可复制类是这样的类：

——没有重要的复制构造函数（12.8），

——没有重要的移动构造函数（12.8），

—没有重要的复制赋值运算符（13.5.3、12.8），

—没有重要的移动赋值运算符（13.5.3、12.8），并且

——有一个简单的析构函数（12.4）。

普通类是具有普通默认构造函数 (12.1) 且可普通复制的类。

[ 注意： 特别是，普通可复制或普通类没有虚函数
或虚拟基类。—尾注]

那么，这些琐碎和不琐碎的事情是什么？

如果类 X 的复制/移动构造函数不是用户提供的，并且如果它不是用户提供的，那么它是微不足道的

—类 X 没有虚函数 (10.3) 和虚基类 (10.1)，并且

- 选择复制/移动每个直接基类子对象的构造函数很简单，并且

- 对于 X 的每个类类型（或其数组）的非静态数据成员，构造函数
选择复制/移动该成员是微不足道的；

否则复制/移动构造函数就很重要。

基本上，这意味着如果不是用户提供的复制或移动构造函数是微不足道的，该类中没有任何虚拟内容，并且该属性对于该类的所有成员和基类都递归地保留。

普通复制/移动赋值运算符的定义非常相似，只需将“构造函数”一词替换为“赋值运算符”即可。

普通析构函数也有类似的定义，但附加了它不能是虚拟的约束。

对于简单的默认构造函数还存在另一个类似的规则，此外，如果类具有带有大括号或等于初始化器的非静态数据成员，那么默认构造函数就不是简单的，我们'上面已经看过了。

下面是一些示例来澄清一切：

// empty classes are trivial
struct Trivial1 {};

// all special members are implicit
struct Trivial2 {
    int x;
};

struct Trivial3 : Trivial2 { // base class is trivial
    Trivial3() = default; // not a user-provided ctor
    int y;
};

struct Trivial4 {
public:
    int a;
private: // no restrictions on access modifiers
    int b;
};

struct Trivial5 {
    Trivial1 a;
    Trivial2 b;
    Trivial3 c;
    Trivial4 d;
};

struct Trivial6 {
    Trivial2 a[23];
};

struct Trivial7 {
    Trivial6 c;
    void f(); // it's okay to have non-virtual functions
};

struct Trivial8 {
     int x;
     static NonTrivial1 y; // no restrictions on static members
};

struct Trivial9 {
     Trivial9() = default; // not user-provided
      // a regular constructor is okay because we still have default ctor
     Trivial9(int x) : x(x) {};
     int x;
};

struct NonTrivial1 : Trivial3 {
    virtual void f(); // virtual members make non-trivial ctors
};

struct NonTrivial2 {
    NonTrivial2() : z(42) {} // user-provided ctor
    int z;
};

struct NonTrivial3 {
    NonTrivial3(); // user-provided ctor
    int w;
};
NonTrivial3::NonTrivial3() = default; // defaulted but not on first declaration
                                      // still counts as user-provided
struct NonTrivial5 {
    virtual ~NonTrivial5(); // virtual destructors are not trivial
};

Standard-layout

Standard-layout 是第二个属性。标准提到这些对于与其他语言进行通信非常有用，这是因为标准布局类具有与等效 C 结构或联合相同的内存布局。

这是成员和所有基类必须递归保留的另一个属性。和往常一样，不允许使用任何虚函数或虚基类。这将使布局与 C 不兼容。

这里的一个宽松规则是标准布局类必须让所有非静态数据成员具有相同的访问控制。以前这些必须全部公开，但现在您可以将它们设为私有或受保护，只要它们全部私有或全部受保护。

使用继承时，整个继承树中只有一个类可以拥有非静态数据成员，并且第一个非静态数据成员不能是基类类型（这可能会破坏别名规则），否则，它不是标准布局类。

标准文本中的定义是这样的：

标准布局类是这样的类：

——没有非标准布局类类型的非静态数据成员（或此类类型的数组）
或参考，

—没有虚函数 (10.3) 和虚基类 (10.1)，

—对所有非静态数据成员具有相同的访问控制（第 11 条），

——没有非标准布局基类，

——要么在最底层的派生类中没有非静态数据成员，要么最多有一个基类具有
非静态数据成员，或者没有带有非静态数据成员的基类，并且

——没有与第一个非静态数据成员相同类型的基类。

标准布局结构是使用类键结构定义的标准布局类或
类键类。

标准布局联合是使用类键联合定义的标准布局类。

[ 注意： 标准布局类对于与用其他编程语言编写的代码进行通信非常有用。它们的布局在 9.2 中指定。—尾注 ]

让我们看几个例子。

// empty classes have standard-layout
struct StandardLayout1 {};

struct StandardLayout2 {
    int x;
};

struct StandardLayout3 {
private: // both are private, so it's ok
    int x;
    int y;
};

struct StandardLayout4 : StandardLayout1 {
    int x;
    int y;

    void f(); // perfectly fine to have non-virtual functions
};

struct StandardLayout5 : StandardLayout1 {
    int x;
    StandardLayout1 y; // can have members of base type if they're not the first
};

struct StandardLayout6 : StandardLayout1, StandardLayout5 {
    // can use multiple inheritance as long only
    // one class in the hierarchy has non-static data members
};

struct StandardLayout7 {
    int x;
    int y;
    StandardLayout7(int x, int y) : x(x), y(y) {} // user-provided ctors are ok
};

struct StandardLayout8 {
public:
    StandardLayout8(int x) : x(x) {} // user-provided ctors are ok
// ok to have non-static data members and other members with different access
private:
    int x;
};

struct StandardLayout9 {
    int x;
    static NonStandardLayout1 y; // no restrictions on static members
};

struct NonStandardLayout1 {
    virtual f(); // cannot have virtual functions
};

struct NonStandardLayout2 {
    NonStandardLayout1 X; // has non-standard-layout member
};

struct NonStandardLayout3 : StandardLayout1 {
    StandardLayout1 x; // first member cannot be of the same type as base
};

struct NonStandardLayout4 : StandardLayout3 {
    int z; // more than one class has non-static data members
};

struct NonStandardLayout5 : NonStandardLayout3 {}; // has a non-standard-layout base class

结论

通过这些新规则，现在更多的类型可以成为 POD。即使类型不是 POD，我们也可以单独利用 POD 的一些属性（如果它只是普通或标准布局之一）。

标准库具有在标头 中测试这些属性的特征：

template <typename T>
struct std::is_pod;
template <typename T>
struct std::is_trivial;
template <typename T>
struct std::is_trivially_copyable;
template <typename T>
struct std::is_standard_layout;

Answer 3

C++14 发生了什么变化

我们可以参考 Draft C++ 14标准供参考。

聚合

这在 8.5.1 部分中有介绍。聚合 为我们提供了以下定义：

聚合是一个数组或一个类（第 9 条），没有用户提供的
构造函数 (12.1)，没有私有或受保护的非静态数据成员
（第 11 条），无基类（第 10 条），无虚函数
（10.3）。

现在唯一的变化是添加类内成员初始值设定项不会使类成为非聚合类。因此，以下示例来自 C++11 具有成员就地初始化程序的类的聚合初始化：

struct A
{
  int a = 3;
  int b = 3;
};

不是 C 中的聚合++11 但它是 C++14 中的。 N3605：成员初始值设定项和聚合中介绍了此更改，其摘要如下：

Bjarne Stroustrup 和 Richard Smith 提出了有关聚合的问题
初始化和成员初始化器不能一起工作。这
论文建议采用史密斯提出的措辞来解决这个问题
消除了聚合不能具有的限制
成员初始化器。

POD 保持不变

POD（普通旧数据）结构的定义在 9 Classes 节中介绍，其中表示：

POD struct¹¹⁰ 是一个非联合类，它既是一个普通类，又是一个
标准布局类，并且没有 type 的非静态数据成员
非 POD 结构、非 POD 联合（或此类类型的数组）。同样，一个
POD union 是一个既是平凡类又是
标准布局类，并且没有类型的非静态数据成员
非 POD 结构、非 POD 联合（或此类类型的数组）。 POD 类是
一个类，它可以是 POD 结构体，也可以是 POD 联合体。

与 C++11 的措辞相同。

C++14 的标准布局更改

正如评论中所述，pod 依赖于 标准布局 的定义，并且 C++14 确实发生了更改，但这是通过事后应用于 C++14 的缺陷报告。

共有三个 DR：

• DR 1672
• DR 1813
• DR 2120

所以标准布局 来自 Pre C++14：

标准布局类是这样的类：

• (7.1) 没有非标准布局类类型（或此类类型的数组）或引用的非静态数据成员，
• (7.2) 没有虚函数 ([class.virtual]) 和虚基类 ([class.mi])，
• (7.3) 对所有非静态数据成员具有相同的访问控制（子句 [class.access]），
• (7.4) 没有非标准布局基类，
• (7.5) 或者在最底层的派生类中没有非静态数据成员并且最多有一个具有非静态数据成员的基类，或者有
  没有带有非静态数据成员的基类，并且
• (7.6) 没有与第一个非静态数据成员相同类型的基类。109

至 C++14 中的此内容：

如果满足以下条件，S 类就是标准布局类：

• (3.1) 没有非标准布局类类型（或此类类型的数组）或引用的非静态数据成员，
• (3.2) 没有虚函数，也没有虚基类，
• (3.3) 对所有非静态数据成员具有相同的访问控制，
• (3.4) 没有非标准布局基类，
• (3.5) 最多有一个任意给定类型的基类子对象，
• (3.6) 具有该类及其基类中的所有非静态数据成员和位字段，并且该基类首先在同一类中声明，并且
• (3.7) 没有类型集合 M(S) 的元素作为基类，其中对于任何类型 X，M(X) 定义如下。 104
  [ 注意：M(X) 是 X 中可能位于零偏移处的所有非基类子对象的类型集合。
  ——尾注
  ]
  • (3.7.1) 如果 X 是没有（可能继承的）非静态数据成员的非联合类类型，则集合 M(X) 为空。
  • (3.7.2) 如果 X 是非联合类类型，且具有 X0 类型的非静态数据成员，该成员的大小为零或者是第一个
    X 的非静态数据成员（其中所述成员可以是匿名的）
    union），集合M(X)由X0和M(X0)的元素组成。
  • (3.7.3) 如果 X 是联合类型，则集合 M(X) 是所有 M(Ui) 和包含所有 Ui 的集合的并集，其中每个 Ui 是该集合的类型
    X 的第 i 个非静态数据成员。
  • (3.7.4) 如果 X 是元素类型为 Xe 的数组类型，则集合 M(X) 由 Xe 和 M(Xe) 中的元素组成。
  • (3.7.5) 如果 X 是非类、非数组类型，则集合 M(X) 为空。

Answer 4

C++17 中的更改

下载 C++17 国际标准最终草案 此处。

聚合

C++17 扩展并增强了聚合和聚合初始化。标准库现在还包含一个 std::is_aggregate 类型特征类。以下是第 11.6.1.1 和 11.6.1.2 节的正式定义（内部参考已省略）：

聚合是一个数组或一个类
— 没有用户提供的、显式的或继承的构造函数，
— 没有私有或受保护的非静态数据成员，
— 没有虚函数，并且
— 没有虚拟、私有或受保护的基类。
[ 注意：聚合初始化不允许访问受保护和私有基类的成员或构造函数。 ——尾注]
聚合的元素是：
— 对于数组，数组元素按下标递增顺序排列，或
— 对于类，按声明顺序排列的直接基类，然后按声明顺序排列的不是匿名联合成员的直接非静态数据成员。

发生了什么变化？

1. 聚合现在可以具有公共的非虚拟基类。此外，不要求基类是聚合的。如果它们不是聚合，则它们是列表初始化的。

struct B1 // not a aggregate
{
    int i1;
    B1(int a) : i1(a) { }
};
struct B2
{
    int i2;
    B2() = default;
};
struct M // not an aggregate
{
    int m;
    M(int a) : m(a) { }
};
struct C : B1, B2
{
    int j;
    M m;
    C() = default;
};
C c { { 1 }, { 2 }, 3, { 4 } };
cout
    << "is C aggregate?: " << (std::is_aggregate<C>::value ? 'Y' : 'N')
    << " i1: " << c.i1 << " i2: " << c.i2
    << " j: " << c.j << " m.m: " << c.m.m << endl;

//stdout: is C aggregate?: Y, i1=1 i2=2 j=3 m.m=4

2. 不允许使用显式默认构造函数

struct D // not an aggregate
{
    int i = 0;
    D() = default;
    explicit D(D const&) = default;
};

3. 不允许使用继承构造函数

struct B1
{
    int i1;
    B1() : i1(0) { }
};
struct C : B1 // not an aggregate
{
    using B1::B1;
};

平凡类

平凡类的定义在 C++17 中进行了重新设计，以解决 C++14 中未解决的几个缺陷。这些变化本质上是技术性的。这是 12.0.6 的新定义（内部引用已删除）：

一个普通可复制的类是一个类：
— 其中每个复制构造函数、移动构造函数、复制赋值运算符和移动赋值运算符要么被删除，要么微不足道，
— 至少有一个未删除的复制构造函数、移动构造函数、复制赋值运算符或移动赋值运算符，并且
— 有一个简单的、未删除的析构函数。
平凡类是一种可平凡复制并具有一个或多个默认构造函数的类，所有默认构造函数都是平凡或已删除的，并且至少其中一个未删除。 [注意：特别是，一个简单可复制的
或普通类没有虚函数或虚基类。-尾注]

更改：

1. 在 C++14 下，对于平凡的类，该类不能具有任何非平凡的复制/移动构造函数/赋值运算符。然而，隐式声明为默认构造函数/运算符可能是不平凡的，但定义为删除，因为例如，该类包含一个类类型的子对象，该子对象可以不能被复制/移动。这种不平凡的、定义为删除的构造函数/运算符的存在将导致整个类变得不平凡。析构函数也存在类似的问题。 C++17 阐明，此类构造函数/运算符的存在不会导致该类不可平凡复制，因此不平凡，并且可平凡复制的类必须具有平凡的、不可删除的析构函数。 DR1734，DR1928
2. C++14 允许一个简单的可复制类，因此是一个简单的类，将每个复制/移动构造函数/赋值运算符声明为已删除。但是，如果此类也是标准布局，则可以使用 std::memcpy 合法地复制/移动它。这是一个语义矛盾，因为通过将所有构造函数/赋值运算符定义为已删除，类的创建者明确表示该类不能被复制/移动，但该类仍然满足普通可复制类的定义。因此，在 C++17 中，我们有一个新子句，声明可平凡复制的类必须至少有一个平凡的、不可删除的（尽管不一定可公开访问）复制/移动构造函数/赋值运算符。请参阅N4148，DR1734
3. 第三个技术更改涉及默认构造函数的类似问题。在 C++14 下，类可以具有隐式定义为已删除的简单默认构造函数，但仍然是一个简单类。新定义阐明，一个平凡类必须至少有一个平凡的、未删除的默认构造函数。请参阅 DR1496

标准布局类

标准布局的定义也进行了修改以解决缺陷报告。同样，这些变化本质上是技术性的。这是标准 (12.0.7) 中的文本。和以前一样，内部引用被省略：

如果满足以下条件，S 类就是标准布局类：
— 没有非标准布局类（或此类类型的数组）类型的非静态数据成员或引用，
— 没有虚函数，也没有虚基类，
— 对所有非静态数据成员具有相同的访问控制，
— 没有非标准布局基类，
— 至多有一个任意给定类型的基类子对象，
— 类及其基类中的所有非静态数据成员和位字段首先在同一个类中声明，并且
— 没有类型（定义如下）集合 M(S) 的元素作为基类。108
M(X) 定义如下：
— 如果 X 是没有（可能继承的）非静态数据成员的非联合类类型，则集合 M(X) 为空。
— 如果 X 是非联合类类型，其第一个非静态数据成员的类型为 X0（其中所述成员可以是匿名联合），则集合 M(X) 由 X0 和 M(X0) 的元素组成。< br>
— 如果 X 是联合类型，则集合 M(X) 是所有 M(Ui) 和包含所有 Ui 的集合的并集，其中每个 Ui 是 X 的第 i 个非静态数据成员的类型。
— 如果 X 是元素类型为 Xe 的数组类型，则集合 M(X) 由 Xe 和 M(Xe) 的元素组成。
— 如果 X 是非类、非数组类型，则集合 M(X) 为空。
[注：M(X) 是所有非基类子对象的类型集合，这些子对象在标准布局类中保证 X 中的偏移量为零。-尾注]
[ 示例：

struct B { int i; }; // 标准布局类
结构体 C : B { }; // 标准布局类
结构体 D : C { }; // 标准布局类
结构 E : D { 字符 : 4; }; // 不是标准布局类
结构体Q{}；
结构体 S : Q { };
结构体 T : Q { };
结构体 U : S, T { }; // 不是标准布局类

—示例结束]
108) 这可确保具有相同类类型且属于同一最派生对象的两个子对象不会分配在同一地址。

更改：

1. 澄清了派生树中只有一个类“具有”非静态数据成员的要求是指首先声明此类数据成员的类，而不是可以继承它们的类，并将这一要求扩展到非静态位字段。还澄清了标准布局类“最多有一个任何给定类型的基类子对象”。请参阅DR1813、DR1881
2. 标准布局的定义从来不允许任何基类的类型class 与第一个非静态数据成员的类型相同。这是为了避免偏移量为零的数据成员与任何基类具有相同类型的情况。 C++17 标准对“在标准布局类中保证位于零偏移量的所有非基类子对象的类型集合”提供了更严格的递归定义，以禁止此类类型不再是任何基类的类型。请参阅DR1672、DR2120。

注意： C++ 标准委员会打算将基于缺陷报告的上述更改应用于 C++14，尽管新语言并未包含在已发布的 C++14 标准中。它符合 C++17 标准。

Answer 5

C++11 中的 POD 基本上分为两个不同的轴：琐碎性和布局。琐碎性是指对象的概念值与其存储中的数据位之间的关系。布局是关于……嗯，一个对象的子对象的布局。只有类类型具有布局，而所有类型都具有琐碎关系。

因此，琐碎性轴的含义如下：

1. 非平凡可复制：此类类型的对象的值可能不仅仅是直接存储在对象内的二进制数据。

   例如，unique_ptr存储一个T*；这是对象内二进制数据的总体。但这并不是 unique_ptr 的值的全部。 unique_ptr 存储 nullptr 或指向其生命周期由 unique_ptr 实例管理的对象的指针。该管理是 unique_ptr 的值的一部分。并且该值不是对象的二进制数据的一部分；它是由该对象的各种成员函数创建的。

   例如，将 nullptr 分配给 unique_ptr 不仅仅是更改对象中存储的位。这样的赋值必须销毁由unique_ptr管理的任何对象。操作 unique_ptr 的内部存储而不通过它的成员函数会破坏这个机制，改变它的内部 T* 而不破坏它当前管理的对象，会违反对象拥有的概念价值。

2. 可简单复制：此类对象的值恰好且仅是其二进制存储的内容。这就是允许复制二进制存储等同于复制对象本身的合理性。

   定义普通可复制性（普通析构函数、普通/删除复制/移动构造函数/赋值）的特定规则是类型仅包含二进制值所需的规则。对象的析构函数可以参与定义对象的“值”，就像 unique_ptr 的情况一样。如果该析构函数很简单，那么它不会参与定义对象的值。

   专门的复制/移动操作也可以参与对象的值。 unique_ptr 的移动构造函数通过将移动操作的源清空来修改它。这可以确保 unique_ptr 的值是唯一。简单的复制/移动操作意味着不会玩这种对象值恶作剧，因此对象的值只能是它存储的二进制数据。

3. 平凡：该对象被认为对其存储的任何位都具有功能值。简单可复制将对象的数据存储的含义定义为该数据。但这些类型仍然可以控制数据如何到达那里（在某种程度上）。此类类型可以具有默认成员初始值设定项和/或默认构造函数，以确保特定成员始终具有特定值。因此，对象的概念值可以限制为它可以存储的二进制数据的子集。

   对具有简单默认构造函数的类型执行默认初始化将使该对象具有完全未初始化的值。因此，具有简单默认构造函数的类型对于其数据存储中的任何二进制数据在逻辑上都是有效的。

布局轴确实非常简单。编译器在决定类的子对象如何存储在类的存储中时有很大的余地。然而，在某些情况下，这种余地是不必要的，并且具有更严格的订购保证是有用的。

此类类型是标准布局类型。 C++ 标准甚至没有真正说明布局的具体含义。它基本上说明了有关标准布局类型的三件事：

1. 第一个子对象与对象本身位于同一地址。

2. 您可以使用 offsetof 获取从外部对象到其成员子对象之一的字节偏移量。

3. union如果活动成员（至少部分）使用与正在访问的非活动成员相同的布局，则可以通过联合体的非活动成员访问子对象来玩一些游戏。

编译器通常允许标准布局对象映射到具有与 C 中相同成员的 struct 类型。但 C++ 标准中没有对此进行说明；这正是编译器想做的事情。

在这一点上，POD 基本上是一个无用的术语。它只是简单的可复制性（值只是其二进制数据）和标准布局（其子对象的顺序更明确定义）的交集。从这些事情中我们可以推断出该类型是类似 C 的并且可以映射到类似的 C 对象。但该标准没有对此做出任何声明。

---

您能否详细说明以下规则：

我会尝试：

a) 标准布局类必须拥有具有相同访问控制的所有非静态数据成员

这很简单：所有非静态数据成员必须全部为public、私有，或受保护。您不能有一些公共和一些私有。

它们的推理完全取决于“标准布局”和“非标准布局”之间的区别。也就是说，让编译器可以自由选择如何将内容放入内存。这不仅仅是虚函数表指针的问题。

当他们在 98 年标准化 C++ 时，他们必须基本上预测人们将如何实现它。虽然他们对各种 C++ 风格拥有相当多的实现经验，但他们对事情并不确定。因此他们决定谨慎行事：给编译器尽可能多的自由。

这就是为什么C++98中POD的定义如此严格。它为 C++ 编译器提供了大多数类的成员布局方面的很大自由度。基本上，POD 类型是为了特殊情况而设计的，是出于某种原因而专门编写的。

当开发 C++11 时，他们在编译器方面拥有更多经验。他们意识到……C++ 编译器编写者真的很懒。他们拥有所有这些自由，但他们没有用它做任何事情。

标准布局的规则或多或少地编码了常见的做法：大多数编译器实际上不需要做太多改变来实现它们（除了相应类型特征的一些东西之外）。

现在，当谈到public/private时，情况就不同了。自由地重新排序哪些成员是公共的，哪些是私有的，实际上对编译器很重要，特别是在调试构建时。由于标准布局的要点是与其他语言兼容，因此您不能让调试与发布中的布局有所不同。

事实上，它并没有真正伤害用户。如果您正在创建一个封装类，那么您的所有数据成员很可能都是私有。您通常不会公开完全封装类型的公共数据成员。因此，对于那些确实想要这样做、想要进行这种划分的少数用户来说，这只会是一个问题。

所以损失并不大。

b) 整个继承树中只有一个类可以拥有非静态数据成员，

这一点的原因又回到了为什么他们再次标准化标准布局：常见做法。

在继承树中拥有两个实际存储内容的成员时，没有常见的做法。有些将基类放在派生类之前，有些则相反。如果成员来自两个基类，您将如何排序？等等。编译器在这些问题上存在很大分歧。

另外，由于零/一/无穷大规则，一旦你说你可以有两个包含成员的班级，你就可以说任意多个。这需要添加很多布局规则来处理这个问题。你必须说明多重继承是如何工作的，哪些类将它们的数据放在其他类之前，等等。这是很多规则，但获得的物质收益却很少。

您无法将没有虚函数和默认构造函数的所有内容都制作为标准布局。

并且第一个非静态数据成员不能是基类类型（这可能会破坏别名规则）。

我真的无法和这个人说话。我对 C++ 别名规则的了解还不够，无法真正理解它。但这与基成员将与基类本身共享相同的地址这一事实有关。那就是：

struct Base {};
struct Derived : Base { Base b; };

Derived d;
static_cast<Base*>(&d) == &d.b;

这可能违反 C++ 的别名规则。在某种程度上。

然而，请考虑一下：拥有执行此操作的能力实际上会有多大用处？由于只有一个类可以具有非静态数据成员，因此 Derived 必须是该类（因为它具有 Base 作为成员）。因此Base必须为空（数据）。如果Base为空，以及一个基类...为什么要有它的数据成员呢？

由于 Base 为空，因此它没有状态。因此，任何非静态成员函数都会根据其参数而不是 this 指针执行其操作。

再说一遍：没有大损失。

Answer 6

c++20< 中有哪些变化/a>

遵循这个问题的明确主题的其余部分，聚合的含义和使用随着每个标准的不同而不断变化。即将发生几个关键的变化。

具有用户声明构造函数的类型 P1008

在 C++17 中，此类型仍然是聚合：

struct X {
    X() = delete;
};

因此，X{} 仍然可以编译，因为这是聚合初始化 - 而不是构造函数调用。另请参阅：什么时候私有构造函数不是私有构造函数？

在 C++20 中，限制将从要求更改为：

没有用户提供的、显式或继承的构造函数

函数

没有用户声明或继承的构造函数

这已被采纳到 C++20 工作中草稿。这里的 X 和链接问题中的 C 都不会在 C++20 中聚合。

这也造成了溜溜球效应，如下例所示：

class A { protected: A() { }; };
struct B : A { B() = default; };
auto x = B{};

在 C++11/14 中，由于基类的原因，B 不是聚合，因此>B{} 执行值初始化，调用 B::B() 调用 A::A()，在可访问的位置。这是格式良好的。

在 C++17 中，B 成为聚合，因为允许基类，这使得 B{} 聚合初始化。这需要从 {} 复制列表初始化 A，但要从 B 上下文外部进行复制列表初始化，因为在该位置它是不可访问的。在 C++17 中，这是格式错误的（尽管 auto x = B(); 也可以）。

现在在 C++20 中，由于上述规则更改，B 再次不再是聚合（不是因为基类，而是因为用户声明的默认构造函数 - 即使它是默认）。所以我们回到 B 的构造函数，并且这个片段变得格式良好。

从带括号的值列表初始化聚合 P960

出现的一个常见问题是想要使用 emplace()具有聚合的 样式构造函数：

struct X { int a, b; };
std::vector<X> xs;
xs.emplace_back(1, 2); // error

这不起作用，因为 emplace 将尝试有效地执行初始化 X(1, 2)，这是无效的。典型的解决方案是向 X 添加一个构造函数，但通过此提议（目前正在通过 Core 进行），聚合将有效地合成了能够执行正确操作的构造函数 - 并且行为与常规构造函数类似。上面的代码将在 C++20 中按原样编译。

聚合的类模板参数推导 (CTAD) P1021 （特别是 P1816)

在 C++17 中，这无法编译：

template <typename T>
struct Point {
    T x, y;
};

Point p{1, 2}; // error

用户必须为所有聚合模板编写自己的推导指南：

template <typename T> Point(T, T) -> Point<T>;

但这在某种意义上是“显而易见的事情” “要做的事情，基本上只是样板，语言会为你做这件事。此示例将以 C++20 进行编译（无需用户提供的推导指南）。