建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。通过这个定义,我们可以得出建造者是一种创建型模式,也就是说建造者模式的输出是一个对象,也就是UML类图中的product。
我们先看看建造者模式的UML类图:
UML类图中我们可以看出,建造者模式使用了聚合、继承和依赖三种关系。第一个疑问就是为什么要使用聚合,如果我们不使用聚合的话,我们始终得到的都是稳定的构建过程,例如我们游戏中每个NPC都有2只手,当我们想要我们游戏在某些场合NPC都是一只手的时候,我们需要对每个ConcreteBuilder中添加生成一只手的逻辑,非常地冗余。
第二个疑问就是我们为什么使用继承,这个问题比较好回答,因为通过这次的基础我们可以让每个继承之Builder的子类都需要实现Builder中定义的纯虚函数,防止某些ConcreteBuilder忘记了写某些函数导致缺胳膊缺腿的情况。
最后一个疑问自然也就是为什么使用依赖,其实这个也比较好回答,因为我们要生成一个product。同时我们通过这个依赖关系能够得出,建造者模式是在product的基础之上进行封装,也就是说我们不喜欢改变product的东西而是调用porduct的方法。
游戏中会有各种log,而log往往都有公共的库,我们使用这些log的时候不希望改变log的内部结构,仅仅是使用这种log提供的各种方法。log可以分为各种类型,例如调试信息、错误信息、警告信息和自定义信息等。我们希望在Windows下面每种log的颜色不一样,方便我们查看,在linux下面每种log的颜色一样等。
代码如下图:
// MVC.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
class Log
{
public:
Log():m_color(0),m_size(0),m_isWriteFile(false){};
void SetSize(int size)
{
m_size = size;
}
void SetColor(int color)
{
m_color = color;
}
void WriteFile( bool value )
{
m_isWriteFile = value;
}
void PrintInfo()
{
cout<<"m_color:"<<m_color<<endl<<"m_size:"<<m_size<<endl<<"m_isWriteFile"<<m_isWriteFile<<endl;
cout<<"----------------------------"<<endl;
}
private:
int m_color;
int m_size;
bool m_isWriteFile;
};
class ILogBuider
{
public:
ILogBuider(){};
virtual ~ILogBuider(){};
virtual void SetColor() = 0;
virtual void SetSize() = 0;
virtual void WriteFile() = 0;
};
class DLogBuiler:public ILogBuider
{
public:
DLogBuiler()
:m_product(new Log())
{}
void SetSize()
{
m_product->SetSize(1);
}
void SetColor()
{
m_product->SetColor(1);
}
void WriteFile()
{
m_product->WriteFile(true);
}
Log* GetLog()
{
return m_product.get();
}
private:
auto_ptr<Log> m_product;
};
class ELogBuiler:public ILogBuider
{
public:
ELogBuiler()
:m_product(new Log())
{}
void SetSize()
{
m_product->SetSize(2);
}
void SetColor()
{
m_product->SetColor(2);
}
void WriteFile()
{
m_product->WriteFile(true);
}
Log* GetLog()
{
return m_product.get();
}
private:
auto_ptr<Log> m_product;
};
class WDirector
{
public:
WDirector(){};
void Construct(ILogBuider* builder)
{
builder->SetColor();
builder->SetSize();
builder->WriteFile();
}
};
class LDirector
{
public:
LDirector(){};
void Construct(ILogBuider* builder)
{
builder->SetSize();
builder->WriteFile();
}
};
void main()
{
//windows;
cout<<"------------Windows-----------------"<<endl;
auto_ptr<WDirector> wDirector(new WDirector());
auto_ptr<LDirector> lDirector(new LDirector());
auto_ptr<DLogBuiler>dBuilder(new DLogBuiler());
auto_ptr<ELogBuiler>eBuilder(new ELogBuiler());
wDirector->Construct(dBuilder.get());
wDirector->Construct(eBuilder.get());
dBuilder->GetLog()->PrintInfo();
eBuilder->GetLog()->PrintInfo();
//linux
cout<<"------------Linux-----------------"<<endl;
dBuilder.reset(new DLogBuiler());
eBuilder.reset(new ELogBuiler());
lDirector->Construct(dBuilder.get());
lDirector->Construct(eBuilder.get());
dBuilder->GetLog()->PrintInfo();
eBuilder->GetLog()->PrintInfo();
}
建造者模式属于一种创建型的模式,主要是对product进行封装从而能适应不同的情况,同时product内部有着稳定的创建过程。
版权声明:本文为博主原创文章,未经博主允许不得转载。