设计模式【4】——建造者模式（Builder 模式）

---

前言

生活中有着很多的Builder的例子，个人觉得大学生活就是一个Builder模式的最好体验：要完成大学教育，一般将大学教育过程分成 4 个学期进行，因此没有学习可以看作是构建完整大学教育的一个部分构建过程，每个人经过这 4 年的（4 个阶段）构建过程得到的最后的结果不一样，因为可能在四个阶段的构建中引入了很多的参数（每个人的机会和际遇不完全相同）。
Builder 模式要解决的也正是这样的问题：当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样。

---

一、建造者模式（Builder 模式）

Builder 模式的关键是其中的 Director 对象并不直接返回对象，而是通过一步步（BuildPartA，BuildPartB，BuildPartC）来一步步进行对象的创建。当然这里 Director 可以提供一个默认的返回对象的接口（即返回通用的复杂对象的创建，即不指定或者特定唯一指定 BuildPart 中的参数）。UML图如下：

二、具体源码

1.Product.h

代码如下（示例）：

#ifndef _PRODUCT_H_ 
#define _PRODUCT_H_

#include<iostream>

class Product
{
public:

  Product();
  ~Product();
  void ProducePart();

protected:
private:
};

class ProductPart
{
public:

  ProductPart();
  ~ProductPart();
  ProductPart* BuildPart();

protected:
private:
};
#endif //~_PRODUCT_H_

2.Product.cpp

代码如下（示例）：

#include "Product.h"

Product::Product()
{
  ProducePart();
  std::cout << "return a product" << std::endl;
}

Product::~Product()
{
}

void Product::ProducePart()
{
  std::cout << "build part of product.." << std::endl;
}

ProductPart::ProductPart()
{
  std::cout<<"build productpart.."<<std::endl; 
}

ProductPart::~ProductPart()
{
}

ProductPart* ProductPart::BuildPart()
{
  return new ProductPart;
}

3.Builder.h

代码如下（示例）：

#pragma once

#ifndef _BUILDER_H_ 
#define _BUILDER_H_ 

#include <string> 
#include "Product.h"

class Builder
{
public:

  virtual ~Builder();
  virtual void BuildPartA(const std::string& buildPara) = 0;
  virtual void BuildPartB(const std::string& buildPara) = 0;
  virtual void BuildPartC(const std::string& buildPara) = 0;
  virtual Product* GetProduct() = 0;

protected:

  Builder();

private:
};

class ConcreteBuilder :public Builder
{
public:

  ConcreteBuilder();
  ~ConcreteBuilder();
  void BuildPartA(const std::string& buildPara);
  void BuildPartB(const std::string& buildPara);
  void BuildPartC(const std::string& buildPara);
  Product* GetProduct(); 

protected:

private:
};
#endif //~_BUILDER_H_

4.Builder.cpp

代码如下（示例）：

#include "Builder.h"

Builder::Builder()
{
}

Builder::~Builder()
{
}

ConcreteBuilder::ConcreteBuilder()
{
}

ConcreteBuilder::~ConcreteBuilder()
{
}

void ConcreteBuilder::BuildPartA(const std::string& buildPara)
{
  std::cout << "Step1:Build PartA..." << buildPara << std::endl;
}

void ConcreteBuilder::BuildPartB(const std::string& buildPara)
{
  std::cout << "Step1:Build PartB..." << buildPara << std::endl;
}

void ConcreteBuilder::BuildPartC(const std::string& buildPara)
{
  std::cout << "Step1:Build PartC..." << buildPara << std::endl;
}

//具体实现
Product* ConcreteBuilder::GetProduct()
{
  BuildPartA("pre-defined");
  BuildPartB("pre-defined");
  BuildPartC("pre-defined");
  return new Product();
}

5.Director.cpp

代码如下（示例）：

#ifndef _DIRECTOR_H_ 
#define _DIRECTOR_H_ 


#include "Builder.h"
class Director
{
public:

  Director(Builder* bld);
  ~Director();
  void Construct();

protected:
private:
  //采用组合的形式，调用Builder类
  Builder* _bld;
};
#endif //~_DIRECTOR_H_

6.Director.cpp

代码如下（示例）：

#include "Director.h"

Director::Director(Builder* bld)
{
  _bld = bld;
}

Director::~Director()
{

}

void Director::Construct()
{
  _bld->BuildPartA("user-defined");
  _bld->BuildPartB("user-defined");
  _bld->BuildPartC("user-defined");
}

7.main.cpp

代码如下（示例）：

#include "Builder.h" 
#include "Product.h" 
#include "Director.h"
#include <iostream>

int main(int argc, char* argv[])
{
  Director* d = new Director(new ConcreteBuilder());
  d->Construct();
  return 0;
}

---

三、运行结果

Builder 模式运行结果如下：

---

总结

Builder 模式的示例代码中，BuildPart 的参数是通过客户程序员传入的，这里为了简单说明问题，使用“user-defined”代替，实际的可能是在 Construct 方法中传入这 3 个参数，这样就可以得到不同的复杂对象。
Builder 模式和 AbstractFactory 模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder 模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说 Builder 模式中对象不是直接返回的。而在 AbstractFactory 模式中对象是直接返回的，AbstractFa ctory 模式强调的是为创建多个相互依赖的对象提供一个同一的接口。两者侧重不同，需细细品味。

---

本文参考《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》，对内容进行整理，方便大家学习。如想学习详细内容，请参考此书。