C++11：POD数据类型

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

啥是POD类型？

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

平凡的定义

1.有平凡的构造函数

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

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

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

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

6.有平凡的析构函数

7.不能包含虚函数

8.不能包含虚基类

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

运行结果

标准布局的定义

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

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

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

4.没有虚函数

5.没有虚基类

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

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

运行结果

POD的使用

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

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

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

运行结果

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