如何阅读：
本文相当长。如果您想了解聚合和POD（普通旧数据），请花些时间阅读。如果您仅对聚合感兴趣，则仅阅读第一部分。如果你只在荚感兴趣，那么你必须首先阅读的定义，内涵和聚集的例子，那么你就可以跳转到荚，但我还是希望推荐阅读全部的第一部分。聚合的概念对于定义POD至关重要。如果您发现任何错误（即使是次要错误，包括语法，文体，格式，语法等），请留下评论，我会进行编辑。
此答案适用于C ++ 03。有关其他C ++标准，请参见：
什么是集合体以及为什么它们很特殊
来自C ++标准（C ++ 03 8.5.1§1）的形式定义：
集合是没有用户声明的构造函数（12.1），没有私有或受保护的非静态数据成员（第11章），没有基类（第10章）以及没有虚函数（10.3）的数组或类（第9节） ）。
好了，让我们解析一下这个定义。首先，任何数组都是聚合。如果……等一下，一个类也可以是一个集合。没有关于结构或联合的任何说法，难道它们不是集合体吗？是的他们可以。在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个阵列的元件与初始化我
否则如果（M <N）
的数组的第m个元素与一个初始化 1，一个 2，...，A米，而另一n - m元件是，如果可能的话，值初始化（见下文的术语的解释）
否则如果（M> N）
，编译器将发出错误
否则 （是这种情况，当n在所有像未指定int a[] = {1, 2, 3};）
的大小假设数组（n）等于m，所以int a[] = {1, 2, 3};等价于int a[3] = {1, 2, 3};
当标量类型（的目的bool，int，char，double，指针等）是值初始化这意味着它是与初始化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}};
在上述示例中y.c被初始化'a'，y.x.i1与10，y.x.i2与20，y.i[0]与20，y.i[1]与30和y.f为值初始化，即，与初始化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类型的对象没有这样的保证。另外，您可以使用来安全地复制POD对象memcpy。下面的示例假定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类型时，此限制才适用。在以下示例中，格式错误，f()而g()格式正确。请注意，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类型，则可以安全地reinterpret_cast从A*获取T*并获得指向第一个成员的指针，反之亦然。
清单还在不断……
结论
重要的是要了解POD到底是什么，因为如您所见，许多语言功能对其行为有所不同。