alex

今天来讲讲怎么编写异常安全的代码。
程序运行过程中，往往需要对一些流程加入异常处理，来提高程序的robust.比如
通过try catch来捕捉异常
try
{
    pMemory = new char[MAX_BUF_SIZE];
}
catch(std::bad_alloc& e)
{
    //error handling,er:do something resource free
}
但在程序代码段中出现大量的try catch,不仅从美观，效率和程序输写上都是不怎么好。
而另外一种对于异常的处理方法是依赖于c++的ctor/dctor的匹配来做的，就是所谓的
RAII,这个很容易让人联想到std::auto_ptr
std::auto_ptr<int> tmp(new int);
通过new分配的对象会在tmp生命结束后，释放相关的资源，通过这种方式，就能保证在程序异常，或退出时，已分配的对象能正确自动的释放拥有的资源，而在对象声明周期内，可以保证资源的有效性。
这种方式就是今天blog要写的主要内容，我们可以看到std::auto_ptr作用范围很小，只能对从堆上分配的对象进行管理，假如对文件打开句柄实行RAII,你也许会认为再写个不就是了，但这样只会造成源代码里充满了这些资源管理的类，这导致了一个严重的问题，好的结构在繁琐的流畅前面变的难堪。
那怎么样对这个进行泛化，从而能对比如从简单的指针释放，文件句柄维护，甚至相关的成员函数。我们来看下loki::socpeguard是怎么实现的：
先看下基本的用法
(1)  FILE* hFileOpen = fopen(....);
(2)  LOKI_ON_BLOCK_EXIT(flose,hFileOpen);
line2会在出LOKI_ON_BLOCK_EXIT域或程序异常结束时被调用，下面是对类成员的调用
void CTestObject::Create
{
    LOKI_ON_BLOCK_EXIT_OBJ(*this,FressResouce);
    ...
}
同上面差不多，会在这个函数结束后或异常结束后调用类成员的FreeResource.在正常流程结束后，可以通过调用Dismiss来防止对FreeResouce的调用，即类似数据库操作的commit操作。下面来分析下LOKI的实现：
从上面可以看到，RAII的是：
1：构造函数对资源的获取
2：稀构函数对资源的释放
先来看下LoKi对上面那2个宏的定义
#define LOKI_ON_BLOCK_EXIT      Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = Loki::MakeGuard

#define LOKI_ON_BLOCK_EXIT_OBJ  Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = Loki::MakeObjGuard
上面的Loki::ScopeGuard是一个基类的别名
typedef const ScopeGuardImplBase& ScopeGuard;
而LOKI_ANONYMOUS_VARIABLE(scopeGuard)用来我们产生唯一的名字，有时假如需要调用Dismiss的话，则需要自己去实现宏定义的内容，这样才能通过对象访问。Loki::MakeGuard或Loki::MakeObjGuard是用来产生对象的实际类型的，下面是一个
Loki::MakeGuard的例子：
template <typename F, typename P1>
inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
{
    return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
}
可以看到ScopeGuardImpl1<F, P1>是要产生的具体类型，MakeGuard通过函数参数的数目来重载的，而MakeGuard此处的作用是要睡死了...-_-'',作用是利用函数自动推导出参数的类型，这样就免去了指定ScopeGuardImpl1的类型的麻烦，而
ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
简单的返回对象的一个临时变量，并assign给一个上面的一个scopeguard的实例，这里依赖一个C++的特性，临时变量的声命周期和通过他初始化的引用类型的声明周期是一致的。

从上面可以看到Loki定义了一个ScopeGuardImplBase的基础类。这个类定义了一个基本的方法Dismiss,以及相关的状态。下面是loki中这个类的定义
class ScopeGuardImplBase
{
    ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
 protected:
    ~ScopeGuardImplBase()
    {}
    ScopeGuardImplBase(const ScopeGuardImplBase& other) throw()
        : dismissed_(other.dismissed_)
    {
        other.Dismiss();
    }
    template <typename J>
    static void SafeExecute(J& j) throw()
    {
        if (!j.dismissed_)
           try
           {
              j.Execute();
           }
           catch(...)
           {}
     }
       
