C++ POD类型

在imperfect c++里,

 

书里是这样解释POD的：

 

1、   所有标量类型(基本类型和指针类型)、POD结构类型、POD联合类型、以及这几种类型的数组、const/volatile修饰的版本都是POD类型。

 

2、  POD结构/联合类型：一个聚合体（包括class），它的非static成员都不是pointer to class member、

 

        pointer to class member function、非POD结构、非POD联合，以及这些类型的数组、引用、const/

 

        volatile修饰的版本；

 

        并且，此聚合体不能有用户自定义的构造函数、析构函数、拷贝构造函数.

 

POD结构（POD-struct）是一个聚合类，它没有以下类型的非静态数据成员：指向成员的指针、非POD结构、非POD联合（或以上类型的数组），或它们的引用，并且没有用户自定义的拷贝赋值运算符，也没有用户自定义的析构函数。 
  
类似的，POD联合（POD-union）是一个聚合联合，它没有以下类型的非静态数据成员：指向成员的指针、非POD结构、非POD联合（或以上类型的数组），或它们的引用，并且没有用户自定义的拷贝赋值运算符，也没有用户自定义的析构函数。

POD类（POD class）是一个类，它要么是POD结构，要么是POD联合。以下几种是POD:  
1、所有基本数据类型 

2、一个class或者struct，它不包含虚函数，没有虚基类，每一个数据成员都是POD，且所有的父类（如果存在的话）都是POD  
   
3、POD数组  
   
4、由POD组成的union  
POD可以包含非虚成员函数，当然也可以包含构造函数和（非虚）析构函数，因为这些东东都不影响对象布局。  
   
下面这个类，它不需要copy ctor就可以拷贝构造，但不是POD：  
struct   S  
{  
    std::string   str;    // std::string内部有指针,使用memcpy时执行浅拷贝 
}; 

C++11中对POD的定义

当class/struct是极简的(trivial)、属于标准布局(standard-layout)，以及他的所有非静态(non-static)成员都是POD时，会被视为POD。

一个极简的类别或结构符合以下定义：

1. 极简的默认建构式。这可以使用默认建构式语法，例如SomeConstructor() = default;
2. 极简的复制建构式，可使用默认语法(default syntax)
3. 极简的赋值运算子，可使用默认语法(default syntax)
4. 极简的解构式，不可以是虚拟的(virtual)

一个标准布局(standard-layout)的类别或结构符合以下定义：

1. 1. 只有非静态的(non-static)资料成员，且这些成员也是符合标准布局的型别
   2. 对所有non-static成员有相同的存取控制(public, private, protected)
   3. 没有虚拟函式
   4. 没有虚拟基础类别
   5. 只有符合标准布局的基础类别
   6. 没有和第一个定义的non-static成员相同型别的基础类别
   7. 若非没有带有non-static成员的基础类别，就是最底层(继承最末位)的类别没有non-static资料成员而且至多一个带有non-static成员的基础类别。基本上，在该类别的继承体系中只会有一个类别带有non-static成员。

