alex

handle-body,睡死了，但還是得堅(jiān)持下。其實(shí)這個(gè)是很簡單的概念
這個(gè)也稱呼為pimpl,是private implemention的縮寫，下面涉及到的都叫做pimpl, 那用這個(gè)到底有什么好處呢：
1：可以把具體的實(shí)現(xiàn)從client端封裝，這樣即使修改實(shí)現(xiàn)，只要不修改頭文件，對client端來說，是沒有任何影響的，甚至不改變代碼的2進(jìn)制特性
2：加速編譯時(shí)間，我們知道有時(shí)頭文件有太多的實(shí)現(xiàn)，會(huì)導(dǎo)致包含這個(gè)頭文件的其他文件的編譯時(shí)間增加，通過pimpl,我們把實(shí)現(xiàn)從頭文件移到cpp里面，從而減少了其他包含這個(gè)文件的編譯時(shí)間，加快編譯速度
3：減少依賴，這個(gè)實(shí)際上也增加了編譯的速度，可以不對client端暴露一些實(shí)現(xiàn)上的頭文件，從而減少了依賴說了這么多，下面來看下一個(gè)簡單的pimpl的實(shí)現(xiàn)。是用loki的類來實(shí)現(xiàn)的。哈哈，睡死了，偷懶
/*.h*/
class CTest
{
public:
??? void Test();
private:?
????Loki::PimplT::Type m_impl;
};
------------------------------------------------------------------- /*.cpp*/
template<>
struct Loki::ImplT
{
public:
?? ?void Test() { std::cout << "test" << std::endl; }
};

void CTest::Test() { return m_impl->Test(); }
上面只是個(gè)很簡單很簡單的例子,以至于有些還無法體會(huì)到pimpl的作用，但相信在實(shí)踐中你會(huì)體會(huì)到，把原來定義在CTest里面的一些私有的方法，成員，全部挪到ImplT里面時(shí)，你會(huì)體會(huì)到，這個(gè)CTest的頭文件里include了很少的頭，他可以說完成了原始的使命，達(dá)到了功能性接口的作用，而其他原來定義在頭里的.h,可以全部挪到cpp里了。下面來分析下loki是怎么實(shí)現(xiàn)的。可以看到實(shí)現(xiàn)pimpl首先需要牽置聲明pre define類，loki通過模板的全特化來實(shí)現(xiàn)了這個(gè)的隱藏，從而避免了把具體的實(shí)現(xiàn)類暴露給client的弊端。下面來看下這個(gè)泛化的pre define: template struct ImplT; 哈哈，很簡單，再看上面我的cpp里的定義，大家結(jié)合上面也許就明白了吧，部過，這里需要注意的是，CTest的構(gòu)造函數(shù)要寫后面，不然can;t compile. 但是，為什么具體的實(shí)現(xiàn)類是ImplT但，前面的
Loki::PimplT::Type m_impl;
那Loki::PimplT::Type是什么用的，我們知道，假如保存原始的
Loki::ImplT<CTest>* m_impl;
然后new一個(gè),其實(shí)這樣只存在1個(gè)問題，2個(gè)不方便，
1：問題是這樣的原始指針，不能傳播const信息，也就是說，對象CTest轉(zhuǎn)為const的化，他里面的指針類型不是同樣隨著帶有const屬性，也就是說，假如此時(shí)指針指向的對象有個(gè)函數(shù)，提供了const＆none const的，此時(shí)，還是會(huì)調(diào)用non const的，所以，外界還是可以通過這個(gè)對象來做修改。
2：2個(gè)不方便是，你必須對對象實(shí)現(xiàn)new和delete.
下面來看下loki是怎么做的
template<class T>
struct ConstPropPtr
{
??????? explicit ConstPropPtr(T* p) : ptr_(p) {}
??????? ~ConstPropPtr() { delete? ptr_; ptr_ = 0; }
??????? T* operator->()??? { return? ptr_; }
??????? T& operator*()??? { return *ptr_; }
??????? const T* operator->() const??? { return? ptr_; }
??????? const T& operator*()? const??? { return *ptr_; }
???
private:
??????? ConstPropPtr();
??????? ConstPropPtr(const ConstPropPtr&);
??????? ConstPropPtr& operator=(const ConstPropPtr&);
??????? T* ptr_;
};

這個(gè)類提供了對問題1的解決。下面會(huì)講解，主要的點(diǎn)是，對象不同于指針，對象能傳遞const屬性。
下面看下pimlT的定義：
template<class T, template<class> class Ptr = ConstPropPtr>
struct PimplT
{
??????? typedef T Impl;

??????? // declare pimpl
??????? typedef Pimpl<ImplT<T>, Ptr<ImplT<T> > > Type;

??????? // inherit pimpl
??????? typedef PimplOwner<ImplT<T>, Ptr<ImplT<T> > > Owner;
};
可以看到對Type 的定義，下面的owner也不說了，直接到Pimpl,

template
<???
??????? class T,
??????? typename Pointer = ConstPropPtr<T>
>
class Pimpl
{
public:

??????? typedef T Impl;

??????? Pimpl() : ptr_(new T)
??????? {}

??????? ~Pimpl()
??????? {
??????????? typedef char T_must_be_defined[sizeof(T) ? 1 : -1 ];
??????? }

??????? T* operator->()
??????? {
??????????? return ptr_.operator->();
??????? }

??????? T& operator*()
??????? {
??????????? return ptr_.operator*();
??????? }

??????? const T* operator->() const
??????? {
??????????? return ptr_.operator->();
??????? }

??????? const T& operator*() const
??????? {
??????????? return ptr_.operator*();
??????? }

??????? Pointer& wrapped()
??????? {
??????????? return ptr_;
??????? }

??????? const Pointer& wrapped() const
??????? {
??????????? return ptr_;
??????? }

private:
??????? Pimpl(const Pimpl&);
??????? Pimpl& operator=(const Pimpl&);

??????? Pointer ptr_;
};

睡死了，早早結(jié)束