C/C++编程：POD类型

╰+哭是因爲堅強的太久メ 2022-11-13 13:26 202阅读 0赞

# 概叙 #

很久之前，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有什么好处：

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

# POD的特征 #

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

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

标准布局中强调了类型的数据在排布上是简单的，比如可以通过memcpy拷贝的简单类型。而平凡的则强调了类型没有复杂的构造、析构或者多态等看起来“不平凡”的行为。

> 能平凡就平凡

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";
    }

![在这里插入图片描述][20210327100401939.png]  
例子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';
    }

![在这里插入图片描述][20210327102224390.png]

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

#include <iostream>
    #include <type_traits>
    
    struct A1 {
        
        int m1;
    };
    
    class A2 :public  A1{
        
        A1 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';
    }

![在这里插入图片描述][20210430090908550.png]

总结：标准布局必须满足如下条件

1.  所有非静态成员有相同的访问权限。
2.  在类或者结构体集成时，满足下列情况之一：
    
     *  派生类中有非静态成员，且只有一个仅包含静态成员的基类。
     *  基类有非静态成员，派生类中没有非静态成员

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

struct B1{
        static int a;}
    struct D1 : B1 {
        int d;}  // 标准布局
    
    struct B2 {
        int a;}
    struct D2 : B2 {
        static int a;} // 标准布局
    
    struct D2 : B2 , B1 {
        static int d;} // 标准布局
    struct D4 : B2{
        int  d;}  // 非标准布局
    struct D5 : B2, D1 {
        };

从上可以看出， **非静态成员只要同时出现在派生类和基类间，其即不属于标准局部**。而多重继承也会导致类型布局的一些变化，所以一旦**非静态成员出现在多个基类中，派生类也不属于标准布局**

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

也就是说，用于形如：

struct A : B{
         B b;}

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

struct C : B{
        int a; B b}

是一个标准局部的类型

这条规则是基于C++中运行优化不包含你成员的基类而产生的， 我们来看个例子：

#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 << reinterpret_cast<long long>(&d1) << "\n";
        cout << hex << reinterpret_cast<long long>(&d1.b) << "\n";
        cout << hex << reinterpret_cast<long long>(&d1.i) << "\n";
    
        cout << hex << reinterpret_cast<long long>(&d2) << "\n";
        cout << hex << reinterpret_cast<long long>(&d2.b) << "\n";
        cout << hex << reinterpret_cast<long long>(&d2.i) << "\n";
    }

上面例子中，直观的看，D1和D2应该是布局相同的，也就是说，可以用memcpy这样的函数在这两种类型间进行拷贝。实际上不是这样。我们打印出地址，观察到, 对于d2，它和它的成员共享了一个地址。而对于d1却没有出现类似的情况。

![在这里插入图片描述][20210430091641209.png]  
实际上，在C++标准中，**如果基类没有成员，标准允许派生类的第一个成员与基类共享地址**。因为派生类是“堆叠”在基类上的，所以这样的地址共享，表明了基类并没有占据任何的实际空间（可以节省一点数据）。但是如果派生类的第一个成员仍然是基类，编译器会为基类分配1字节的空间（因为C++要求类型相同的对象地址不同），从而导致D1和D2这两种类型的“布局”不同：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
所以在标准布局的解释中，C++11强制要求派生类的第一个非静态成员的类型必须不同于基类。

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

在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, 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() 等底层函数，我们来看看怎么用。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

[https://blog.csdn.net/kongkongkkk/article/details/77414410][https_blog.csdn.net_kongkongkkk_article_details_77414410]  
[https://zhuanlan.zhihu.com/p/45545035][https_zhuanlan.zhihu.com_p_45545035]  
[https://www.jianshu.com/p/191f713587cf][https_www.jianshu.com_p_191f713587cf]

[20210327100401939.png]: /images/20221022/3f1415850c164818994b3186a0220a94.png
[20210327102224390.png]: /images/20221022/5f6822ecc0884ae2829affe94c65847e.png
[20210430090908550.png]: https://img-blog.csdnimg.cn/20210430090908550.png
[20210430091641209.png]: https://img-blog.csdnimg.cn/20210430091641209.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210430093511269.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210327103402748.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_kongkongkkk_article_details_77414410]: https://blog.csdn.net/kongkongkkk/article/details/77414410
[https_zhuanlan.zhihu.com_p_45545035]: https://zhuanlan.zhihu.com/p/45545035
[https_www.jianshu.com_p_191f713587cf]: https://www.jianshu.com/p/191f713587cf