设计模式03 - 建造者模式

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

• 隔离了构建的步骤和具体的实现，为产品的具体实现提供了灵活度
• 封装和抽象了每个步骤的实现，实现了依赖倒转原则

• 封装了具体的步骤，减少了代码的冗余

  
  

2. 代码实现

//Builder.h
#ifndef _BUILDER_H_
#define _BUILDER_H_

#include <stdio.h>

class Product{
public:
    Product();
    ~Product();

    void setPartA(int param);
    void setPartB(int param);
    void setPartC(int param);

    void show();

private:
    int partA;
    int partB;
    int partC;
};

class AbstractBuilder{
public:
    AbstractBuilder();
    virtual ~AbstractBuilder();

    virtual void createProduct() = 0;
    virtual void buildPartA(int param) = 0;
    virtual void buildPartB(int param) = 0;
    virtual void buildPartC(int param) = 0;

    virtual Product* getProduct() = 0;
};

class Builder: public AbstractBuilder{
public:
    Builder();
    ~Builder();

    void createProduct();
    void buildPartA(int param);
    void buildPartB(int param);
    void buildPartC(int param);

    Product* getProduct();

private:
    Product* curProduct;

};
#endif
 

//Builder.cpp
#include "Builder.h"

Product::Product() { }

Product::~Product() { }

void Product::setPartA(int param)
{
    partA = param;
}

void Product::setPartB(int param)
{
    partB = param;
}

void Product::setPartC(int param)
{
    partC = param;
}

void Product::show()
{
    fprintf(stderr,"partA = %d  partB = %d  partC = %d\n",partA,partB,partC);
}

AbstractBuilder::AbstractBuilder() { }

AbstractBuilder::~AbstractBuilder() { }

Builder::Builder()
:curProduct(NULL) { }

Builder::~Builder() { }

void Builder::createProduct()
{
    fprintf(stderr,"创建一个产品空壳\n");
    curProduct = new Product();
}

void Builder::buildPartA(int param)
{
    fprintf(stderr,"正在构建产品的A部分\n");
    curProduct->setPartA(param);
}

void Builder::buildPartB(int param)
{
    fprintf(stderr,"正在构建产品的B部分\n");
    curProduct->setPartB(param);
}

void Builder::buildPartC(int param)
{
    fprintf(stderr,"正在构建产品的C部分\n");
    curProduct->setPartC(param);
}

Product* Builder::getProduct()
{
    return curProduct;
}
 
//Director.h
#ifndef _DIRECTOR_H_
#define _DIRECTOR_H_

#include "Builder.h"

class Director
{
public:
    Director(AbstractBuilder* builder);
    ~Director();

    void construct();

private:
    AbstractBuilder* curBuilder;
};

#endif

//Director.cpp
#include "Director.h"

Director::Director(AbstractBuilder* builder)
{
    curBuilder = builder;
}

Director::~Director() { }

void Director::construct()
{
    if (!curBuilder)
        return;

    curBuilder->createProduct();
    curBuilder->buildPartA(1);
    curBuilder->buildPartB(2);
    curBuilder->buildPartC(3);
}

//client.cpp
#include "Director.h"

int main()
{
    AbstractBuilder* builder = new Builder();
    Director* director = new Director(builder);

    director->construct();
    
    Product* product = builder->getProduct();
    product->show();
    return 0;
}