     mutable bool dismissed_;
public:
     ScopeGuardImplBase() throw() : dismissed_(false)
     {}
     void Dismiss() const throw()
     {
         dismissed_ = true;
      }
};
可以看到类里面定义了上面所说的一些属性，其中SafeExecute用来提供子类同一的资源释放方法，并调用子类的方法来具体操作，因为相关的函数，变量都保存在具体的子类，可以看到这个函数使用了try catch，这里加这个的目的是，因为资源释放要在子类的稀构里被触发，而调用具体的方法是外面传进来的，所以无法保证一定是异常安全的，而假如在稀构里面异常的话，会导致程序的行为无法定义。
下面具体来看下一个子类的实现：
template <typename F, typename P1>
class ScopeGuardImpl1 : public ScopeGuardImplBase
{
public:
    static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
    {
        return ScopeGuardImpl1<F, P1>(fun, p1);
    }
    ~ScopeGuardImpl1() throw()
    {
        SafeExecute(*this);
    }
    void Execute()
    {
        fun_(p1_);
    }
protected:
    ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1)
    {}
    F fun_;
    const P1 p1_;
};
在LoKi里面可以看到很多类似ScopeGuardImpl1的定义，比如ScopeGuardImpl0，
ScopeGuardImpl2，可以发现最后面的数字表示具体参数的数目。
可以看到上面所说的MakeGuard的定义，以及对基类方法的调用，可以看到构造函数接收的类型，一个函数对象，和一些参数对象，并保存，对于成员函数的scopeguard,LoKi定义了1些相似的类，主要是增加了对象的引用，还有就是函数的调用方式上。
上面可以看到参数是通过值的方式来保存的而不是通过引用。而且是const属性的，下面是相关的分析。
1：通过传值的方式，从而避免了异常抛出时，可能引用的对象被稀构
2：加const属性，从而保证了在func需要参数是reference时而保存的参数确是非const时产生相应的编译错误，因为对reference传人const non-reference形式是错误的。
而对于1的方式，存在的一种问题是假如操作的fun需要传入引用，那传进去的值就无法在释放的函数中被改变，而2是对这种的一种类似契约似的编程，Loki 提供的方法是通过一个中间对象来保存操作参数的引用，并赋予这个对象自动转换功能。下面是这个类的定义：
template <class T>
class RefToValue
{  
public:
    RefToValue(T& ref) : ref_(ref)
    {}
    RefToValue(const RefToValue& rhs) : ref_(rhs.ref_)
    {}
    operator T& () const
    {
        return ref_;
    }
private:
    // Disable - not implemented
    RefToValue();
    RefToValue& operator=(const RefToValue&);
       
    T& ref_;
};
可以很清楚的看到类的实现，下面是一个工具类
template <class T>
inline RefToValue<T> ByRef(T& t)
{
     return RefToValue<T>(t);
}
下面给个具体的例子，假如
template<typename _Ty>
void SAFEDELETE(_Ty*& ptr)
{
   if (NULL != ptr)
      delete ptr;
   ptr = NULL;
}

char* ptr = new char;
 
{
    LOKI_ON_BLOCK_EXIT(SAFEDELETE<char>,Loki::ByRef(ptr));
}
 
if (NULL == ptr)
  std::cout << "NULL" << std::endl;
基本上就这么多了，sleep去了
                                                    alex_yuu

                               time - task

图中箭头指向的方向表示紧迫度的添加,那么下面是关于1,2,3,4的定义:

一:任务比较重要,但相应的时间也很紧

二:任务是长期任务,但比较重要

三:不那么重要的任务,时间也很多

四:不需要多长时间的非重要任务

现在分析下上面的这些:
对于一:往往这个时候处于时间的dead line状态,而此时往往是我们都不想要的,熟话说事情是急不来的,这个时候往往会导致质量的下降.

对于二:我们有充足的时间来做重要的任务,这正是我们想要的,但,怎么做才能使其不会过渡到区间一呢,转为区间1往往会由于人的惰性产生的,关键是要提前做事.安排好时间.

对于三:往往是一些可以辅助我们成长的事情,这些东西对我们有益处,这对全面的发展起到了很好的作用,-_-''就象我学吉他..

对于四:是些时间紧,但不重要的任务,比如要帮助人去google一些资料.

从上面可以看到,区间一实际上是最差的,但为了做好区间2,我们必须要尽量减少区间4的份量,而对于全面的发展,我们也要安排时间到区间3.这也是很重要的.

