4 创建型模式-----建造者模式

模式动机：一个对象由若干部件组成，而组合这些部件的过程比较复杂，因此可以把这个组合工作交给建造者来完成，建造这返回给客户的是一个组装好的对象。

模式定义(Builder Pattern)：将一个复杂对象的构建与表示分离开来，使得同样的构建过程可以创建不同的表示形式。

模式结构图：





其中包含抽象建造者Builder、具体建造者ConcreteBuilder、指挥者Director、产品Product。该模式中引入了Director，负责控制产品的生产及其与用户的隔离工作。Director针对抽象建造者Builder编程，客户只要知道具体建造者ConcreteBuilder的类型就能得到一个完整的产品。

模式代码：

bt_建造者模式.h：

#ifndef BP_H
#define BP_H

#include <iostream>

using namespace std;

/*
产品类
*/
class Product
{
public:
const string& getA() const{ return partA; }
void setA(const string& a){ partA = a; }
const string& getB() const{ return partB; }
void setB(const string& b){ partB = b; }
const string& getC() const{ return partC; }
void setC(const string& c){ partC = c; }

private:
string partA;
string partB;
string partC;
};

 /*
抽象建造者类
*/
class Builder
{
public:
virtual ~Builder(){ };
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual void buildPartC() = 0;
virtual Product* getResult() = 0;
};

 /*
具体建造者类
*/
class ConcreteBuilder : public Builder
{
public:
ConcreteBuilder()
{
product = new Product;      // 具体工厂new一个Product对象，这个工作也可以在抽象工厂中完成
}

virtual void buildPartA()
{
product->setA("AAA");
cout << "构建完成A部分" << endl;
}
virtual void buildPartB()
{
product->setB("BBB");
cout << "构建完成B部分" << endl;
}
virtual void buildPartC()
{
product->setC("CCC");
cout << "构建完成C部分" << endl;
}
virtual Product* getResult()
{
cout << "构建工作全部完成了" << endl;
return product;
}

private:
Product* product;
};

/*
指挥者类
*/
class Director
{
public:
Director(Builder* builder)
{
this->builder = builder;
}

Product* construct()
{
builder->buildPartA();
builder->buildPartB();
builder->buildPartC();
return builder->getResult();
}

private:
Builder* builder;
};

#endif // BP_H

bt_建造者模式.cpp：

#include "bt_建造者模式.h"
#include <iostream>

using namespace std;

int main()
{
　　　　cout << "***** 建造者模式测试 *****" << endl;
Builder* builder = new ConcreteBuilder;
Director* director = new Director(builder);
Product* product = director->construct();

delete product;
delete director;
delete builder;

return 0;
}

模式优缺点：使用不同的具体建造者，用户可以得到不同的具体对象；增加新的建造者无需修改抽象类即可更改建造方式，因此，对于产品内部组成部分不变的情况下，可以很容易实现花样建造，符合“开闭原则”； 但是如果产品内部发生变化，那么就必须修改建造者。