C++11 POD类型

C++11 POD类型，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）和标准布局的（standard layout）。

我们先来看一下平凡的定义。通常情况下，一个平凡的类或结构体应该符合以下定义：

1）拥有平凡的默认构造函数（trivial constructor）和析构函数（trivial destructor）。

平凡的默认构造函数就是说构造函数“什么都不干”。通常情况下，不定义类的构造函数，编译器就会为我们生成一个平凡的默认构造函数。而一旦定义了构造函数，即使构造函数不包含参数，函数体里也没有任何的代码，那么该构造函数也不再是“平凡”的。比如：

struct NoTrivial { NoTrivial(); };

在NoTrivial的定义中，构造函数就不是平凡的，这对于析构函数来讲也类似。但这样的类型声明并非“无可救药”地“非平凡化”（non-trivial）了。

2）拥有平凡的拷贝构造函数（trivial copy constructor）和移动构造函数（trivial move constructor）。平凡的拷贝构造函数基本上等同于使用memcpy进行类型的构造。同平凡的默认构造函数一样，不声明拷贝构造函数的话，编译器会帮程序员自动地生成。同样地，可以显式地使用=default声明默认拷贝构造函数。
而平凡移动构造函数跟平凡的拷贝构造函数类似，只不过是用于移动语义。

3）拥有平凡的拷贝赋值运算符（trivial assignment operator）和移动赋值运算符（trivial move operator）。这基本上与平凡的拷贝构造函数和平凡的移动构造运算符类似。

4）不能包含虚函数以及虚基类。

以上4点虽然看似复杂，不过在C++11中，我们可以通过一些辅助的类模板来帮我们进行以上属性的判断。

template <typename T> struct std::is_trivial;

类模板is_trivial的成员value可以用于判断T的类型是否是一个平凡的类型。除了类和结构体外，is_trivial还可以对内置的标量类型数据（比如int、float都属于平凡类型）及数组类型（元素是平凡类型的数组总是平凡的）进行判断。

代码清单3-34

#include <iostream>
#include <type_traits>
using namespace std;
struct Trivial1 {};
struct Trivial2 {
public:
    int a;
private:
    int b;
};
struct Trivial3 {
    Trivial1 a;
    Trivial2 b;
};
struct Trivial4 {
    Trivial2 a[23];
};
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();
  };
  int main() {
      cout << is_trivial<Trivial1>::value << endl;     // 1
      cout << is_trivial<Trivial2>::value << endl;     // 1
      cout << is_trivial<Trivial3>::value << endl;     // 1
      cout << is_trivial<Trivial4>::value << endl;     // 1
      cout << is_trivial<Trivial5>::value << endl;     // 1
      cout << is_trivial<NonTrivial1>::value << endl; // 0
      cout << is_trivial<NonTrivial2>::value << endl; // 0
      cout << is_trivial<NonTrivial3>::value << endl; // 0
      return 0;
  }

读者可以依照代码清单3-34的输出结果核对上面提到的4种规则。

POD包含的另外一个概念是标准布局。标准布局的类或结构体应该符合以下定义：
1）所有非静态成员有相同的访问权限（public, private, protected）。
这一点非常好理解，比如：

struct {
public:
int a;
private:
    int b;
};

成员a和b就拥有不同的访问权限，因此该匿名结构体不是标准布局的。如果去掉private关键字的话，那么，该匿名结构体就符合标准布局的定义了。

struct {
public:
int a;
    int b;
};

2）在类或者结构体继承时，满足以下两种情况之一：

• 派生类中有非静态成员，且只有一个仅包含静态成员的基类。
• 基类有非静态成员，而派生类没有非静态成员。

这样的类或者结构体，也是标准布局的。比如下面的例子：

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则不属于标准布局的。这实际上使得非静态成员只要同时出现在派生类和基类间，其即不属于标准布局的。而多重继承也会导致类型布局的一些变化，所以一旦非静态成员出现在多个基类中，派生类也不属于标准布局的。
3）类中第一个非静态成员的类型与其基类不同。
这条规则非常特别，用于形如：

struct A : B{ B b; };

这样的情况。这里A类型不是一个标准布局的类型，因为第一个非静态成员变量b的类型跟A所继承的类型B相同。而形如：

struct C : B {int a; B b;};

则是一个标准布局的类型。
读者可能对这个规则感到不解，不过该规则实际上是基于C++中允许优化不包含成员的基类而产生的。我们可以看看代码清单3-35这个例子。
代码清单3-35

#include <iostream>
using namespace std;
struct B1 {};
struct B2 {};
struct D1 : B1 {
    B1 b;        // 第一个非静态变量跟基类相同
    int i;
};
struct D2 : B1 {
    B2 b;
    int i;
};
int main() {
    D1 d1;
    D2 d2;
    cout << hex;
    cout << reinterpret_cast<long long>(&d1) << endl;
  // 7ffffd945c60
    cout << reinterpret_cast<long long>(&(d1.b)) << endl;
  // 7ffffd945c61
    cout << reinterpret_cast<long long>(&(d1.i)) << endl;
  // 7ffffd945c64
    cout << reinterpret_cast<long long>(&d2) << endl;
  // 7ffffd945c50
    cout << reinterpret_cast<long long>(&(d2.b)) << endl;
  // 7ffffd945c50
    cout << reinterpret_cast<long long>(&(d2.i)) << endl;
// 7ffffd945c54
}

