设计模式之建造者模式

建造者

目的：

Separate the construction of a complex object from its representation so that
the same construction process can create different representations.

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

与工厂模式对比

Builder模式和AbstractFactory模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。而在AbstractFactory模式中对象是直接返回的，AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了；而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。

C++实现：

至少包括4个类：产品类，抽象建造类，具体建造类和导演类，产品类提供具体的实现接口，抽象建造类为具体建造类提供统一的方法，具体建造类包含一商品对象，并实现具体的方法，导演类包含一抽象建造类对象，对通过一公有方法，统一安排 具体建造类的方法。

示例代码： 

//builder.h
#include <iostream>
#include <string>
using namespace std;

class product
{
private:
    string m_partA;
    string m_partB;
    string m_partC;
public:
    void setPartA(string A);
    void setPartB(string B);
    void setPartC(string C);
    string getPartA();
    string getPartB();
    string getPartC();
    
};

class abstractbuilder
{
public:
    virtual void buildPartA()=0;
    virtual void buildPartB()=0;
    virtual void buildPartC()=0;
    virtual product getProduct()=0; //返回指针与返回变量的区别
};

class concreteBuilder1:public abstractbuilder
{
public:
    virtual void buildPartA();
    virtual void buildPartB();
    virtual void buildPartC();
    product getProduct();
private:
    product m_product;
};

class  concreteBuilder2:public abstractbuilder
{
public:
    virtual void buildPartA();
    virtual void buildPartB();
    virtual void buildPartC();
    product getProduct();
protected:
private:
    product m_product;
};

class Director
{
public:
    Director(abstractbuilder *builder);
    ~Director();
    void construct();
//private:
    abstractbuilder *m_builder;
};

//builder.cpp
#include "builder.h"
void product::setPartA(string A)
{
    m_partA=A;
}

void product::setPartB(string B)
{
    m_partB=B;
}

void product::setPartC(string C)
{
    m_partC=C;
}

string product::getPartA()
{
    return m_partA;
}

string product::getPartB()
{
    return m_partB;
}

string product::getPartC()
{
    return m_partC;
}

void concreteBuilder1::buildPartA()
{
    m_product.setPartA("build1partA");
}

void concreteBuilder1::buildPartB()
{
    m_product.setPartB("build1PartB");
}

void concreteBuilder1::buildPartC()
{
    m_product.setPartC("build1PartC");
}

product concreteBuilder1::getProduct()
{
    return this->m_product;
}


void concreteBuilder2::buildPartA()
{
    m_product.setPartA("build2partA");
}

void concreteBuilder2::buildPartB()
{
    m_product.setPartB("build2PartB");
}

void concreteBuilder2::buildPartC()
{
    m_product.setPartC("build2PartC");
}

product concreteBuilder2::getProduct()
{
    return this->m_product;
}
void Director::construct()
{
    m_builder->buildPartA();
    m_builder->buildPartB();
    m_builder->buildPartC();
}

Director::Director(abstractbuilder *builder)
{
    this->m_builder=builder;
}
Director::~Director()
{
    if (m_builder!=NULL)
    {
        delete m_builder;
        m_builder=NULL;
    }

}

//main.cpp
#include "builder.h"
void main()
{
    Director* pDirector = new Director(new concreteBuilder1());
        pDirector->construct();
    cout<<pDirector->m_builder->getProduct().getPartA();
    
        Director* pDirector1 = new Director(new concreteBuilder2());
        pDirector1->construct();
    cout<<endl<<pDirector1->m_builder->getProduct().getPartA()<<endl;

        return;
}

参考文献

1 C++设计模式实现--建造者

2 C++设计模式-Builder建造者模式

3 设计模式--建造者模式