久久综合视频网站,午夜肉伦伦影院久久精品免费看国产一区二区三区,久久精品国产69国产精品亚洲

�~�写异常安全的代�?loki::scopeguard)

agerlis — Sun, 11 Feb 2007 07:55:00 GMT

今天来讲讲怎么�~�写异常安全的代码�?br />�E�序�q�行�q�程中，往往需要对一些流�E�加入异常处理，来提高程序的robust.比如
通过try catch来捕捉异�?br />try
{
    pMemory = new char[MAX_BUF_SIZE];
}
catch(std::bad_alloc& e)
{
    //error handling,er:do something resource free
}
但在�E�序代码�D�中出现大量的try catch,不仅从美观，效率和程序输写上都是不怎么好�?br />而另外一�U�对于异常的处理�Ҏ��是依赖于c++的ctor/dctor的匹配来做的�Q�就是所谓的
RAII,�q�个很容易让��惛_��std::auto_ptr
std::auto_ptr tmp(new int);
通过new分配的对象会在tmp生命�l�束后，释放相关的资源，通过�q�种方式�Q�就能保证在�E�序异常�Q�或退出时�Q�已分配的对象能正确自动的释放拥有的资源�Q�而在对象声明周期内，可以保证资源的有效性�?br />�q�种方式��是今天blog要写的主要内容，我们可以看到std::auto_ptr作用范围很小�Q�只能对从堆上分配的对象�q�行��理�Q�假如对文�g打开句柄实行RAII,你也�怼�认�ؓ再写个不��是了，但这样只会造成源代码里充满了这些资源管理的�c�，�q�导致了一个严重的问题�Q�好的结构在�J�琐的流畅前面变的难堪�?br />那怎么样对�q�个�q�行泛化�Q�从而能�Ҏ��如从��单的指针释放�Q�文件句柄维护，甚至相关的成员函数。我们来看下loki::socpeguard是怎么实现的：
先看下基本的用法
(1) FILE* hFileOpen = fopen(....);
(2) LOKI_ON_BLOCK_EXIT(flose,hFileOpen);
line2会在出LOKI_ON_BLOCK_EXIT域或�E�序异常�l�束时被调用�Q�下面是对类成员的调�?br />void CTestObject::Create
{
    LOKI_ON_BLOCK_EXIT_OBJ(*this,FressResouce);
    ...
}
同上面差不多�Q�会在这个函数结束后或异常结束后调用�c�L��员的FreeResource.在正常流�E�结束后�Q�可以通过调用Dismiss来防止对FreeResouce的调用，即类似数据库操作的commit操作。下面来分析下LOKI的实玎ͼ�
从上面可以看刎ͼ�RAII的是�Q?br />1�Q�构造函数对资源的获�?br />2�Q�稀构函数对资源的释�?br />先来看下LoKi对上面那2个宏的定�?br />#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是一个基�cȝ��别名
typedef const ScopeGuardImplBase& ScopeGuard;
而LOKI_ANONYMOUS_VARIABLE(scopeGuard)用来我们产生唯一的名字，有时假如需要调用Dismiss的话�Q�则需要自己去实现宏定义的内容�Q�这��h��能通过对象讉K��。Loki::MakeGuard或Loki::MakeObjGuard是用来��生对象的实际�c�d��的，下面是一�?br />Loki::MakeGuard的例子：
template
inline ScopeGuardImpl1 MakeGuard(F fun, P1 p1)
{
return ScopeGuardImpl1::MakeGuard(fun, p1);
}
可以看到ScopeGuardImpl1是要产生的具体类型，MakeGuard通过函数参数的数目来重蝲的，而MakeGuard此处的作用是要睡��M��...-_-'',作用是利用函数自动推导出参数的类型，�q�样��免��M��指定ScopeGuardImpl1的类型的�ȝ��Q��?br />ScopeGuardImpl1::MakeGuard(fun, p1);
��单的�q�回对象的一个��时变量，�q�assign�l�一个上面的一个scopeguard的实例，�q�里依赖一个C++的特性，临时变量的声命周期和通过他初始化的引用类型的声明周期是一致的�?/p>

