概叙

很久之前，C语言统一了江湖，几乎所有的系统底层都是用C写的，当时定义大的基本数据类型类型有 int、char、float 等整数类型、浮点类型、枚举、void、指针、数组、结构等等。然后只要碰到一串0101011100之类的数据，编译器就可以正确的把它解析出来

C++诞生之后，出现了继承、派生这样的概念，于是就诞生了一些新的数据结构，比如派生类，但是C语言中并没有派生的概念，遇到这样的数据编译器就不认识了。可是我们的计算机世界里，主要的系统还是用 C 写的，为了和旧的C数据相兼容，C++就提出了POD数据结构到概念

• POD，是Plain Old Data的缩写，普通的旧数据类型(比如 int、float 等都是 POD 类型的。)，是C++11中的一种数据类型概念

  • Plain 代表它是一个普通类型
  • Old 代表它是旧的，与几十年前的 C 语言兼容

• POD类型可以与C编程语言中使用的类型兼容。这就意味着，POD数据类型可以使用C库函数进行操作，也可以使用std::malloc创建，可以使用std::memmove等进行复制，也可以使用C语言库（比如memcpy、API：memmove等）直接进行二进制形式的数据交换

  • 两个系统进行交换数据，如果没有办法对数据进行语义检查和解释，那么就只能以非常底层的数据形式进行交互。而拥有POD特征的类或者结构体通过二进制拷贝后一九能保持数据结构不变
  • 也就是说，能用 C 的 memcpy() 等函数进行操作的类、结构体就是 POD 类型的数据。

• 请注意，C++标准没有使用此名称定义命名的要求或者概念，这是由核心语言定义的类型类别。它被包括在这里作为概念，只是为了一致性

• 基本上谈到这个概念，一般都是说某某 class、struct、union 是不是 POD 类型的。

POD的特征

是是不是POD类型，可以用is_pod<T>::value判断。那么什么样的类、结构体是拥有POD特性的呢？要求由两个：

• 能平凡(trival)就平凡
• 布局要有序（标准布局）

能平凡就平凡

trival（平凡）是个概念，对于类或者结构体，满足以下条件即可：

• 拥有平凡的默认构造函数和析构函数
  • 平凡的构造函数和析构函数的意思是函数什么都不做。
  • 通常情况下，不定义构造函数编译期会生成一个平凡的默认构造函数。而一旦定义了构造函数，即使函数不包含参数，函数体没有代码，那么该构造函数也不再是”平凡“的。
  • 但可以通过”=default“关键字显示声明缺省版本的构造函数，使得类型”平凡化“
• 拥有平凡的拷贝构造函数和移动构造函数
  • 平凡的拷贝构造函数等同于使用memcpy进行类型的构造。同样可以使用”=default“声明默认拷贝构造函数。平凡移动构造函数和拷贝构造函数类似，用于移动语义
• 拥有平凡的拷贝赋值运算符和移动赋值运算符
• 不能包含虚函数和虚基类

换句话说，平凡的类或者结构体：

• 不能写构造/析构函数、拷贝/移动构造函数、拷贝/移动运算符(因为C语言中没有这些东西)，而是用编译器自动为我们生成，那这个数据就是“平凡的”。非要写的话，用 C++ 11 的 default 关键字。。
• 不能有虚函数和 虚基类。

C++11中可以通过类模板进行判断是不是平凡类型

template <typename T> struct std::istrivial;

我们来看两个例子：

#include <iostream>
#include <vector>

class A{
    
    
    A(){
    
    }  // 自定义的构造函数， 不是编译器默认提供的===》 不平凡，非POD类
};
class B{
    
    };
class C{
    
    
    C() = default;
};
struct D {
    
    
    virtual void foo();  //Flase
};

int main()
{
    
    
    std::cout << std::is_trivial<A>::value << "\t";
    std::cout << std::is_trivial<B>::value << "\t";
    std::cout << std::is_trivial<C>::value << "\t";
}

例子2：

#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;
    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;
    
    return 0;
}

标准布局

除了平凡之外，还对布局有要求。为了便于理解讲述，我们把非静态数据称为普通数据。

• 普通成员（即非静态数据）拥有相同的访问级别。例如下面的类，因为 a 和 b 的访问级别不一样，所以布局无序，自然就不是 POD 类型的数据。当然，如果 b 写成 static int b，例子中的 A 类就是 POD 类型的了。所以一定要看清每个字，是“普通成员”哦。

struct A {
    
      //访问级别不一样，所以不是POD类型
    int m1;
private:
    int m2;
};

• 只要有父类，普通成员只能在其中一个类中，不可分散。 因为 C 没有继承的概念，所以就别把普通成员在两个类中都写，写在一个类中就像 C 的风格了。如下图的代码，从 A 的角度看上边没有父类，就按上文的规则去判断是否是 POD 类型。从 A1 的角度看上边有个父类，这个时候就要看父子两个是否都有普通成员了，都有的话肯定不行，只能其中一个有。

在C++11中，也可以用模板类来判断类型是否是一个标准布局的类型

template <typename T> struct std::is_standard_layout;

#include <iostream>
#include <type_traits>

struct A {
    
    
    int m1;
};

class A1 :public  A{
    
    
    int a1; // flase：类不能分散
};


int main()
{
    
    
    std::cout << std::boolalpha;
    std::cout << std::is_pod<A>::value << '\n';
    std::cout << std::is_pod<A1>::value << '\n';
}

• 第一个成员必须是自己的？？？？？

#include <iostream>
#include <type_traits>

struct A1 {
    
    
    int m1;
};

class A2 :public  A{
    
    
    A a;   // 第一个必须是A1的数据成员
    int a1;  
};



int main()
{
    
    
    std::cout << std::boolalpha;
    std::cout << std::is_pod<A1>::value << '\n';
    std::cout << std::is_pod<A2>::value << '\n';

}

总结：对于标准布局。如何使用 POD 类型的数据？

1. 所有非静态成员有相同的访问权限。

2. 在类或者结构体集成时，满足下列情况之一：

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

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

3. 类中第一个非静态成员的类型与其基类不同。
4. 没有虚函数和虚基类
5. 所有非静态数据成员均符合标准布局类型，其基类也符合标准布局

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, SLayout2 {
    
    };

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;
    cout << is_standard_layout<SLayout2>::value << endl;
    cout << is_standard_layout<SLayout3>::value << endl;
    cout << is_standard_layout<SLayout4>::value << endl;
    cout << is_standard_layout<SLayout5>::value << endl;
    cout << is_standard_layout<SLayout6>::value << endl;
    cout << is_standard_layout<SLayout7>::value << endl;
    cout << is_standard_layout<NonSLayout1>::value << endl;
    cout << is_standard_layout<NonSLayout2>::value << endl;
    cout << is_standard_layout<NonSLayout3>::value << endl;
    cout << is_standard_layout<NonSLayout4>::value << endl;
    return 0;
}

如何使用 POD 类型的数据？

具有 POD 性质的数据可以使用 C 语言中的 memcpy() 等底层函数，我们来看看怎么用。

https://blog.csdn.net/kongkongkkk/article/details/77414410
https://zhuanlan.zhihu.com/p/45545035
https://www.jianshu.com/p/191f713587cf