BOOST库的使用

1. 下载Boost库 从http://www.boost.org/下载最新的boost1.330.1库。
2. 解压缩到系统的任意目录。
3. 编译BJam编译工具：

   开始->程序->Microsoft Visual Studio .NET 2003
   ->Visual Studio .NET 工具"->"Visual Studio .NET 2003 命令提示"
   然后在此环境下切换到boost_1_33_1\tools\build\jam_src目录:
   运行build编译。键入build进行bjam的编译。

4. 将bjam.exe拷贝到根目录底下，运行bjam，进行Boost库的编译如果是VC2005的话，则需要加参数bjam sTOOLS=vc-8_0

5. 将boost的源文件以及库放到IDE工具能够找到的地方，这样就完成了安装。

前不久阅读了一下 Andrei Alexandrescu的大作《Modern C++ Design》，深受启发。现写一些读后感，一个是促进自己学习，二者是希望大家交流，抛砖引玉。

说到底Policy Based Class Design是基于Templete模版的Templete组件设计技术，就是用内Templete来作为Policy为外Templete提供可配置的服务。

例如：

 template  <   class   T,Template  <   class   >     class    Policy1,Template  <   class   >   class   Policy2   >  
  class   PolicyBasedClass： public  Policy1  <  T  >  , public  Policy2  <  T  >  
    {
}  

当然Policy1也可以不依赖于模版T。同样Policy2也可以。这样也当然也可以。

 template  <   class   T,  class    Policy1, class   Policy2   >  
  class   PolicyBasedClass： public  Policy1 , public  Policy2
{
}  

当然第一个例子更加具有通用性。

这样你可以代入不同的Policy Class，来改变PolicyBasedClass的行为。

而所有的配置都是在编译阶段完成的，而不是RunTime，所以没有任何的性能损失。

有人说，我可以加个参数，对这个Class做重载，当然是可以的，而且可以获得运行时刻的灵活性，当然系统的开销相对也会大一些。

所以个人认为，PolicyBasedClass更加适合于做一些Framework的工作。例如设计一个基础的框架库，这个技术就很实用。所以Loki也是这样子的一个库。

namespace  SHFTest
... {
    template  < class  T >
     struct  OpNewCreator
     ... {
         static  T *  Create()
         ... {
             return   new  T;
        }
     protected :
         ~ OpNewCreator() ... {} ;
    } ;

    template  < class  T >
     struct  MallocCreator
     ... {
         static  T *  Create()
         ... {
            T *  buf  =  (T * )std::malloc( sizeof (T));
             if  (  ! buf )
             ... {
                 return   0 ;
            }
             return  buf;
        }
     protected :
         ~ MallocCreator() ... {} ;
    } ;

    template  < class  T >
     struct  ProtypeCreator 
     ... {
     public :
        T *  Create()
         ... {
             return   /**/ /* pPrototype_ ? pPrototype_->Clone() : */   0 ;
        }

        T *  GetPrototype()  ... {  return  pPrototype_; }

         void  SetPrototype(T *  pObj)  ... { pPrototype_  =  pObj; }
     protected :
         ~ ProtypeCreator() ... {} ;
     private :
        T *  pPrototype_;
    } ;

    template <
             class  T,
            template  < class >   class  CreatePolicy  =  OpNewCreator
             >
     class  CommonObj: public  CreatePolicy < T >
     ... {
     public :
        CommonObj()
         ... {
            CreatePolicy < T > ::Create();
        }

         ~ CommonObj() ... {}

         void  Test()
         ... {
            std::cout << " Hello World " ;
        }
     protected :
    } ;
}





int  _tmain( int  argc, _TCHAR *  argv[])
... {
    typedef SHFTest::CommonObj < int ,SHFTest::ProtypeCreator >  myProtypeObj;
    myProtypeObj Testobj1;
    Testobj1.Test();

    typedef SHFTest::CommonObj < int >  myObj;
    myObj Testobj2;
    Testobj2.Test();

     return   0 ;
}

Modern C++ Design的第一章就是Policy Based Class Design,可见该技术是整个Loki库的设计基础.这种方式的优点是能够增加程序库的弹性和提高复用性.
简单来说就是,一个Policy Based Class由很多基本的Policy来组成的,每个Policy Class代表了该复杂类(相对复杂)类的某些行为或者特性.有点类似于类的继承，当然和类的继承是不同的。
那么Policy Based Class有什么用呢？我们先看下面这个问题。
假如需要设计一个基础库，可能是基于某个特定领域的，那么库的设计者就需要考虑这样的问题，他需要将未来的可能的需求加以分类，抽象出层次，然后运用OO思想，希望能够构造出一个开发的结构，当然其中的component的设计当然是越是灵活越好。
用传统的OO设计思想，可能可以设计出一套非常完善的类库 ，可能包罗万象。当然的对于应用开发人员需要花很多时间去学习这个“包罗万象”的基础类库。而且往往这样的基础库不是通用性不强就是限制条件太多（例如MFC）可以说就是这样一种类型的库。

下面要展示一下运用多重继承以及Templetes来实现的policy class,举一个简单的例子：
假如我们需要发明一个灯，它有不同的种类，有使用不同能源的工作方式以及有不同的操作方式，如果运用

policy based class来设计的话，可能是这样的结构：

 1 templete <
 2      class  T,
 3     templete  < class >   class  Work,
 4     templete  < class >   class  OpMethod
 5 >
 6 class  Light
 7     : public  Work < T > ,
 8         OpMethod < Light >
 9
10 {
11     T *  xxOp()
12      {
13          if (Work(T).Status  ==  ACMODE)
14             OpMethod( * this );
15     }
16 }

当你实例化一个Policy Based Class的时候，你还可以给出默认的实现，就像成员函数声明和定义时候给出的默认参数一样。

回头来看一下多重继承和Templetes的特性：
多重继承：欠缺一种一成不变的可以套用的代码，在某种受控的情况下将继承的Class组合起来（多重继承只是将他们放在一起，然后提供一种访问方式）。Templetes：有这样的特性。
多重继承由于继承自多个Base Class，所以型别信息缺乏，而Templetes正式基于型别的。
多重继承容易扩张，而Templetes的特化不容易扩张。

正是两项技术的互补，才使这样的技术实现成为可能。
Light对象继承多个policy class,使得特性得以在编译期间定值，从而实现Light Class功能的扩张。
而Templetes技术使得大部分Work以及OpMethod能够共享大部分基础代码，而对特定的版本实现定值。

这样的好处就是，应用程序开发人员得以在应用设计时期，使用这些Class，选择适合自己的Policy组装自己的代码，从而使得程序大小得以精减，运行速率得以提高，而不必去包含整个又大又全的基础类库。

以上只是一些学习的心得和体会，如果有不对的地方，希望大家多多指教。