c++ - 什么是聚合和POD，它们为何/为什么特别？

Question

此FAQ关于聚合和POD，涉及以下材料：


什么是骨料？
什么是POD（普通旧数据）？
它们有什么关系？
它们如何以及为什么如此特别？
C ++ 11有什么变化？

Answer 1

如何阅读：

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

此答案适用于C ++ 03。有关其他C ++标准，请参见：


C++11 changes
C++14 changes
C++17 changes


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

根据C ++标准（C ++ 03 8.5.1§1）的形式定义：


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


好了，让我们解析一下这个定义。首先，任何数组都是聚合。如果……等一下，一个类也可以是一个集合。没有关于结构或联合的任何说法，难道它们不是集合体吗？是的他们可以。在C ++中，术语class表示所有类，结构和联合。因此，当且仅当一个类（或结构或联合）满足上述定义的条件时，该类才是集合。这些标准意味着什么？


这并不意味着聚合类不能具有构造函数，实际上，它可以具有默认构造函数和/或副本构造函数，只要它们是由编译器隐式声明的，而不是由用户显式声明的
没有私有或受保护的非静态数据成员。您可以根据需要拥有任意数量的私有和受保护的成员函数（但不能具有构造函数）以及私有或受保护的静态数据成员和成员函数，并且不违反聚合类的规则
聚合类可以具有用户声明的/用户定义的副本分配运算符和/或析构函数
数组是聚合的，即使它是非聚合类类型的数组也是如此。


现在让我们看一些例子：

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
};

你明白了。现在，让我们看看聚合的特殊之处。与非聚合类不同，它们可以使用花括号 {}进行初始化。这种初始化语法是数组众所周知的，我们刚刚了解到它们是集合。因此，让我们从它们开始。

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

如果（m == n）
   数组的第i个元素用ai初始化
否则if（m   数组的前m个元素用a1，a2，…，am初始化，其他 n - m元素（如果可能）进行值初始化（有关术语的解释，请参见下文）
否则if（m> n）
   编译器将发出错误
否则（当像 int a[] = {1, 2, 3};一样根本没有指定n时就是这种情况）
 假定数组（n）的大小等于m，所以 int a[] = {1, 2, 3};等效于 int a[3] = {1, 2, 3};

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

数组初始化的示例：

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}};

在上面的示例中， double用 y.c初始化， 'a'用 y.x.i1， 10用 y.x.i2， 20用 y.i[0]， 20用 y.i[1]和 30初始化值初始化，即用 y.f初始化。受保护的静态成员 0.0根本没有初始化，因为它是 d。

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

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

关于聚集体已经足够了。现在我们可以定义一组更严格的类型，例如POD

什么是POD及其特殊性

C ++标准的正式定义（C ++ 03 9§4）：


  POD结构是一个聚合类
  没有以下非静态数据成员
  输入non-POD-struct，non-POD-union（或
  此类类型的数组）或引用，以及
  没有用户定义的副本分配
  运算符，无用户定义
  析构函数。同样，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类型的对象，由标准保证，当您将对象的内容 static放入char或未签名的char数组中，然后将 memcpy的内容返回至对象时，该对象将保留其原始值。请注意，对于非POD类型的对象没有这样的保证。另外，您可以使用 memcpy安全地复制POD对象。下面的示例假定T为POD类型：

#define N sizeof(T)
char buf[N];
T obj; // obj initialized to its original value
memcpy(buf, &obj, N); // between these two calls to memcpy,
// obj might be modified
memcpy(&obj, buf, N); // at this point, each subobject of obj of scalar type
// holds its original value

goto语句。如您所知，通过goto从尚未在某个范围内的变量跳转到已经在范围内的点是非法的（编译器应发出错误）。仅当变量为非POD类型时，此限制才适用。在以下示例中， memcpy格式错误，而 f()格式正确。请注意，Microsoft的编译器在使用此规则时过于宽松-在这两种情况下都只会发出警告。

int f()
{
  struct NonPOD {NonPOD() {}};
  goto label;
  NonPOD x;
label:
  return 0;
}

int g()
{
  struct POD {int i; char c;};
  goto label;
  POD x;
label:
  return 0;
}

确保在POD对象的开头没有填充。换句话说，如果POD类A的第一个成员是T类型，则可以从 g()到 reinterpret_cast安全地 A*并获得指向第一个成员的指针，反之亦然。


清单还在不断……

结论

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