2. 啥是POD类型？

   POD全称Plain Old Data。通俗的讲，一个类或结构体通过二进制拷贝后还能保持其数据不变，那么它就是一个POD类型。

   
   

   平凡的定义

   1.有平凡的构造函数

   2.有平凡的拷贝构造函数

   3.有平凡的移动构造函数

   4.有平凡的拷贝赋值运算符

   5.有平凡的移动赋值运算符

   6.有平凡的析构函数

   7.不能包含虚函数

   8.不能包含虚基类

   
   

   [cpp]  view plain  copy

    

   1. #include "stdafx.h"  
   2. #include <iostream>  
   3.   
   4. using namespace std;  
   5.   
   6. class A { A(){} };  
   7. class B { B(B&){} };  
   8. class C { C(C&&){} };  
   9. class D { D operator=(D&){} };  
   10. class E { E operator=(E&&){} };  
   11. class F { ~F(){} };  
   12. class G { virtual void foo() = 0; };  
   13. class H : G {};  
   14. class I {};  
   15.   
   16. int _tmain(int argc, _TCHAR* argv[])  
   17. {  
   18.     std::cout << std::is_trivial<A>::value << std::endl;  // 有不平凡的构造函数  
   19.     std::cout << std::is_trivial<B>::value << std::endl;  // 有不平凡的拷贝构造函数  
   20.     std::cout << std::is_trivial<C>::value << std::endl;  // 有不平凡的拷贝赋值运算符  
   21.     std::cout << std::is_trivial<D>::value << std::endl;  // 有不平凡的拷贝赋值运算符  
   22.     std::cout << std::is_trivial<E>::value << std::endl;  // 有不平凡的移动赋值运算符  
   23.     std::cout << std::is_trivial<F>::value << std::endl;  // 有不平凡的析构函数  
   24.     std::cout << std::is_trivial<G>::value << std::endl;  // 有虚函数  
   25.     std::cout << std::is_trivial<H>::value << std::endl;  // 有虚基类  
   26.   
   27.     std::cout << std::is_trivial<I>::value << std::endl;  // 平凡的类  
   28.   
   29.     system("pause");  
   30.     return 0;  
   31. }  
   
   运行结果

   
   

   

   
   

   标准布局的定义

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

   2.继承树中最多只能有一个类有非静态数据成员

   3.子类的第一个非静态成员不可以是基类类型

   4.没有虚函数

   5.没有虚基类

   6.所有非静态成员都符合标准布局类型

   
   

   [cpp]  view plain  copy

    

   1. #include "stdafx.h"  
   2. #include <iostream>  
   3.   
   4. using namespace std;  
   5.   
   6. class A   
   7. {   
   8. private:  
   9.     int a;  
   10. public:  
   11.     int b;  
   12. };  
   13.   
   14. class B1  
   15. {  
   16.     static int x1;  
   17. };  
   18.   
   19. class B2  
   20. {  
   21.     int x2;  
   22. };  
   23.   
   24. class B : B1, B2  
   25. {  
   26.     int x;  
   27. };  
   28.   
   29. class C1 {};  
   30. class C : C1  
   31. {  
   32.     C1 c;  
   33. };  
   34.   
   35. class D { virtual void foo() = 0; };  
   36. class E : D {};  
   37. class F { A x; };  
   38.   
   39. int _tmain(int argc, _TCHAR* argv[])  
   40. {  
   41.     std::cout << std::is_standard_layout<A>::value << std::endl;  // 违反定义1。成员a和b具有不同的访问权限  
   42.     std::cout << std::is_standard_layout<B>::value << std::endl;  // 违反定义2。继承树有两个(含)以上的类有非静态成员  
   43.     std::cout << std::is_standard_layout<C>::value << std::endl;  // 违反定义3。第一个非静态成员是基类类型  
   44.     std::cout << std::is_standard_layout<D>::value << std::endl;  // 违反定义4。有虚函数  
   45.     std::cout << std::is_standard_layout<E>::value << std::endl;  // 违反定义5。有虚基类  
   46.     std::cout << std::is_standard_layout<F>::value << std::endl;  // 违反定义6。非静态成员x不符合标准布局类型  
   47.   
   48.     system("pause");  
   49.     return 0;  
   50. }  
   
   运行结果

   
   

   
   

   
   

   POD的使用

   当一个数据类型满足了”平凡的定义“和”标准布局“，我们则认为它是一个POD数据。可以通过std::is_pod来判断一个类型是否为POD类型。

   如文章开头说的，一个POD类型是可以进行二进制拷贝的，看看下面的例子。

   
   

   [cpp]  view plain  copy

    

   1. #include "stdafx.h"  
   2. #include <iostream>  
   3. #include <Windows.h>  
   4.   
   5. using namespace std;  
   6.   
   7. class A   
   8. {   
   9. public:  
   10.     int x;  
   11.     double y;  
   12. };  
   13.   
   14. int _tmain(int argc, _TCHAR* argv[])  
   15. {  
   16.     if (std::is_pod<A>::value)  
   17.     {  
   18.         std::cout << "before" << std::endl;  
   19.         A a;  
   20.         a.x = 8;  
   21.         a.y = 10.5;  
   22.         std::cout << a.x << std::endl;  
   23.         std::cout << a.y << std::endl;  
   24.   
   25.         size_t size = sizeof(a);  
   26.         char *p = new char[size];  
   27.         memcpy(p, &a, size);  
   28.         A *pA = (A*)p;  
   29.   
   30.         std::cout << "after" << std::endl;  
   31.         std::cout << pA->x << std::endl;  
   32.         std::cout << pA->y << std::endl;  
   33.   
   34.         delete p;  
   35.     }  
   36.   
   37.     system("pause");  
   38.     return 0;  
   39. }  
   
   运行结果

   
   

   
   

   
   

   可以看到，对一个POD类型进行二进制拷贝后，数据都成功的迁移过来了。