POD类型是英文中Plain Old Data的缩写。POD在C++中是一个非常重要的概念，通常用于说明一个类型的属性，尤其是用户自定义类型的属性。POD属性在C++11中往往又是构建其它C++概念的基础，事实上，在C++11标准中，POD出现的概率相当高。因此学习C++，尤其是在C++11中，了解POD的类型是非常必要的。
POD意如其名。Plain，表示了POD类型是个普通的类型，在C++中常见的类型都有这样的属性，而不像一些存在着虚函数虚继承的类型那么特别。而Old类型则体现了其与C的兼容性，比如可以用最老的memcpy()函数进行复制，使用memset()进行初始化等。当然，这样的描述都过于笼统，具体地，C++11将POD类型划分为两个基本概念的合集，即：平凡的(trivial)和标准布局的(standar layout)。
平凡的
我们先来看一下平凡的定义。通常情况下，一个平凡的类或者结构体应该符合以下定义：
- 拥有平凡的默认构造函数（trivial constructor）和析构函数（trivial destructor）
平凡的默认构造函数就是说构造函数“什么都不干”。通常情况下，不定义类的构造函数，编译器就会为我们生成一个平凡的默认构造函数。而一旦定义了构造函数，即使构造函数不包含参数，函数体里也没有任何的代码，那么该构造函数也不再是“平凡”的。比如：
struct NoTrivial { NoTrivial() {} };
在NoTrivial的定义中，构造函数就不是平凡的，这对于析构函数来讲也类似。但这样的类型声明并非“无可救药”地“非平凡化”（non-trivial）了，可以使用=default关键字来显式地声明缺省版本的构造函数，从而使得类型恢复“平凡化”。
- 拥有平凡的拷贝构造函数（trivial copy constructor）和移动构造函数（trivial move constructor）
平凡的拷贝构造函数基本上等同于使用memcpy进行类型的构造。同平凡的默认构造函数一样，不声明拷贝构造函数的话，编译器会帮程序员自动地生成。同样地，可以显式地使用=default声明默认拷贝构造函数。而平凡移动构造函数跟平凡的拷贝构造函数类似，只不过是用于移动语义。
- 拥有平凡的拷贝赋值运算符（trivial assignment operator）和移动赋值运算符（trivial move operator）
- 不能包含虚函数和虚基类
以上4点虽然看似复杂，不过在C++11中，我们可以通过一些辅助的类模板来帮我们进行以上属性的判断。
template <typename T> struct std::is_trivial;
类模板is_trivial的成员value可以用于判断T的类型是否是一个平凡的类型。除了类和结构体外，is_trivial还可以对内置的标量类型数据（比如int、float都属于平凡类型）及数组类型（元素是平凡类型的数组总是平凡的）进行判断。
struct Trivial1 {};
struct Trivial2 {
public:
int a;
private:
int b;
};
struct Trivial3 {
Trivial1 a;
Trivial2 b;
};
struct Trivial4 {
Trivial2 a[24];
};
struct Trivial5 {
int x;
static int y;
};
struct NonTrivial1 {
NonTrivial1() :z(42) {}
int z;
};
struct NonTrivial2 {
NonTrivial2();
int w;
};
NonTrivial2::NonTrivial2() = default;
struct NonTrivial3 {
Trivial5 c;
virtual void f();
};
void test() {
cout << is_trivial<Trivial1>::value << endl;
cout << is_trivial<Trivial2>::value << endl;
cout << is_trivial<Trivial3>::value << endl;
cout << is_trivial<Trivial4>::value << endl;
cout << is_trivial<Trivial5>::value << endl;
cout << is_trivial<NonTrivial1>::value << endl;
cout << is_trivial<NonTrivial2>::value << endl;
cout << is_trivial<NonTrivial3>::value << endl;
}
// 运行结果
true
true
true
true
true
false
false
false
标准布局
- 所有非静态成员有相同的访问权限（public，private，protected）
struct {
public:
int m_a;
private:
int m_b;
};
成员m_a和成员m_b拥有不同的访问权限，因此该匿名结构体不是标准布局的
- 在类或结构体继承时，满足下列两种情况之一：
- 派生类中有非静态成员，且只有一个仅包含静态成员的基类
- 基类有非静态成员，而派生类中没有非静态成员
这样的类或者结构体也是标准布局的，如下：
struct B1 { static int a; };
struct D1 : B1 { int d; };
struct B2 { int a; };
struct D2 : B2 { static int d; };
struct D3 : B2, B1 { static int d; };
struct D4 : B2 { int d; };
struct D5 : B2, D1 {};
D1、D2和D3都是标准布局的，而D4和D5则不属于标准布局的。这实际上使得非静态成员只要同时出现在派生类和基类间，其即不属于标准布局的。而多重继承也会导致类型布局的一些变化，所以一旦非静态成员出现在多个基类中，派生类也不属于标准布局的。
- 类中第一个非静态成员的类型与其基类不同
struct A : B { B b; };
struct C : B { int a; B b; };
在这里，A类型不是一个标准布局的类型，而C类型是一个标准布局的类型
该规则是基于C++中允许优化不包含成员的基类而产生的。如下代码：
struct B1 {};
struct B2 {};
struct D1 : B1 {
B1 b;
int i;
};
struct D2 : B1 {
B2 b;
int i;
};
void test() {
D1 d1;
D2 d2;
cout << hex;
cout << reinterpret_cast<long long>(&d1) << endl; // 7ffd9002a300
cout << reinterpret_cast<long long>(&(d1.b)) << endl; // 7ffd9002a301
cout << reinterpret_cast<long long>(&(d1.i)) << endl; // 7ffd9002a304
cout << reinterpret_cast<long long>(&d2) << endl; // 7ffd9002a310
cout << reinterpret_cast<long long>(&(d2.b)) << endl; // 7ffd9002a310
cout << reinterpret_cast<long long>(&(d2.i)) << endl; // 7ffd9002a314
return;
}
在上面的代码中，我们声明了4个类。其中两个没有成员的基类B1和B2，以及两个派生于B1的派生类D1和D2。D1和D2唯一的区别是第一个非静态成员的类型。在D1中，第一个非静态成员的类型是B1，这跟它的基类相同；而D2中，第一个非静态成员的类型则是B2。直观地看，D1和D2应该是“布局相同”的，程序员应该可以使用memcpy这样的函数在这两种类型间进行拷贝，但实际上却并不是这样。
将D1类型的变量d1以及D2类型的变量d2的地址分别打印出来。同时我们也把它们的成员的地址打印出来。可以看到，对于d2，它和它的成员共享了一个地址，而对于d1却没有出现类似的情况。
事实上，在C++标准中，如果基类没有成员，标准允许派生类的第一个成员与基类共享地址。因为派生类的地址总是“堆叠”在基类之上的，所以这样的地址共享，表明了基类并没有占据任何的实际空间（可以节省一点数据）。但是如果基类的第一个成员仍然是基类，在我们的例子中可以看到，编译器仍然会为基类分配1字节的空间。分配为1字节空间是由于C++标准要求类型相同的对象必须地址不同（基类地址及派生类中成员d的地址必须不同），而导致的结果是，对于D1和D2两种类型而言，其“布局”也就是不同的了。我们可以看看所示的示意图。
所以在标准布局的解释中，C++11标准强制要求派生类的第一个非静态成员的类型必须不同于基类。
- 没有虚函数和虚基类
- 所有非静态数据成员均符合标准布局类型，其基类也符合标准布局
以上5点构成了标准布局的含义，最为重要的应该是前两条。
同样，在C++11中，我们可以使用模板类来帮助判断类型是否是一个标准布局的类型。
template <typename T> struct std::is_standard_layout;
struct SLayout1 {};
struct SLayout2 {
private:
int x;
int y;
};
struct SLayout3 : SLayout1 {
int x;
int y;
void f();
};
struct SLayout4 : SLayout1 {
int x;
SLayout1 y;
};
struct SLayout5 : SLayout1, SLayout3 {};
struct SLayout6 { static int y; };
struct SLayout7 : SLayout6 { int x; };
struct NonSLayout1 : SLayout1 {
SLayout1 x;
int i;
};
struct NonSLayout2 : SLayout2 { int z; };
struct NonSLayout3: NonSLayout2{};
struct NonSLayout4 {
public:
int x;
private:
int y;
};
void test() {
cout << boolalpha;
cout << is_standard_layout<SLayout1>::value << endl; // true
cout << is_standard_layout<SLayout2>::value << endl; // true
cout << is_standard_layout<SLayout3>::value << endl; // true
cout << is_standard_layout<SLayout4>::value << endl; // true
cout << is_standard_layout<SLayout5>::value << endl; // true
cout << is_standard_layout<SLayout6>::value << endl; // true
cout << is_standard_layout<SLayout7>::value << endl; // true
cout << is_standard_layout<NonSLayout1>::value << endl; // false
cout << is_standard_layout<NonSLayout2>::value << endl; // false
cout << is_standard_layout<NonSLayout3>::value << endl; // false
cout << is_standard_layout<NonSLayout4>::value << endl; // false
return;
}
现在回到POD来，对于POD而言，在C++11中的定义就是平凡的和标准布局的两个方面。同样地，要判定某一类型是否是POD，标准库中的<type_traits>头文件也为程序员提供了如下模板类：
template <typename T> struct std::is_pod;
union U{};
union U1{U1(){} };
enum E{};
typedef double* DA;
typedef void(*PF)(int, double);
void test() {
cout << is_pod<U>::value << endl; // true
cout << is_pod<U1>::value << endl; // false
cout << is_pod<E>::value << endl; // true
cout << is_pod<int>::value << endl; // true
cout << is_pod<DA>::value << endl; // true
cout << is_pod<PF>::value << endl; // true
return;
}
可以看到，很多内置类型默认都是POD的。POD最为复杂的地方还是在类或者结构体的判断。那么，使用POD有什么好处呢？我们看得到的大概有如下3点：
- 字节赋值，可以安全地使用memset和memcpy对POD类型进行初始化和拷贝等操作；
- 提供对C内存布局兼容。C++程序可以与C函数进行相互操作，因为POD类型的数据在C与C++间的操作总是安全的；
- 保证了静态初始化的安全有效。静态初始化在很多时候能够提高程序的性能，而POD类型的对象初始化往往更加简单（比如放入目标文件的.bss段，在初始化中直接被赋0）。
558
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
