ITPub博客

首页 > Linux操作系统 > Linux操作系统 > 简单实现设计模式(转)

简单实现设计模式(转)

原创 Linux操作系统 作者:jcszjswkzhou 时间:2019-05-08 14:12:06 0 删除 编辑
简单实现设计模式
发完这个贴,要休息一段时间才动笔了。


下面这些设计模式的实现都是一些简单的示例实现,如果你希望更稳固,更方便的实现,请自己修改。我以Gof的书作为蓝本,实现里面可以被抽象的设计模式,里面使用Loki, Boost, STL的一些东西,如果有疑问的话请翻阅相关书籍。

//***************************************************************************

Abstract Facrory 抽象工厂:

目的:
为了把产品的创建抽象化
为了隐藏产品的实现
为了实现一序列产品的安全创建

实现:

namespace Noir_Impl
{
template
struct CAF_Product { P* Create_Impl() { return new P; } };

template
class CAF_AbstractFactory : public Loki::GenScatterHierarchy< CProductList, CAF_Product > { };
};

//IProductList是你的抽象工厂接口,CProductList是你的抽象工厂的实现

template
struct Simple_AbstractFactory : public IProductList, private Noir_Impl::CAF_AbstractFactory< CProductList >
{
template IP* Create()
{
typedef TypeAt< CProductList, IndexOf< IProductList, IP >::value > CP;
return CP::Create_Impl();
}
};

//***************************************************************************

Builder 产生器:

目的:
为了实现通过继承修改产品创建的某个环节

实现:

template struct IBuilder; //产生器接口,stepnum表示分几步构造

template<>
struct IBuilder<0>
{
virtual void BuildPart(Loki::Int2Type<0>&) = 0;
};

template
struct IBuilder : public IBuilder< stepnum - 1 >
{
virtual void BuildPart(Loki::Int2Type&) = 0;
};

template
struct Simple_Builder //产生器
{
template static void Build(T* obj)
{
obj->IBuilder::BuildPart(Loki::Int2Type());
Build< stepnum - 1 >(obj);
}
template<> static void Build<0>(T* obj)
{
obj->IBuilder<0>::BuildPart(Loki::Int2Type<0>());
}
};

//***************************************************************************

Clone Factory 克隆工厂:

目的:
为了不关心我们将创建的对象的类别
为了避免类爆炸,通过运行时的参数指定来创建新的“类”

实现:

namespace Noir_Impl
{
template
class CCL_Product
{
private:
P* m_obj;
public:
CCL_Product() : m_obj(NULL) { }
void Set_Impl(P* p) { assert(p); m_obj = p; }
P* Clone_Impl() { assert(m_obj); return new P(m_obj); }
};

template
class CCL_CloneFactory : public Loki::GenScatterHierarchy< CProductList, CCL_Product > { };
};

template //IProductList是你的克隆工厂接口,CProductList是你的克隆工厂的实现
struct Simple_CloneFactory : public IProductList, private Noir_Impl::CCL_CloneFactory< CProductList >
{
template void Set(IP* p)
{
typedef TypeAt< CProductList, IndexOf< IProductList, IP >::value > CP;
CP::Set_Impl(p);
}
template IP* Clone()
{
typedef TypeAt< CProductList, IndexOf< IProductList, IP >::value > CP;
return CP::Clone_Impl();
}
};

//***************************************************************************

FactoryMethod 对象工厂:

目的:
为了在运行时通过外部信息来创建产品
当不关心对象的类别的时候

实现;

#define CLASSID(x) static const int CLASS_ID = x;

template< class IC, class PList >
struct Simpe_FactoryMethod : public Loki::SmallObject<>
{
template IC* Create(int id)
{
assert( id >= 0 );
typedef TypeAt::Result CClass;
if( id == CClass::CLASS_ID )
return new CClass;
else
return Create(id);
}
template<> IC* Create<0>(int id)
{
assert( id >= 0 );
typedef TypeAt::Result CClass;
if( id == CClass::CLASS_ID )
return new CClass;
else
assert(0);
}
};

//***************************************************************************

Singleton 单件:

目的:
一个安全的全局变量,你可以完全监控他的行为

实现:

template
class Simple_Init
{
private:
static T _obj;
public:
static T& Instance() { return _obj; }
};
template
T Simple_Init::_obj;


template
class Lazy_Init
{
public:
static T& Instance() { static T _obj; return _obj; }
};

template< class T, template class S=Simple_Init>
class Simple_Singleton : private S, private boost::noncopyable, private noncreatable, public T
{
private:
operator &() const;
operator T() const;
public:
using S::Instance;

bool Init() { return Instance().Init(); }
bool UnInit() { return Instance().UnInit(); }
};

//***************************************************************************

Adapter 适配器:

目的:
为了把不吻合或不搭配的接口转换成我们希望的接口

实现:
无固定实现

//***************************************************************************

Bridge 桥接:

目的:
抽象出实现的“核心部分”和“扩展部分”,“扩展部分”由“核心部分”实现,通过切换“核心部分”来使“扩展部分”相应的改变,从而达到切换整个系统的目的

实现:
无固定实现,其实就是Policy的设计方法的一个运用

//***************************************************************************

Composite 组合:

目的:
为了把对象以及他们的组合体“一视同仁”

实现:

template
class Simple_Composite_Train : private Safe_Dector, public T, public Loki::SmallObject<>
{
private:
typedef Simple_Composite_Train ClassType;
std::list m_childlist;
public:
void ChildAs(ClassType* p)
{
assert(p);
p->m_childlist.pus_back(this);
}
void ParentAs(ClassType* p)
{
assert(p);
p->Chi


来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/10294527/viewspace-126673/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论

注册时间:2007-08-29

  • 博文量
    2754
  • 访问量
    2010831