boost.compressed_pair源碼剖析
意義
當compressed_pair的某一個模板參數為一個空類的時候將對其進行“空基類優化”，這樣可以使得compressed_pair占用的空間比std::pair的更小。
參考如下代碼：
#include <iostream>
using namespace std;
#include <boost/compressed_pair.hpp>
class A{};
class B{};
int main()
{
cout<< sizeof( std::pair< A, B > ) << endl;
cout<< sizeof( boost::compressed_pair< A, B > ) << endl;
return 0;
}
在我的機器上，VC2008 SP1輸出2和1。
std::pair參考
std::pair被實現為一個結構體，其中VC2008 SP1的pair被實現為如下：
template<class _Ty1, class _Ty2>
struct pair
{ // store a pair of values
typedef pair<_Ty1, _Ty2> _Myt;
typedef _Ty1 first_type;
typedef _Ty2 second_type;
pair()
: first(_Ty1()), second(_Ty2())
{ // construct from defaults
}
pair(const _Ty1& _Val1, const _Ty2& _Val2)
: first(_Val1), second(_Val2)
{ // construct from specified values
}
template<class _Other1,
class _Other2>
pair(const pair<_Other1, _Other2>& _Right)
: first(_Right.first), second(_Right.second)
{ // construct from compatible pair
}
// 刪除了一些不重要的代碼
_Ty1 first; // the first stored value
_Ty2 second; // the second stored value
};
通過直接訪問first和second對數據進行訪問。
boost.compressed_pair參考
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。
boost.compressed_pair剖析
boost.compressed_pair的實現依賴于boost.type_traits和boost.call_traits。boost.type_traits是boost提供的一個特征類庫，這是一個強大的庫，可以應用于很多地方。boost的大量組件都依賴于它。boost.call_traits也是一個類似于type_traits的庫，它主要提供的是一些類型調整，通過編譯器演繹我們可以在編譯時得到最好的type，它可以使我們的傳遞的參數等等相關內容總是以最恰當（根據經驗）的方式來進行調用，而且還能在新的C++標準發布之前繞過“引用的引用”問題。
接下來我將剖析支持偏特化版本的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。在文章最開始的時候我們的簡單程序發現std::pair由于直接采用組合T1、T2而無法使之成功的應用“空基類優化”，使得其占用空間的大小是2.如果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<
T,
T,
::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。
其它重點
這里將繼續探討一些有意義的技巧。
繼承
在這里我們將聚焦compressed_pair_imp的實現，其中除了第0版本和第5版本之外，其它的實現均不同程度的使用了繼承，比如第1版：
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 1>
: protected ::boost::remove_cv<T1>::type
這個版本是：
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, false, true, false>
{static const int value = 1;};
即T1和T2不同，且只有T1為空，那么它繼承去cv限定符之后的T1類型。它的意義何在呢？
參考第1版本的compressed_pair_imp的實現可以看到：
first_reference first() {return *this;}
first_const_reference first() const {return *this;}
當需求要T1的類型對象的時候，直接返回的是compressed_pair_imp對象自己，如果不繼承的話這個動作將是非法的。這就是為什么有這樣一個繼承的原因。
對于版本3：
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;}
實際上道理是一樣的。同時它還解決了構造函數中的這個問題：
compressed_pair_imp(first_param_type x, second_param_type y)
: first_type(x), second_type(y) {}
因為first_type、second_type為其基類，這樣的調用才合法。
還有一個猜想就是如果T1是內置類型的話，比如說int，那么繼承int會是合法的代碼嗎？實際上我們并不需要擔心這個，因為int不會通過::boost::is_empty測試。boost::is_empty<int>::value將得到false，因此不會被編譯器演繹到這一步。
[本文原創]相關連接：