C/C++教程

C++ POD类型

本文主要是介绍C++ POD类型,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录
  • 什么是POD类型?
  • 如何判断一个类型是否为平凡的类型?
  • 什么是标准布局?
  • 如何判断类型是一个标准布局的类型?
  • 参考

什么是POD类型?

POD是Plain Old Data,是C++定义的一类数据结构,如char,int,float,double等都是POD类型。Plain顾名思义,表明POD是个普通类型,Old代表是旧的,与C语言兼容,意味着可以用古老的memcpy()进行复制,memset()进行初始化等。也就是说,POD特征的类或结构体,通过二进制拷贝后,仍然能保持数据结构(内存布局)不必。

C++11中,将POD划分为2个基本概念的合集:平凡的(trivial)和标准布局的(standard layout)。
而一个POD类型,就是指平凡的类型。

先看平凡的定义,一个平凡的类或结构体应该符合以下定义:

1)拥有平凡的默认构造函数(trivial constructor)和析构函数(trivial destructor)
通常,不定义类的构造函数,编译器就会生成一个平凡的默认构造函数。而一旦定义了构造函数,即使构造函数不含参数,函数体也没有任何代码,那么该构造函数也不再是“平凡”的。

比如:

struct NoTrivial {
    NoTrivial();
};

这里NoTrivial构造函数就是非平凡的,而下面的构造函数就是平凡的,因为是编译器默认合成的。

struct NoTrivial {
    NoTrivial() = default;
};

2)拥有平凡的拷贝构造函数(trivial copy constructor)和移动构造函数(trivial move constructor)。
平凡的copy构造函数等同于用memcpy进行类型的构造。同平凡的默认构造函数一样,不声明copy构造函数的话,编译器会帮程序员自动地生成平凡的默认copy构造函数。

平凡的move构造函数与平凡的copy构造函数类似。

3)拥有平凡的拷贝赋值运算符(trivial assignment operator)和移动赋值运算符(trivial move operator)。
与平凡的copy构造函数和平凡的move构造函数类似。

4)不能包含虚函数和虚基类。
因为编译器会为包含虚函数/虚基类的类生成一个隐含的指向虚函数表的指针vptr,而要构造。

如何判断一个类型是否为平凡的类型?

除了看类和结构是否包含上面提到的4类定义,最简单方式,当然是看 类和数据结构的内置数据是否都是内置的基本类型(int、float等平凡类型),数组的元素是否为平凡类型。

C++11中,还可以通过辅助的类模板帮助判断:

template<typename T> struct std::is_trivial;

is_trivial的成员value可以用于判断T类型是否是一个平凡的类型。除了类和结构体,is_trivial也可以对内置的标量数据类型(int、float等)以及数组类型(元素类型是平凡的数组总是平凡的)进行判断。

示例:is_trivial判断指定类型是否为平凡的。

// 用支持C++11标准的编译器编译
#include <iostream>
#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() = default;
    int y;
};

struct NonTrivial3 {
    NonTrivial3();
    int w;
};

NonTrivial3::NonTrivial3() = default;

struct NonTrivial4 {
    Trivial5 c;
    virtual void f();
};

int main()
{
    cout << is_trivial<Trivial1>::value << endl;  // 1
    cout << is_trivial<Trivial2>::value << endl;  // 1
    cout << is_trivial<Trivial3>::value << endl;  // 1
    cout << is_trivial<Trivial4>::value << endl;  // 1
    cout << is_trivial<Trivial5>::value << endl;  // 1
    cout << is_trivial<NonTrivial1>::value << endl;  // 0
    cout << is_trivial<NonTrivial2>::value << endl;  // 1
    cout << is_trivial<NonTrivial3>::value << endl;  // 0
    cout << is_trivial<NonTrivial4>::value << endl;  // 0
    return 0;
}

注意:NonTrivial2和NonTrivial3的构造函数,虽然都是用的编译器生成的默认构造函数,但后者是相当于自定义了构造函数,不过用编译器生成的版本。

什么是标准布局?

POD包含另外一个概念,即标准布局。标准布局的类或结构体应该符合以下定义:
1)所有非静态成员有相同的访问权限(public,private,protected)。

// 非标准布局
struct {
public:
   int a;
private:
   int b;
};

// 标准布局
struct {
public:
    int a;
    int b;
};

2)在类或结构体继承时,满足下面两张情况之一:

  • 派生类中有非静态成员,且只有一个仅包含静态成员的基类。
  • 基类有非静态成员,而派生类没有非静态成员。
// 派生类有非静态成员d, 且只有一个仅包含静态成员的基类B1
struct B1 { static int a; };
struct D1 : B1 { int d; }; 

// 基类B2有非静态成员a, 派生类D2没有非静态成员
struct B2 { int a; };
struct D2 : B2 { static int d; }; 

struct D3 : B2, B1 { static int d; }; // D3有1个基类B1包含静态成员, 1个基类B2包含非静态成员
struct D4 : B2 { int d; }; // D4的基类B2包含非静态成员, 派生类D4也包含非静态成员
struct D5 : B2, D1 { };    // D5有2个基类B2, D1, 都包含了非静态成员, 但多重继承会导致类型布局的变化

