C++中的POD类型

POD类型是英文中Plain Old Data的缩写。POD在C++中是一个非常重要的概念,通常用于说明一个类型的属性,尤其是用户自定义类型的属性。POD属性在C++11中往往又是构建其它C++概念的基础,事实上,在C++11标准中,POD出现的概率相当高。因此学习C++,尤其是在C++11中,了解POD的类型是非常必要的。

POD意如其名。Plain,表示了POD类型是个普通的类型,在C++中常见的类型都有这样的属性,而不像一些存在着虚函数虚继承的类型那么特别。而Old类型则体现了其与C的兼容性,比如可以用最老的memcpy()函数进行复制,使用memset()进行初始化等。当然,这样的描述都过于笼统,具体地,C++11将POD类型划分为两个基本概念的合集,即:平凡的(trivial)和标准布局的(standar layout)

平凡的

我们先来看一下平凡的定义。通常情况下,一个平凡的类或者结构体应该符合以下定义:

  1. 拥有平凡的默认构造函数(trivial constructor)和析构函数(trivial destructor)

平凡的默认构造函数就是说构造函数“什么都不干”。通常情况下,不定义类的构造函数,编译器就会为我们生成一个平凡的默认构造函数。而一旦定义了构造函数,即使构造函数不包含参数,函数体里也没有任何的代码,那么该构造函数也不再是“平凡”的。比如:

struct NoTrivial { NoTrivial() {} };

NoTrivial的定义中,构造函数就不是平凡的,这对于析构函数来讲也类似。但这样的类型声明并非“无可救药”地“非平凡化”(non-trivial)了,可以使用=default关键字来显式地声明缺省版本的构造函数,从而使得类型恢复“平凡化”。

  1. 拥有平凡的拷贝构造函数(trivial copy constructor)和移动构造函数(trivial move constructor)

平凡的拷贝构造函数基本上等同于使用memcpy进行类型的构造。同平凡的默认构造函数一样,不声明拷贝构造函数的话,编译器会帮程序员自动地生成。同样地,可以显式地使用=default声明默认拷贝构造函数。而平凡移动构造函数跟平凡的拷贝构造函数类似,只不过是用于移动语义。

  1. 拥有平凡的拷贝赋值运算符(trivial assignment operator)和移动赋值运算符(trivial move operator)
  2. 不能包含虚函数和虚基类

以上4点虽然看似复杂,不过在C++11中,我们可以通过一些辅助的类模板来帮我们进行以上属性的判断。

template <typename T> struct std::is_trivial;

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

struct Trivial1 {};

struct Trivial2 {
public:
  int a;
private:
  int b;
};

struct Trivial3 {
  Trivial1 a;
  Trivial2 b;
};

struct Trivial4 {
  Trivial2 a[24];
};

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();
};

void test() {
  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;
}
// 运行结果
true
true
true
true
true
false
false
false

标准布局

  1. 所有非静态成员有相同的访问权限(public,private,protected)
struct {
public:
  int m_a;
private:
  int m_b;
};

成员m_a和成员m_b拥有不同的访问权限,因此该匿名结构体不是标准布局的

  1. 在类或结构体继承时,满足下列两种情况之一:
    • 派生类中有非静态成员,且只有一个仅包含静态成员的基类
    • 基类有非静态成员,而派生类中没有非静态成员

这样的类或者结构体也是标准布局的,如下:

struct B1 { static int a; };
struct D1 : B1 { int d; };
struct B2 { int a; };
struct D2 : B2 { static int d; };
struct D3 : B2, B1 { static int d; };
struct D4 : B2 { int d; };
struct D5 : B2, D1 {};

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

  1. 类中第一个非静态成员的类型与其基类不同
struct A : B { B b; };
struct C : B { int a; B b; };

在这里,A类型不是一个标准布局的类型,而C类型是一个标准布局的类型

该规则是基于C++中允许优化不包含成员的基类而产生的。如下代码:

struct B1 {};
struct B2 {};
struct D1 : B1 {
  B1 b;
  int i;
};
struct D2 : B1 {
  B2 b;
  int i;
};

