handle-body,睡死了，但還是得堅持下。其實這個是很簡單的概念
這個也稱呼為pimpl,是private implemention的縮寫，下面涉及到的都叫做pimpl, 那用這個到底有什么好處呢：
1：可以把具體的實現從client端封裝，這樣即使修改實現，只要不修改頭文件，對client端來說，是沒有任何影響的，甚至不改變代碼的2進制特性
2：加速編譯時間，我們知道有時頭文件有太多的實現，會導致包含這個頭文件的其他文件的編譯時間增加，通過pimpl,我們把實現從頭文件移到cpp里面，從而減少了其他包含這個文件的編譯時間，加快編譯速度
3：減少依賴，這個實際上也增加了編譯的速度，可以不對client端暴露一些實現上的頭文件，從而減少了依賴說了這么多，下面來看下一個簡單的pimpl的實現。是用loki的類來實現的。哈哈，睡死了，偷懶
/*.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(); }
上面只是個很簡單很簡單的例子,以至于有些還無法體會到pimpl的作用，但相信在實踐中你會體會到，把原來定義在CTest里面的一些私有的方法，成員，全部挪到ImplT里面時，你會體會到，這個CTest的頭文件里include了很少的頭，他可以說完成了原始的使命，達到了功能性接口的作用，而其他原來定義在頭里的.h,可以全部挪到cpp里了。下面來分析下loki是怎么實現的。可以看到實現pimpl首先需要牽置聲明pre define類，loki通過模板的全特化來實現了這個的隱藏，從而避免了把具體的實現類暴露給client的弊端。下面來看下這個泛化的pre define: template struct ImplT; 哈哈，很簡單，再看上面我的cpp里的定義，大家結合上面也許就明白了吧，部過，這里需要注意的是，CTest的構造函數要寫后面，不然can;t compile. 但是，為什么具體的實現類是ImplT但，前面的
Loki::PimplT::Type m_impl;
那Loki::PimplT::Type是什么用的，我們知道，假如保存原始的
Loki::ImplT<CTest>* m_impl;
然后new一個,其實這樣只存在1個問題，2個不方便，
1：問題是這樣的原始指針，不能傳播const信息，也就是說，對象CTest轉為const的化，他里面的指針類型不是同樣隨著帶有const屬性，也就是說，假如此時指針指向的對象有個函數，提供了const＆none const的，此時，還是會調用non const的，所以，外界還是可以通過這個對象來做修改。
2：2個不方便是，你必須對對象實現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_;
};

這個類提供了對問題1的解決。下面會講解，主要的點是，對象不同于指針，對象能傳遞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_;
};

睡死了，早早結束