3.6　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）了，在第7章中，可以看到如何使用=default关键字来显式地声明缺省版本的构造函数，从而使得类型恢复“平凡化”。

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

而平凡移动构造函数跟平凡的拷贝构造函数类似，只不过是用于移动语义。

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

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

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

template＜typename T＞struct std::is_trivial;

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

我们可以看看代码清单3-34所示的例子。

代码清单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;

}

//编译选项:g++ -std=c++11 3-6-1.cpp

读者可以依照代码清单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

}

//编译选项:g++ -std=c++11 3-6-2.cpp

在代码清单3-35中，我们声明了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两种类型而言，其“布局”也就是不同的了。我们可以看看如图3-3所示的示意图。

图　3-3　基类地址与派生类第一个非静态成员地址关系

所以在标准布局的解释中，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;

}

//编译选项:g++ -std=c++11 3-6-3.cpp

同样地，读者可以对照我们上述的5条规则，自行分析一下代码清单3-36中的情况。

那么，我们现在回到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

}

//编译选项:g++ -std=c++11 3-6-4.cpp

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

1）字节赋值，代码中我们可以安全地使用memset和memcpy对POD类型进行初始化和拷贝等操作。

2）提供对C内存布局兼容。C++程序可以与C函数进行相互操作，因为POD类型的数据在C与C++间的操作总是安全的。

3）保证了静态初始化的安全有效。静态初始化在很多时候能够提高程序的性能，而POD类型的对象初始化往往更加简单（比如放入目标文件的.bss段，在初始化中直接被赋0）。

如我们所提到的，理解POD对理解C++11中其他概念非常重要，之后我们还会在本书中看到很多引用POD的地方。