从上面可以看到Loki定义了一个ScopeGuardImplBase的基��c�R��这个类定义了一个基本的�Ҏ��Dismiss,以及相关的状态。下面是loki中这个类的定�?br />class ScopeGuardImplBase
{
    ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
protected:
    ~ScopeGuardImplBase()
    {}
    ScopeGuardImplBase(const ScopeGuardImplBase& other) throw()
        : dismissed_(other.dismissed_)
    {
        other.Dismiss();
    }
    template
    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;
      }
};
可以看到�c�里面定义了上面所说的一些属性，其中SafeExecute用来提供子类同一的资源释放方法，�q�调用子�cȝ��Ҏ��来具体操作，因�ؓ相关的函敎ͼ�变量都保存在具体的子�c�，可以看到�q�个函数使用了try catch�Q�这里加�q�个的目的是�Q�因��源释放要在子�cȝ��E�构里被触发，而调用具体的�Ҏ��是外面传�q�来的，所以无法保证一定是异常安全的，而假如在�E�构里面异常的话，会导致程序的行�ؓ无法定义�?br />下面具体来看下一个子�cȝ��实现�Q?br />template
class ScopeGuardImpl1 : public ScopeGuardImplBase
{
public:
    static ScopeGuardImpl1 MakeGuard(F fun, P1 p1)
    {
        return ScopeGuardImpl1(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里面可以看到很多�c�M��ScopeGuardImpl1的定义，比如ScopeGuardImpl0�Q?br />ScopeGuardImpl2�Q�可以发现最后面的数字表�C�具体参数的数目�?br />可以看到上面所说的MakeGuard的定义，以及对基�c�L��法的调用�Q�可以看到构造函数接收的�c�d��Q�一个函数对象，和一些参数对象，�q�保存，对于成员函数的scopeguard,LoKi定义�?些相似的�c�，主要是增加了对象的引用，�q�有��是函数的调用方式上�?br />上面可以看到参数是通过值的方式来保存的而不是通过引用。而且是const属性的�Q�下面是相关的分析�?br />1�Q�通过传值的方式�Q�从而避免了异常抛出�Ӟ��可能引用的对象被�E��?br />2�Q�加const属性，从而保证了在func需要参数是reference时而保存的参数��是非const时��生相应的�~�译错误�Q�因为对reference传�hconst non-reference形式是错误的�?br />而对�?的方式，存在的一�U�问题是假如操作的fun需要传入引用，那传�q�去的值就无法在释攄��函数中被改变�Q��?是对�q�种的一�U�类似契�U�似的编�E�，Loki 提供的方法是通过一个中间对象来保存操作参数的引用，�q�赋予这个对象自动�{换功能。下面是�q�个�cȝ��定义�Q?br />template
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_;
};
可以很清楚的看到�cȝ��实现�Q�下面是一个工��L��
template
inline RefToValue ByRef(T& t)
{
     return RefToValue(t);
}
下面�l�个具体的例子，假如
template
void SAFEDELETE(_Ty*& ptr)
{
   if (NULL != ptr)
      delete ptr;
   ptr = NULL;
}

char* ptr = new char;

{
LOKI_ON_BLOCK_EXIT(SAFEDELETE,Loki::ByRef(ptr));
}

if (NULL == ptr)
std::cout << "NULL" << std::endl;
基本上就�q�么多了�Q�sleep��M��
alex_yuu

agerlis 2007-02-11 15:55 发表评论

解析boost::any

agerlis — Sun, 11 Feb 2007 07:54:00 GMT

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

template
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
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
_Ty& __Access();

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

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

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

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

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

typedef any ANY;

�q�样��g��可以接收�Q何类型了,也可以取出数据，取出时必��要知道相应的类型，而且�Q�假如类型不在列表里面，则编译期出错

class CERROR_ACCESS_DENIED;
LOKI_STATIC_CHECK((Loki::TL::IndexOf<_typelist,_Ty>::value != - 1),CERROR_ACCESS_DENIED);

�q�样�Q?_-''��g��可以了�Q�只要所接收的类型可以拷贝即可。但有个明了的缺��P��?��是接收的类型必��ȝ��译期写死�Q�假如不写死的话�Q�我个�h开始的认�ؓ是加一个基�c�，-_-''

�q�是�?q我那位朋友，让我了解到boost::any的用�?/div>

下面是boost::any的具体分�?我们要达��C��面几个要求：

1�Q�可以接收�Q何类型的数据�Q�具有value属�?

2: 可以方便的取出数�?/div>

3�Q�型别安全，不象void*

下面是boost::any的实玎ͼ�我按部分��_��而且省去我认��Z��重要的东西，因�ؓ太长了，�q�会影响我blog的收视率�?/div>

1�Q�首先来看下他的构造和�E��?-_-''错别字）

any()
: content(0)
{
}

template
any(const ValueType & value)
: content(new holder(value))
{
}

any(const any & other)
: content(other.content ? other.content->clone() : 0)
{
}

~any()
{
delete content;
}
从构造函数可以看刎ͼ�any可以接受默认的，��M��其他值包括ant本��n�Q�在�E�构里面可以看到对content的释放，content在这里是一个基�cȝ��指针�Q�是any内部实现的，我们可以看到�Q�在对any构造是有种�Ҏ��Q?/font>

�Q?�Q�content(new holder(value))
�Q?�Q�content(other.content ? other.content->clone() : 0)

�E�后会看到holder是派生自content�c�d��的一个模板实玎ͼ�也许讲到�q�里�Q�有些应该明白了any是怎么保存��M��c�d��的吧�Q�对于其他any的构造，我们发现调用了content的一个clone�Ҏ��Q�很明显�q�是content的一个虚�Ҏ��Q�这个方法的存在得以让我们运用虚函数的机制正��的拯��对象�Q�下面会看到�q�只是个��单的new操作�?/font>

2:来看下any的operator =的重�?/div>

any & swap(any & rhs)
{
std::swap(content, rhs.content);
return *this;
}

template
any & operator=(const ValueType & rhs)
{
any(rhs).swap(*this);
return *this;
}

any & operator=(const any & rhs)
{
any(rhs).swap(*this);
return *this;
}

可以看到operator =�Q�接收�Q何其他类型的参数�Q�swap�Ҏ��的实玎ͼ�用来交换2个对象的content指针�Q�我们可以看到operator =里面临时对象的构建，在函数结束后�Q�自动释攑֎�来content的对象，�q�有点RAII味道。（http://blog.sina.com.cn/u/1019039487)独家��菜。�?/font>

3�Q�下面来看下辅助�c?/div>

bool empty() const
{
return !content;
}

const std::type_info & type() const
{
return content ? content->type() : typeid(void);
}

可以看到。一个empty,一个type,很�Ş象�?/div>

4�Q�下面来看下上面content所指的对象�Q�以及any怎么保存��M��c�d��Q�以及这�U�怎么保证型别安全

class placeholder
{
public: // structors

     virtual ~placeholder()
     {
     }

public: // queries

virtual const std::type_info & type() const = 0;

virtual placeholder * clone() const = 0;

};

template
class holder : public placeholder
{
public: // structors

     holder(const ValueType & value)
              : held(value)
     {
     }

public: // queries

     virtual const std::type_info & type() const
     {
         return typeid(ValueType);
     }

     virtual placeholder * clone() const
     {
          return new holder(held);
     }

public: // representation

ValueType held;

};(-_-''格式矫正真是�c�d��)

placeholder��是上面content指向的对象，可以看到他定义的一些提供给any调用的函数和虚基本必��ȝ��虚稀构函敎ͼ�可以看到any对content调用了delete)

下面�?font color="#0000ff">holder的实玎ͼ�holder是一个模板，里面定义�?/font>

ValueType held;

很明星是any用来保存��M��c�d��的，回顾下上面所说的any初始化content�?�U�方�?/font>

�Q?�Q�content(new holder(value))
�Q?�Q�content(other.content ? other.content->clone() : 0)

从这个地方可以看到怎么初始化holder对象�Q��ƈ保存到content.注意到这里的held是public的，�q�样��提供了�Ҏ��据访问的功能�Q�在讉K��的时候必��要知道具体要访问的�c�d��Q�才能调用相应的static_cast或者dynamic_cast来操作，而这样其实也提供了型别安全的保证�Q�eg:不象malloc,�q�回void*,然后()转换一下�?/font>

5�Q�看下怎么讉K��any里面的属性��|��q�里��׃��列�D出所有的实现�Q�因为有些是对const的版本�?/div>

template
ValueType * any_cast(any * operand)
{
    return operand && operand->type() == typeid(ValueType)
                    ? &static_cast *> (operand->content)->held
                    : 0;
}

template
ValueType any_cast(const any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference::type nonref;

   const nonref * result = any_cast(&operand);
   if(!result)
            boost::throw_exception(bad_any_cast());
    return *result;
}//�q�里��L��1些原来实现的代码和注�?/font>

可以看到具体的实现方式＆dynamic_cast的逻辑差不多，对引用的cast有可能抛出异常。通过上面�q�种方式�Q�就辑ֈ�了对数据的读取，��d��时必��ȝ��道里面的数据�c�d��。可以看出any只能保存一个��|��-_-''不向我那个，可以同时保存不同�c�d��的倹{�?/font>

6�Q�extension

可以通过std::vector anys,来构��Z��个�Q何类型的列表�Q�但讉K��比较�ȝ��?/div>

也可以通过any来达到虚函数不能为template的限�Ӟ��因�ؓ一个是静态的一个是动态的�Q?/div>

象下面：

class CBase

{

public:

virtual void Set(boost::any) = 0;

};

class CHild:

public CBase

{

public:

virtual void Set(boost::any param)

{

m_value = param;

}

private:

boost::any m_value;

};

CHild test;
CBase* ptr = &test;

ptr->Set(1);
ptr->Set('a');

7.finish...�ȝ��完成�?..-_-''要变唐僧�?..

alex. agerlis@163.com

agerlis 2007-02-11 15:54 发表评论

旉��理

agerlis — Sun, 11 Feb 2007 07:54:00 GMT

听说�q�一�U�时间管理的�Ҏ��,是用来怎么安排��d��和时间的,下面是大概的概念�?

time - task

图中��头指向的方向表�C�紧�q�度的添�?那么下面是关�?,2,3,4的定�?

一:��d��比较重要,但相应的旉��也很�?/p>

�?��d��是长期�Q�?但比较重�?/p>

�?不那么重要的��d��,旉��也很�?/p>

�?不需要多长时间的非重要�Q�?/p>

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

对于�?我们有充��的旉��来做重要的�Q�?�q�正是我们想要的,�?怎么做才能��其不会过渡到区间一�?转�ؓ区间1往往会由于�h的惰性��生的,关键是要提前做事.安排好时�?

对于�?往往是一些可以辅助我们成长的事情,�q�些东西�Ҏ��们有益处,�q�对全面的发展�v��C��很好的作�?-_-''��p��我学吉他..

对于�?是些旉��?但不重要的�Q�?比如要帮助�h去google一些资�?

从上面可以看�?区间一实际上是最差的,但�ؓ了做好区�?,我们必须要尽量减��区�?的䆾�?而对于全面的发展,我们也要安排旉��到区�?.�q�也是很重要�?

agerlis 2007-02-11 15:54 发表评论

agerlis — Sun, 11 Feb 2007 07:53:00 GMT

以前C��d��命��o行参数感觉太�ȝ��,而且不容易记�?下面是另外一�U�命令行的读取方�?/div>

通过GetCommandLine(),来返回当前的命��o�?

setlocale(LC_ALL, ".ACP");
std::wcout << GetCommandLine() << std::endl;

下面是输�?

"e:\学习�E�序\consol3\debug\consol3.exe" a b c

对于命��o行的参数��d��用CommandLineToArgvW,可以把命令行参数转换成字�W�串数组的�Ş�?/font>

int nums = 0;
TCHAR** temp = CommandLineToArgvW(GetCommandLine(),&nums);

for(int i = 0; i < nums; i++)
{
std::wcout<< temp[i] << std::endl;
}

下面是输�?
e:\学习�E�序\consol3\debug\consol3.exe
a
b
c
可以看到命��o行参��C��下标=1的元素开�?

感觉�q�种形式比较好记�?/div>

agerlis 2007-02-11 15:53 发表评论

学习abstract factory�W�记

agerlis — Sun, 11 Feb 2007 07:53:00 GMT

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

pCreateWindow1->CreateListWindow()->DrawList();
pCreateWindow1->CreateScrollWindow()->DrawScroll();
假如需要用不同的工厂，则更换不会媄响到调用处的代码。因为掉用工厂的地方是面向接口的。其实abstract factory的理念应该是比较��单的(^^瞎猜�?.基本讲完了什么是抽象�c�d��厂，他要解决的一些问题以及怎么解决�?个小而�ؕ的demo代码�D�c��下面来看下我们怎么泛化�q�个�c�d��厂，�q�个会涉及到loki里面的具体实玎ͼ�大家要加满��a啊，因�ؓ泛化�c�d��厂是一件不�Ҏ��的事情啊�?/p>

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

template
<
    class TList,
    template class Unit = AbstractFactoryUnit
>
class AbstractFactory : public GenScatterHierarchy
{
public:
     typedef TList ProductList;

     template T* Create()
     {
        Unit& unit = *this;
        return unit.DoCreate(Type2Type());
     }
};
可以看到�q�个即由GenScatterHierarchy来得��C��我们惌��的东�ѝ��提供了Create的模板函敎ͼ�使得我们可以象这样factory.Create()的方便�Ş势来调用。ProductList是对于抽象工厂要创徏的类型的重命名。方便后面在产生实际的类型时�Q�获取对应的�c�d��信息�Q�对于DoCreate的参敎ͼ�大家应该都明白这是重载用的，那用在哪里呢�Q�下面会介绍�?/font>

泛化_2
在辛苦介�l�完泛化抽象工厂的接口后�Q�我们可以通过�c�M��的方式来定义1个abstract factory的接�?br />Loki::AbstractFactory
下面我们来介�l�最后的�Q�我们怎么来提供抽象工厂的实现�Q�首先是对象的创建，loki里面提供了默认的创徏的方法，当然我们可以修改或用特化的版本来做选择�?br />template
class OpNewFactoryUnit : public Base
{
     typedef typename Base::ProductList BaseProductList;

protected:
     typedef typename BaseProductList::Tail ProductList;

public:
     typedef typename BaseProductList::Head AbstractProduct;
     ConcreteProduct* DoCreate(Type2Type)
     {
          return new ConcreteProduct;
     }
};

可以看到DoCreate是我们的核心部分�Q�里面调用了new来创建对象。而这里也让我们看到这应该是上面创建对象的重蝲。而Type2Type的作用正是在�q�里体现作用�Q�因为c++无法通过函数�q�回值来重蝲不同的对象。也�怽�会看��C��面的一些类型定义，包括OpNewFactoryUnit�?个模板参敎ͼ��W?个模板参数是实现GenLinearHierarchy必备的GenLinearHierarchy和上面的GenScatterHierarchy的核心思想一��P��都是通过��L��化来实现的，不过GenLinearHierarchy产生的是�U�性的�l�承体系�Q�中间夹杂着比如OpNewFactoryUnit >�q�样的�Ş�ѝ��下面来看下抽象工程的具体实现的泛化�Q�联�p��v来就能对上面的理解了
template
<
    class AbstractFact,
    template class Creator = OpNewFactoryUnit,
    class TList = typename AbstractFact::ProductList
>
class ConcreteFactory
     : public GenLinearHierarchy<
     typename TL::Reverse::Result, Creator, AbstractFact>
{
public:
    typedef typename AbstractFact::ProductList ProductList;
    typedef TList ConcreteProductList;
};
可以看到ConcreteFactory由GenLinearHierarchy来驱动��生我们想要的�Q�本来这个脓图比较明朗点�Q�但我懒的画�Q�哈哈。从GenLinearHierarchy的参数来看，�W?个是具体的实现类的typelist,比如LOKI_TYPELIST2(CScrollBar_1,CListWindow_1),至于��Z��么要对类型做reverse操作�Q�因为在�cȝ��基础体系产生后，typelist的第1个元素，在��承体�p�L��׃��往上的�Q�而于上面由OpNewFactoryUnit�{�定义的ProductList的Head定义的自上往下的是相反的�Q�所以这里应用了reverse操作。Creator��是上面的OpNewFactoryUnit或你自定义的元素。�ƈ在具现化是，应用typelist的每个类型。AbstractFact是��承体现的最��端�Q�这个应该很明显�Q�就是上面定义的AbstractFactory,�q�样啥都明确了，具体的接口，�Ҏ��口的函数的重载都已经泛化完成。下面是�Q�^^睡死了，睡觉��M��Q�简单从便，上面均未调试�?.至于��Z��么会把第3个参数默认�ؓ抽象�c�d��厂接口的ProductList�Q�这个和loki用基于prototype的Creator有关�p�R��?^^俺是菜鸟�Q�就只能到这里了)
对abstract factory的看法，优点在上面的已经说过了，��定在，我们要添�?�U�对象的创徏�Ӟ��都要��M��Ҏ��口的定义�Q�当然后面的泛化也�ؓ我们解决了些问题�Q�但泛化对于参数的传递不怎么好用�Q�可以通过提供新的OpNewFactoryUnit来适当解决�?br />                                                    agerlis.2007.2.10 0:22

agerlis 2007-02-11 15:53 发表评论

agerlis — Sun, 11 Feb 2007 07:52:00 GMT

handle-body,睡死了，但还是得坚持下。其实这个是很简单的概念
�q�个也称��gؓpimpl,是private implemention的羃写，下面涉及到的都叫做pimpl, 那用�q�个到底有什么好处呢�Q?br />1�Q�可以把具体的实��C��client端封装，�q�样即��修改实现�Q�只要不修改头文�Ӟ��对client端来��_��是没有�Q何媄响的�Q�甚至不改变代码�?�q�制�Ҏ�?br />2�Q�加速编译时��_��我们知道有时头文件有太多的实玎ͼ�会导致包含这个头文�g的其他文件的�~�译旉��增加�Q�通过pimpl,我们把实��C��头文件移到cpp里面�Q�从而减��了其他包含�q�个文�g的编译时��_��加快�~�译速度
3�Q�减��依赖，�q�个实际上也增加了编译的速度�Q�可以不对client端暴露一些实��C��的头文�g�Q�从而减��了依赖说了�q�么多，下面来看下一个简单的pimpl的实现。是用loki的类来实现的。哈哈，睡死了，��h��
/*.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的作用，但相信在实践中你会体会到�Q�把原来定义在CTest里面的一些私有的�Ҏ��Q�成员，全部挪到ImplT里面�Ӟ��你会体会刎ͼ��q�个CTest的头文�g里include了很��的��_��他可以说完成了原始的使命�Q�达��C��功能性接口的作用�Q�而其他原来定义在头里�?h,可以全部挪到cpp里了。下面来分析下loki是怎么实现的。可以看到实现pimpl首先需要牵�|�声明pre define�c�，loki通过模板的全特化来实��C��q�个的隐藏，从而避免了把具体的实现�c�L��露给client的弊端。下面来看下�q�个泛化的pre define: template struct ImplT; 哈哈�Q�很��单，再看上面我的cpp里的定义�Q�大家结合上面也许就明白了吧�Q�部�q�，�q�里需要注意的是，CTest的构造函数要写后面，不然can;t compile. 但是�Q��ؓ什么具体的实现�c�L��ImplT但，前面�?br />Loki::PimplT::Type m_impl;
那Loki::PimplT::Type是什么用的，我们知道�Q�假如保存原始的
Loki::ImplT* m_impl;
然后new一�?其实�q�样只存�?个问题，2个不方便�Q?br />1�Q�问题是�q�样的原始指针，不能传播const信息�Q�也��是��_��对象CTest转�ؓconst的化�Q�他里面的指针类型不是同样随着带有const属性，也就是说�Q�假如此时指针指向的对象有个函数�Q�提供了const�Q�none const的，此时�Q�还是会调用non const的，所以，外界�q�是可以通过�q�个对象来做修改�?br />2�Q?个不方便是，你必��d��对象实现new和delete.
下面来看下loki是怎么做的
template
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_;
};

�q�个�c�L��供了寚w��?的解冟뀂下面会讲解�Q�主要的�Ҏ��Q�对象不同于指针�Q�对象能传递const属性�?br />下面看下pimlT的定义：
template class Ptr = ConstPropPtr>
struct PimplT
{
typedef T Impl;

// declare pimpl
typedef Pimpl, Ptr > > Type;

// inherit pimpl
typedef PimplOwner, Ptr > > Owner;
};
可以看到�?/font>Type 的定义，下面的owner也不说了�Q�直接到Pimpl,

template
<
        class T,
        typename Pointer = ConstPropPtr
>
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_;
};

可以看到�Q�这个类用了上面�?font color="#0000ff">ConstPropPtr从而��对象有了const属性的传递。其他的�Q�实际上�Q�帮你操作了new,�?/font>ConstPropPtr里释放，有点RAII的味道，剩下的完全模拟保存的指针的行为，即implT的实玎ͼ�从而��其能正确的操作对象�?/font>

睡死了，早早�l�束

alex_yuu

agerlis 2007-02-11 15:52 发表评论

agerlis — Sun, 11 Feb 2007 07:32:00 GMT

我的msn:agerlis@163.com
我的email:agerlis@163.com
我的qq:350457656

agerlis 2007-02-11 15:32 发表评论

久久综合视频网站,午夜肉伦伦影院久久精品免费看国产一区二区三区,久久精品国产69国产精品亚洲

�~�写异常安全的代�?loki::scopeguard)

解析boost::any

旉������理

学习abstract factory�W�记

旉��理