Boost.Compressed_pair 原理

来源：互联网发布：华为大数据认证编辑：程序博客网时间：2024/05/09 08:17

1）与std::pair不同之处在于，

boost::compressed_pair对模板参数进行评估，看其中有没有空的成员，如果有，使用空类优化技术来压缩pair的大小。

场合：常用于存放一对对象，其中之一或两个都可能是空的。

空基类：

没有非静态变量（静态成员不增加类实例的大小）

没有虚函数（虚表指针）

元函数表述：is_class<T>&&is_empty<T>

2）实现原理：编译器的空基类优化技术

1，真正实现是compressed_pair_imp

2，根据模板参数类型是否相同和两个成员是否为空定义了6个偏特化；

3，编译器元计算，决定使用哪个版本的compressed_pair_imp

偏特化的compressed_pair_imp已经知道了模板参数是否为空类，因此

它就以空类protected继承，而不是作为成员变量，这样编译器就可以使用空基类优化技术类优化类的大小

例如：T1为空时的偏特化

compressed_pair只有一个成员变量，空基类T1原本所需的至少为1的空间被编译器优化掉了。

3）Boost.Compressed_pair 源码剖析

引用的原链接：http://www.cppblog.com/db123/archive/2009/05/18/83260.html

boost.compressed_pair大概的实现如下：

class compressed_pair

{

public:

typedef T first_type;

typedef T second_type;

typedef typename call_traits<first_type>::param_type first_param_type;

typedef typename call_traits<second_type>::param_type second_param_type;

typedef typename call_traits<first_type>::reference first_reference;

typedef typename call_traits<second_type>::reference second_reference;

typedef typename call_traits<first_type>::const_reference first_const_reference;

typedef typename call_traits<second_type>::const_reference second_const_reference;

first_reference first() {return base::first();}

first_const_reference first() const {return base::first();}

second_reference second() {return base::second();}

second_const_reference second() const {return base::second();}

void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }

};

注意这不是完整的代码，它只是对其实现的一个简单描述。从中我们可以看出boost.compressed_pair使用成员函数来访问数据而不是如std::pair一样直接访问first和second。

接下来我将剖析支持偏特化版本的compressed_pair的实现，它位于boost\detail\compressed_pair.hpp。

compressed_pair_switch
这是一个开关工具，用于在后面对各种情况进行开关控制，它的基本实现如下：

template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>

struct compressed_pair_switch;

注意，它只是定义而非实现，因此我们无法构造未特化过的compressed_pair_switch。后面三个bool代表了三个概念：

l pair的两个模板参数是否是相同类型。（去掉cv限定符之后）。

l 第一个模板参数是空的吗？

l 第二个模板参数是空的吗？

因此对这三个bool进行有限组合可以得到6种组合，也就出现了接下来我们所看到的6个特化（偏特化）。

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, false, false>

{static const int value = 0;};

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, true, true>

{static const int value = 3;};

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, true, false>

{static const int value = 1;};

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, false, true>

{static const int value = 2;};

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, true, true, true>

{static const int value = 4;};

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, true, false, false>

{static const int value = 5;};

现在我们已经偏特化了6个不同的开关，它们将在最终实现compressed_pair的过程中发挥巨大的作用。注意每个类中的value，这个常量值代表了它的版本。

compressed_pair_imp
它作为最终compressed_pair的基类存在，它的声明如下：

template <class T1, class T2, int Version> class compressed_pair_imp;

注意第三个参数Version，在最终的实现中它将被以compressed_pair_switch::value来具现化。

接下来按照compressed_pair_switch的6种版本所说明的6中组合情况分别实现其对应的compressed_pair_imp。

compressed_pair_imp对应不同组合情况有不同的实现，比如说对于版本1：

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, true, false>

{static const int value = 1;};

这种情况便是指T1和T2在去cv限定符之后为不同类型，且第一种类型为空，第二种不为空，那么这时候在实现compressed_pair_imp的时候便取消了T1的数据，源码如下：

template <class T1, class T2>

class compressed_pair_imp<T1, T2, 1>

: protected ::boost::remove_cv<T1>::type