D1, D2, D3都是标准布局的,D4, D5则不属于标准布局。实际上,非静态成员只要同时出现在派生类和基类间,就不属于标准布局。而多重继承也会导致类型布局的一些变化,所以一旦非静态成员出现在多个基类中,派生类也不属于标准布局。

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

形如:

struct A : B { B b; };

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

struct C : B { 
    int a;
    B b;
};

这里C是一个标准布局的类型。

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;
    // 7ffcdf314d00
    cout << reinterpret_cast<long long>(&d1) << endl;
    // 7ffcdf314d01
    cout << reinterpret_cast<long long>(&d1.b) << endl;
    // 7ffcdf314d04
    cout << reinterpret_cast<long long>(&d1.i) << endl;

    // 7ffcdf314d10
    cout << reinterpret_cast<long long>(&d2) << endl;
    // 7ffcdf314d10
    cout << reinterpret_cast<long long>(&d2.b) << endl;
    // 7ffcdf314d14
    cout << reinterpret_cast<long long>(&d2.i) << endl;

    return 0;
}

上面代码声明了4个类,其中2个没有成员的基类B1和B2,以及2个派生于B1的派生类D1和D2。D1,D2唯一区别是第一个非静态成员的类型。在D1中,第一个非静态成员的类型是B1,跟它的基类相同;而在D2中,第一个非静态成员的类型则是B2。

直观地看,D1和D2应该是“布局相同”的,程序员应该可以用memcpy这样的函数,在这2种类型间进行拷贝,但实际上并不是这样。

可以看到main函数中,打印出的D1类型变量d1和D2类型变量d2的地址,以及其成员的地址,是不一样的。

d1.b地址 = d1地址 +1,而d2.b地址 = d2地址。

在C++标准中,如果基类没有成员,则允许派生类的第一个成员与基类共享地址。因为派生类的地址总是“堆叠”在基类之上的,所以这样的地址共享,表明了基类没有占据任何的实际空间(节省一点数据空间)。但如果派生类第一个成员仍然是基类(如D1第一个成员B1 b),编译器仍会为该成员分配1byte空间。分配1byte空间,是因为C++标准要求类型相同的对象必须地址不同,即基类地址与派生类的成员b地址必须不同。

也就是说,在标准布局中,C++11标准强制要求派生类的第一个非静态成员的类型必须不同于基类。

下图表示代码示例中,2个基类地址与派生类地址第一个非静态成员地址关系:

可以看到D1类型对象d1中,从基类B1继承而来的数据地址跟d1相同,占1byte,跟D1自定义的B1类型对象b地址d1.b并不相同。

而在D2类型对象d2中,从基类B1继承而来的数据地址,跟D2自定义的B2类型对象b地址d2.b重叠,地址完全相同。

如何判断类型是一个标准布局的类型?

类似于用std::is_trivial判断一个类型是否为平凡的,C++11中,可以用std::is_standard_layout模板来判断类型是否是一个标准布局的类型。

例,用 std::is_standard_layout::value 打印出类型的标准布局属性。

#include <iostream>
#include <type_traits>
using namespace std;

struct SLayout1 { }; // 空类是标准布局

struct SLayout2 { // 所有非静态成员有相同访问属性, 成员类型是基本类型(不存在基类), 是标准布局
private:
    int x;
    int y;
};

struct SLayout3 : SLayout1 { // 第一个非静态成员x, 并非基类成员, 是标准布局
    int x;
    int y;
    void f();
};

struct SLayout4 : SLayout1 { // 第一个非静态成员x, 并非基类成员, 是标准布局
    int x;
    SLayout1 y;
};

struct SLayout5 : /*SLayout1,*/ SLayout3 { }; // 第一个非静态成员(不存在), 并非基类成员, 是标准布局

struct SLayout6 { static int y; }; // 没有非静态成员, 是标准布局

struct SLayout7 : SLayout6 { int x; }; // 第一个非静态成员x, 并非基类成员, 是标准布局

struct NonSLayout1 : SLayout1 { // // 第一个非静态成员x, 是基类成员, 不是标准布局
    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; // 1
    cout << is_standard_layout<SLayout2>::value << endl; // 1
    cout << is_standard_layout<SLayout3>::value << endl; // 1
    cout << is_standard_layout<SLayout4>::value << endl; // 1
    cout << is_standard_layout<SLayout5>::value << endl; // 1
    cout << is_standard_layout<SLayout6>::value << endl; // 1
    cout << is_standard_layout<SLayout7>::value << endl; // 1

    cout << is_standard_layout<NonSLayout1>::value << endl; // 0
    cout << is_standard_layout<NonSLayout2>::value << endl; // 0
    cout << is_standard_layout<NonSLayout3>::value << endl; // 0
    cout << is_standard_layout<NonSLayout4>::value << endl; // 0
    return 0;
}

参考

[1]MichaelWon, IBM XL编译器中国开发团队. 深入理解C++11:C++11新特性解析与应用[M]. 机械工业出版社, 2013.

这篇关于C++ POD类型的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!