我们声明了4个类。其中两个没有成员的基类B1和B2，以及两个派生于B1的派生类D1和D2。D1和D2唯一的区别是第一个非静态成员的类型。在D1中，第一个非静态成员的类型是B1，这跟它的基类相同；而D2中，第一个非静态成员的类型则是B2。直观地看，D1和D2应该是“布局相同”的，程序员应该可以使用memcpy这样的函数在这两种类型间进行拷贝，但实际上却并不是这样。

我们可以看看main函数中的状况。在main中，将D1类型的变量d1以及D2类型的变量d2的地址分别打印出来。同时我们也把它们的成员的地址打印出来。可以看到，对于d2，它和它的成员共享了一个地址（本例中，实验机上的结果为7ffffd945c50），而对于d1却没有出现类似的情况。

事实上，在C++标准中，如果基类没有成员，标准允许派生类的第一个成员与基类共享地址。因为派生类的地址总是“堆叠”在基类之上的，所以这样的地址共享，表明了基类并没有占据任何的实际空间（可以节省一点数据）。但是如果基类的第一个成员仍然是基类，在我们的例子中可以看到，编译器仍然会为基类分配1字节的空间。分配为1字节空间是由于C++标准要求类型相同的对象必须地址不同（基类地址及派生类中成员d的地址必须不同），而导致的结果是，对于D1和D2两种类型而言，其“布局”也就是不同的了。我们可以看看如图所示的示意图。

所以在标准布局的解释中，C++11标准强制要求派生类的第一个非静态成员的类型必须不同于基类。

4）没有虚函数和虚基类。

5）所有非静态数据成员均符合标准布局类型，其基类也符合标准布局。这是一个递归的定义，没有什么好特别解释的。
以上5点构成了标准布局的含义，最为重要的应该是前两条。

同样，在C++11中，我们可以使用模板类来帮助判断类型是否是一个标准布局的类型。

template <typename T> struct std::is_standard_layout;

通过is_standard_layout模板类的成员value（is_standard_layout<T>::value），我们可以在代码中打印出类型的标准布局属性。那么，通过代码清单3-36所示的这个例子，我们可以加深一下对标准类型的理解。
代码清单3-36

#include <iostream>
#include <type_traits>
using namespace std;
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;
};
int main() {
cout<<is_standard_layout<SLayout1>::value << endl;   // 1
cout<<is_standard_layout<SLayout2>::value << endl;   // 1
cout<<is_standard_layout<SLayout3>::value << endl;   // 1
cout<<is_standard_layout<SLayout4>::value << endl;   // 1
cout<<is_standard_layout<SLayout5>::value << endl;   // 1
cout<<is_standard_layout<SLayout6>::value << endl;   // 1
cout<<is_standard_layout<SLayout7>::value << endl;   // 1
cout<<is_standard_layout<NonSLayout1>::value << endl;    // 0
cout<<is_standard_layout<NonSLayout2>::value << endl;    // 0
cout<<is_standard_layout<NonSLayout3>::value << endl;    // 0
cout<<is_standard_layout<NonSLayout4>::value << endl;    // 0
return 0;
}

那么，我们现在回到POD来，对于POD而言，在C++11中的定义就是平凡的和标准布局的两个方面。同样地，要判定某一类型是否是POD，标准库中的<type_traits>头文件也为程序员提供了如下模板类：

template <typename T> struct std::is_pod;

我们可以使用std::is_pod<T>::value来判定一个类型是否是POD，如代码清单3-37所示。
代码清单3-37

#include <type_traits>
#include <iostream>
using namespace std;
union U{};
union U1{ U1(){} };
enum E{};
typedef double* DA;
typedef void (*PF)(int, double);
int main() {
    cout << is_pod<U>::value << endl;    // 1
    cout << is_pod<U1>::value << endl;   // 0
    cout << is_pod<E>::value << endl;    // 1
    cout << is_pod<int>::value << endl; // 1
    cout << is_pod<DA>::value << endl;   // 1
    cout << is_pod<PF>::value << endl;   // 1
}

事实上，如我们在代码清单3-37中看到的一样，很多内置类型默认都是POD的。POD最为复杂的地方还是在类或者结构体的判断。不过通过上面平凡和标准布局的判断，相信读者对POD已经有所理解。那么，使用POD有什么好处呢？我们看得到的大概有如下3点：

1）字节赋值，代码中我们可以安全地使用memset和memcpy对POD类型进行初始化和拷贝等操作。
2）提供对C内存布局兼容。C++程序可以与C函数进行相互操作，因为POD类型的数据在C与C++间的操作总是安全的。
3）保证了静态初始化的安全有效。静态初始化在很多时候能够提高程序的性能，而POD类型的对象初始化往往更加简单（比如放入目标文件的.bss段，在初始化中直接被赋0）。

酷客教程相关文章：

• C++11 列表初始化
• C++11 显式转换操作符
• C++11 委派构造函数
• C++11 继承构造函数