{

public:

typedef T1 first_type;

typedef T2 second_type;

typedef typename call_traits<first_type>::param_type first_param_type;

typedef typename call_traits<second_type>::param_type second_param_type;

typedef typename call_traits<first_type>::reference first_reference;

typedef typename call_traits<second_type>::reference second_reference;

typedef typename call_traits<first_type>::const_reference first_const_reference;

typedef typename call_traits<second_type>::const_reference second_const_reference;

compressed_pair_imp() {}

compressed_pair_imp(first_param_type x, second_param_type y)

: first_type(x), second_(y) {}

compressed_pair_imp(first_param_type x)

: first_type(x) {}

compressed_pair_imp(second_param_type y)

: second_(y) {}

first_reference first() {return *this;}

first_const_reference first() const {return *this;}

second_reference second() {return second_;}

second_const_reference second() const {return second_;}

private:

second_type second_;

};

现在回过头去，对于版本0：

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, false, false>

{static const int value = 0;};

由于T1和t2为不同类型，同时都不为空，因此这种情况下compressed_pair与std::pair是一样的。

对于版本2：

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, false, true>

{static const int value = 2;};

T1和T2不相同，且T1不为空，T2为空，那么这和版本1的差别就在于t2的数据成员被取消，T1的数据成员存在。

template <class T1, class T2>

class compressed_pair_imp<T1, T2, 2>

: protected ::boost::remove_cv<T2>::type

{

first_reference first() {return first_;}

first_const_reference first() const {return first_;}

second_reference second() {return *this;}

second_const_reference second() const {return *this;}

private:

first_type first_;

}; // 删除了某系无关紧要的代码

版本3：

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, false, true, true>

{static const int value = 3;};

T1和t2不相同，且两者均为空。这种时候compressd_pair_imp不再需要任何数据成员，因此其精简版的定义如下:

template <class T1, class T2>

class compressed_pair_imp<T1, T2, 3>

: protected ::boost::remove_cv<T1>::type,

protected ::boost::remove_cv<T2>::type

{

first_reference first() {return *this;}

first_const_reference first() const {return *this;}

second_reference second() {return *this;}

second_const_reference second() const {return *this;}

// no need to swap empty bases:

void swap(::boost::compressed_pair<T1,T2>&) {}

};

在这里面我们可以看到它的交换动作根本什么也没做。而且也没有数据成员，但是其占用空间大小依然是1.

版本4定义了T1和T2相同，且均为空的特殊情况：

template <class T1, class T2>

struct compressed_pair_switch<T1, T2, true, true, true>

{static const int value = 4;};

template <class T1, class T2>

class compressed_pair_imp<T1, T2, 4>

: protected ::boost::remove_cv<T1>::type

{

first_reference first() {return *this;}

first_const_reference first() const {return *this;}

second_reference second() {return m_second;}

second_const_reference second() const {return m_second;}

void swap(::boost::compressed_pair<T1,T2>&) {}

private:

T2 m_second;

};

既然T1和T2均为空，那么为何还要保存一个T2的数据呢？这是为了防止first()和second()所返回的对象的地址相同，这是很郁闷的一件事情。

版本5定义了T1和T2相同，且均不为空的情况：

template <class T1, class T2>

class compressed_pair_imp<T1, T2, 5>

{

first_reference first() {return first_;}

first_const_reference first() const {return first_;}

second_reference second() {return second_;}

second_const_reference second() const {return second_;}

void swap(::boost::compressed_pair<T1, T2>& y)

{

cp_swap(first_, y.first());

cp_swap(second_, y.second());

}

private:

first_type first_;

second_type second_;

};

这个版本并没有什么特殊之处。

compressed_pair
最终的实现通过继承compressed_pair_imp来实现，而上述的compressed_pair_imp都有一个Version模板参数，通过编译时推断出的compressed_pair_switch的数据value则可得到与其对应的基类。

template <class T1, class T2>

class compressed_pair

: private ::boost::details::compressed_pair_imp<T1, T2,

::boost::details::compressed_pair_switch<

T1,

T2,

::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,

::boost::is_empty<T1>::value,

::boost::is_empty<T2>::value>::value>

template <class T>

class compressed_pair<T, T>

: private details::compressed_pair_imp<T, T,

::boost::details::compressed_pair_switch<

::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,

::boost::is_empty<T>::value,

::boost::is_empty<T>::value>::value>

这是按照T1和T2是否相同所不同的实现。它们的区别主要在构造函数的实现上：

explicit compressed_pair(first_param_type x) : base(x) {}

explicit compressed_pair(second_param_type y) : base(y) {}

对于T1和T2相同的情况，上面的这段代码不是合法的重载。

::boost::is_same将对T1和T2去cv限定符之后的类型进行比较，结果value是一个bool值常量，对应于compressed_pair_switch第三个模板参数。::boost::is_empty可以判断类型是否是空类型，其值value也是一个bool值常量。这样便可推断出该继承哪一个版本的compressed_pair_imp。

0 0