void test() {
  D1 d1;
  D2 d2;
  cout << hex;
  cout << reinterpret_cast<long long>(&d1) << endl;		// 7ffd9002a300
  cout << reinterpret_cast<long long>(&(d1.b)) << endl;	// 7ffd9002a301
  cout << reinterpret_cast<long long>(&(d1.i)) << endl;	// 7ffd9002a304
  cout << reinterpret_cast<long long>(&d2) << endl;		// 7ffd9002a310
  cout << reinterpret_cast<long long>(&(d2.b)) << endl;	// 7ffd9002a310
  cout << reinterpret_cast<long long>(&(d2.i)) << endl;	// 7ffd9002a314
  return;
}

在上面的代码中,我们声明了4个类。其中两个没有成员的基类B1和B2,以及两个派生于B1的派生类D1和D2。D1和D2唯一的区别是第一个非静态成员的类型。在D1中,第一个非静态成员的类型是B1,这跟它的基类相同;而D2中,第一个非静态成员的类型则是B2。直观地看,D1和D2应该是“布局相同”的,程序员应该可以使用memcpy这样的函数在这两种类型间进行拷贝,但实际上却并不是这样。

将D1类型的变量d1以及D2类型的变量d2的地址分别打印出来。同时我们也把它们的成员的地址打印出来。可以看到,对于d2,它和它的成员共享了一个地址,而对于d1却没有出现类似的情况。

事实上,在C++标准中,如果基类没有成员,标准允许派生类的第一个成员与基类共享地址。因为派生类的地址总是“堆叠”在基类之上的,所以这样的地址共享,表明了基类并没有占据任何的实际空间(可以节省一点数据)。但是如果基类的第一个成员仍然是基类,在我们的例子中可以看到,编译器仍然会为基类分配1字节的空间。分配为1字节空间是由于C++标准要求类型相同的对象必须地址不同(基类地址及派生类中成员d的地址必须不同),而导致的结果是,对于D1和D2两种类型而言,其“布局”也就是不同的了。我们可以看看所示的示意图。

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

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

以上5点构成了标准布局的含义,最为重要的应该是前两条。

同样,在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, SLayout3 {};
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;
};

void test() {
  cout << boolalpha;
  cout << is_standard_layout<SLayout1>::value << endl;	  // true
  cout << is_standard_layout<SLayout2>::value << endl;	  // true
  cout << is_standard_layout<SLayout3>::value << endl;	  // true
  cout << is_standard_layout<SLayout4>::value << endl;	  // true
  cout << is_standard_layout<SLayout5>::value << endl;	  // true
  cout << is_standard_layout<SLayout6>::value << endl;	  // true
  cout << is_standard_layout<SLayout7>::value << endl;	  // true
  cout << is_standard_layout<NonSLayout1>::value << endl; // false
  cout << is_standard_layout<NonSLayout2>::value << endl; // false
  cout << is_standard_layout<NonSLayout3>::value << endl; // false
  cout << is_standard_layout<NonSLayout4>::value << endl; // false
  return;
}

现在回到POD来,对于POD而言,在C++11中的定义就是平凡的和标准布局的两个方面。同样地,要判定某一类型是否是POD,标准库中的<type_traits>头文件也为程序员提供了如下模板类:

template <typename T> struct std::is_pod;
union U{};
union U1{U1(){} };
enum E{};
typedef double* DA;
typedef void(*PF)(int, double);

void test() {
  cout << is_pod<U>::value << endl;	  // true
  cout << is_pod<U1>::value << endl;  // false
  cout << is_pod<E>::value << endl;	  // true
  cout << is_pod<int>::value << endl; // true
  cout << is_pod<DA>::value << endl;  // true
  cout << is_pod<PF>::value << endl;  // true

  return;
}

可以看到,很多内置类型默认都是POD的。POD最为复杂的地方还是在类或者结构体的判断。那么,使用POD有什么好处呢?我们看得到的大概有如下3点:

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

《深入理解C++11:C++11新特性解析与应用》

  • 8
    点赞
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值