前几天一个朋友给我看了1段代码：
any temp; //any is a class
temp = 1;
temp = "a";
temp = x; //x is a abstract class
看到这段代码着实下了1跳.初期的感觉象void*指针那样，又象variant变量。但感觉还是比较新颖的，-_-''也许我是菜鸟的原因，在脑袋转了一下后，我实现了自己的一个类，用来接受任何参数，起初我认为any应该是个typedef,而接收的类型也是前面知道的(-_-''又没弄清需求就去实现了)，所以实现一个接收任何参数的类需要个typelist,和对每种类型的泛化，下面是class的定义：

template<typename _typelist>
class any
{
public:
 typedef typename Loki::TL::TypeAtNonStrict<_typelist,0>::Result param1;
 typedef typename Loki::TL::TypeAtNonStrict<_typelist,1>::Result param2;
 typedef typename Loki::TL::TypeAtNonStrict<_typelist,2>::Result param3;
 typedef typename Loki::TL::TypeAtNonStrict<_typelist,3>::Result param4;
 typedef typename Loki::TL::TypeAtNonStrict<_typelist,4>::Result param5;

 any(param1 param):
  m_param1(param){}

 any(param2 param):
  m_param2(param){}

 any(param3 param):
  m_param3(param){}

 any(param4 param):
  m_param4(param){}

 template<typename _Ty>
 const _Ty&  Get()
 {
     class CERROR_ACCESS_DENIED;
     LOKI_STATIC_CHECK((Loki::TL::IndexOf<_typelist,_Ty>::value != -     1),CERROR_ACCESS_DENIED);

     return __Access<_Ty>();
 }
private:
 template<typename _Ty>
 _Ty&  __Access();

 template<>
 param1& __Access<param1>() {return m_param1;}

 template<>
 param2& __Access<param2>() {return m_param2;}

 template<>
 param3& __Access<param3>() {return m_param3;}

 template<>
 param4& __Access<param4>() {return m_param4;}

 param1  m_param1;
 param2  m_param2;
 param3  m_param3;
 param4  m_param4;
};

typedef any<Loki::TYPE_LIST_3(int,float,char)> ANY;

abstract factory.感觉是个很玄的名字，即使在我写学习笔记的时候，我也因为缺少现实中的实践而对其了解不深。^^希望.... 多指正
Name:
   abstract factory
Addressed Problem:
   提供对同1种相关对象的创建。比如在程序里面，希望根据用户配置来设置UI方案，比如方案1和2，对应的UI也存在2套不同的实现类，比如对于ScrollBar,有CScrollBar1和CScrollBar2，都继承自ScrollBar。也许在程序里面有很多这样的类。这样你在应用UI实例化类时就必须要选择比如
IScrollBar* pScrollBar = NULL;
if (_use_ui_1)
   pScrollBar = new CScrollBar1;
else
   pScrollBar = new CScrollBar2;
也许你这样感觉没多大关系，但想象下，在程序的多处都存在这样的选择，为什么我不选择一种less error phone的方法呢？比如
pScrollBar = Create(...);
这样一种简单的方式呢？而且上面的写法也引进了1个避短，也就是在产生pScrollBar时，涉及到了具体的实现类，这在面向对象这种program to interface这样的语言中是很忌讳的事情。比如，在加种UI方案，也许你会再写个else,这样等于自己把自己往火堆里面推。你是一个勤奋的程序员，但不是个优秀的程序员^^.也许有人会说，我可以利用prototype这样的方式来啊。这样，在程序的外面配置一下每个类的prototype就可以了，或许也可以用object factory啊，都可以（^^似乎是哦，我也没学过这2个的说）解决上面的问题，一个通过DoClone类似的，1个通过ID或其他的，其实在应用上面的2种时，自然的导出了abstract factory.为什么呢，因为上面的2种，你都需要设置多个的原型或ID。比如也许在CUIManager的构造里面写贼大的if
if (_use_ui_1)
{
    ...//设置UI_1下所有的prototype
}
else
{
    ...//设置UI_2下所有的prototype
}
也许在将来的莫天，在加上UI_3,则。再写个if.也许大家可能会想，我在应用ui时，我就知道了所要创建的对象，为什么我不把上面宝装一下改成：
if (_use_ui_1)
 //设置factory_1
else
 //设置factory_2
然后在抽象出来的IFactory里面提供创建这些UI Class的方法，比如，CreateScrollBase.等等，这样就有了abstract factory 的雏形。
基础实现
/*
 测试abstract factory模式
*/

