C++中的POD类型

心已赠人 2022-10-10 09:45 192阅读 0赞

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)`。

## 平凡的 ##

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

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

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

struct NoTrivial {  NoTrivial() { } };

在`NoTrivial`的定义中，构造函数就不是平凡的，这对于析构函数来讲也类似。但这样的类型声明并非“无可救药”地“非平凡化”（non-trivial）了，可以使用`=default`关键字来显式地声明缺省版本的构造函数，从而使得类型恢复“平凡化”。

1.  **拥有平凡的拷贝构造函数（trivial copy constructor）和移动构造函数（trivial move constructor）**

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

1.  **拥有平凡的拷贝赋值运算符（trivial assignment operator）和移动赋值运算符（trivial move operator）**
2.  **不能包含虚函数和虚基类**

以上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

## 标准布局 ##

1.  **所有非静态成员有相同的访问权限（public，private，protected）**

struct { 
    public:
      int m_a;
    private:
      int m_b;
    };

成员m\_a和成员m\_b拥有不同的访问权限，因此该匿名结构体不是标准布局的

1.  **在类或结构体继承时，满足下列两种情况之一：**
    
     *  派生类中有非静态成员，且只有一个仅包含静态成员的基类
     *  基类有非静态成员，而派生类中没有非静态成员

这样的类或者结构体也是标准布局的，如下：

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

1.  **类中第一个非静态成员的类型与其基类不同**

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两种类型而言，其“布局”也就是不同的了。我们可以看看所示的示意图。

![2e3348979038b63a72de783dd38e4e25.png][]

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

1.  **没有虚函数和虚基类**
2.  **所有非静态数据成员均符合标准布局类型，其基类也符合标准布局**

以上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）。

> [《深入理解C++11：C++11新特性解析与应用》][C_11_C_11]

[2e3348979038b63a72de783dd38e4e25.png]: /images/20221005/1b6bf36567264d3f8859cdd84096687b.png
[C_11_C_11]: https://weread.qq.com/web/reader/596325a059346c59642f910