设计模式在游戏中的应用--建造者模式（九）

建造者模式(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内部有着稳定的创建过程。