class IScrollWindow
{
public:
 virtual void DrawScroll(void) = 0;
};

class IListWindow
{
public:
 virtual void DrawList(void) = 0;
};

class ICreateWindowFactory
{
public:
 virtual IScrollWindow* CreateScrollWindow(void) = 0;

 virtual IListWindow* CreateListWindow(void) = 0;
};

class CBlueWindowFactory:
 public ICreateWindowFactory
{
 class CBlueScrollWindow:
  public IScrollWindow
 {
 public:
  virtual void DrawScroll(void)
  {
   std::cout << "draw blue scroll" << std::endl;
  }
 };

 class CBlueListWindow:
  public IListWindow
 {
 public:
  virtual void DrawList(void)
  {
   std::cout << "draw blue list" << std::endl;
  }
 };
public:
 virtual IScrollWindow* CreateScrollWindow(void)
 {
  return new CBlueScrollWindow;
 }

 virtual IListWindow* CreateListWindow(void)
 {
  return new CBlueListWindow;
 }
};

class CRedWindowFactory:
 public ICreateWindowFactory
{
 class CRedScrollWindow:
  public IScrollWindow
 {
 public:
  virtual void DrawScroll(void)
  {
   std::cout << "draw red scroll" << std::endl;
  }
 };

 class CRedListWindow:
  public IListWindow
 {
 public:
  virtual void DrawList(void)
  {
   std::cout << "draw red list" << std::endl;
  }
 };
public:
 virtual IScrollWindow* CreateScrollWindow(void)
 {
  return new CRedScrollWindow;
 }

 virtual IListWindow* CreateListWindow(void)
 {
  return new CRedListWindow;
 }
};
在需要用的地方，就可以这样：
ICreateWindowFactory* pCreateWindow1 = new CBlueWindowFactory;

 pCreateWindow1->CreateListWindow()->DrawList();
 pCreateWindow1->CreateScrollWindow()->DrawScroll();
假如需要用不同的工厂，则更换不会影响到调用处的代码。因为掉用工厂的地方是面向接口的。其实abstract factory的理念应该是比较简单的(^^瞎猜的).基本讲完了什么是抽象类工厂，他要解决的一些问题以及怎么解决和1个小而乱的demo代码段。下面来看下我们怎么泛化这个类工厂，这个会涉及到loki里面的具体实现，大家要加满油啊，因为泛化类工厂是一件不容易的事情啊。

泛化_1
首先，(^^这部分我也不是很懂)要泛化的是abstract factory的接口，就象上面的CreateScrollWindow和CreateListWindow，在泛化时需要的信息是要创建的同1组对象的相关接口比如IScrollBar,IList等等，在loki里面，要为1个类泛化1组接口，可以通过GenScatterHierarchy来将unit应用到typelist里的每1个类型，并将该类从unit<type>派生，从而得到1组接口。GenScatterHierarchy做了什么呢，他产生了啥呢？具体的可以看morden c++里面的实现。通过GenScatterHierarchy我们得到了我们要得1组接口。下面是loki里面对这个得相关实现
template <class T>
class AbstractFactoryUnit
{
public:
    virtual T* DoCreate(Type2Type<T>) = 0;
    virtual ~AbstractFactoryUnit() {}
};
可以看到，上面定义了2个函数，而这个类就是我上面说得调用GenScatterHierarchy时，具现化时对typelist得每个类型应用得template类，而最后产生得也将是类似AbstractFactoryUnit<IScrollBar>的类，我们具体的抽象工厂从这些派生。至于pure dctor这个大家应该都知道啥作用。下面来看Abstract Factory 的泛化：

template
<
    class TList,
    template <class> class Unit = AbstractFactoryUnit
>
class AbstractFactory : public GenScatterHierarchy<TList, Unit>
{
public:
     typedef TList ProductList;
       
     template <class T> T* Create()
     {
        Unit<T>& unit = *this;
        return unit.DoCreate(Type2Type<T>());
     }
 };
可以看到这个即由GenScatterHierarchy来得到了我们想要的东西。提供了Create的模板函数，使得我们可以象这样factory.Create<IScrollBar>()的方便形势来调用。ProductList是对于抽象工厂要创建的类型的重命名。方便后面在产生实际的类型时，获取对应的类型信息，对于DoCreate的参数，大家应该都明白这是重载用的，那用在哪里呢？下面会介绍。

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_;
};

睡死了，早早结束