C++博客-Anywhere-随笔分类-设计模式学习笔记----创建模式

Prototype模式.-原型模型

三水寿 — Sun, 09 Aug 2009 13:01:00 GMT

实际为一个复制本身类的模式.
通过在成员函数中调用复制构造函数,返回一个自身的副本.
代码:

class Prototype
{
   public:
     Prototype();
     virtual ~prototype();
     virtual Prototype * Clone()=0;
};
class Child:public Prototype
{
  public:
    Child();
    Child(const Child &c);
    Prototype *Clone() const;
    {
       return new Child(*this);
    }
    ~Child();
};

主函数:
Prototype *pPro=new Child();
Prototype *pChild=pPro->Clone();

这样就可以得到一个子类对象的拷贝了.

三水寿 2009-08-09 21:01 发表评论

Builder模式

三水寿 — Mon, 20 Jul 2009 00:59:00 GMT

Builder模式:将一个复杂对象的构建与它的表示相分离.使得同样的构建过程可以创建不同的表示.一般情况下,且对象不是直接返回的...
定义:
先定义一个要构建的类:
class Product
{
public:
     Product();
    ~Product();
    void ProducePart();
};
class ProductPart//定义组成Product的部分.
{
   ProductPart();
     ~ProductPart();
    ProducePart *BuildPart();
};
然后创建一个Builder抽象类.
class builder
{
public:
       ~builder();
       virtual void ProducePartA(部分一);
       virtual void ProducePartB(部分二);
       virtual void ProducePartC(部分三);
       ...
      virtual Product * GetProduct()=0;
protected:                        //在主函数中一般不直接构造实例....比如:builder *p=new builder..
        Builder();
private:
};
3.定义一个生产具体对象的子builder
class childBuilder:public builder
{
   public:
      childBuilder();
     ~childBuilder();
     void BuildPartA();  /*****buildPartX()---start*********/
                                               生产过程
    ....                          /*****buildPartX()---end*********/
   Product *GetProduct();                        //返回生成的实例.....
};
4 定义一个类来实现某一产品对象的构造过程
class con
{
public:
      Director(builder *bldr);
      ~Director();
     void produce()         //构造产品.
       {
            BuildPartA();
           BuildPartB();
          .....
       }
protected;
private:
     Builder *_bldr;//通过_bldr来调用生产过程,完成对象的实现过程.

};
总结及讨论:builder模式似乎注重构建的过程,不需要返回构建的产品.如果想返回产品的话,可以在con中添加一个Product的指针.然后将该指针作为buildPart函数的参数..来完成product的构建,然后添加一个返回product的指针的函数得到该product.
或者在childbuilder中添加一个属性,为product *类型.然后通过GetProduct()得到该Prodcut.

三水寿 2009-07-20 08:59 发表评论

2.关于Singleton模式

三水寿 — Mon, 20 Jul 2009 00:25:00 GMT

singleton:独身,一个
Singleton模式比较简单,利用类的静态成员变量对于它的子类来说就一个拷贝这个特性,在定义类的时候为这个类添加一个静态的该类的指针,同时声明一个静态的方法(只能静态方法才能访问静态变量).这样,在创建这个类的对象的时候,就始终存在一个,唯一一个对象.
定义:
class Singleton
{
public:
     static Singleton *Instance()
      {
           if(NULL==_instance)//保证该实例不变.
              {
                  _instance = new Singleton();
                }
            return _instance;
      }
protected:
    Singleton();//限制了外部访问...
private:
    static Singleton *_instance;
};

三水寿 2009-07-20 08:25 发表评论

Factory && AbstractFactory;

三水寿 — Fri, 10 Jul 2009 08:16:00 GMT

Factory模式----为一类对象提供创建接口.

特点:当Factory仅仅提供了创建对象的接口时,这时候可以用模板的形式定义Factory类.
       此时的工厂直接生产.
例子:
代码:
Factory类提供一个创建对象的接口:virtual class CreateClass()=0;          //class 代表一个抽象类
ClassFactory则实现这个接口,virtual class CreateClass(){return new class()}; //class代表一个对象类.

使用模板的话:
class Factory
{
public:
~Factory();
virtual class Createclass()=0;
protected:
Factory();
};
typedef class
class classFactory:public Factory;
{
public:
    classFactory();
~classFactory();
    type Createclass(){return new type;}
};


当Factory不仅提供了创建对象的接口,同时将对象的实例化放到了工厂的子类中.
把Factory看作是总厂,负责提供"技术"．方法;Factory的子类看作是分工厂,负责生产具体的物品.
这样，生产一种商品就要派生一个子类．为了减少Factory的子类,也可以采用模板的形式定义子类.

AbstractFactory模式----为一组对象提供创建接口.

AbstractFactory
ChildFactoryA		ChildFactoryB		..
物品１生产	物品２生产（或者更多相关的）	物品3生产	物品4(more)

总之,抽象工厂是用来封装创建一组或一类相关对象的接口.

三水寿 2009-07-10 16:16 发表评论