Builder（构建器）模式

背景：在软件系统中，有时候面临着一个复杂的对象的创建工作，其通常由各个部分的子对象用一定的算法构成，由于需求的变化，这个复杂的对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
将一个复杂对象的构建和表示分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）。
问题：
当我们要创建的对象很复杂的时候（通常是很多其他的对象组合而来的时候），我们要复杂对象的创建过程和这个对象的表示分离开。由于在每一步的构造过程中可以引入参数，使得经过相同步骤创建最后得到的对象显示结果不一样。
作用：
Builder模式主要用于“分步骤构建一个复杂对象”，其中“分步骤”是一个稳定的算法，复杂对象的各个部分经常变化。
特点：
变化点在哪里，封装在哪里。Builder模式主要应对“复杂对象各个部分”频繁需求变动。
缺点：
难以应对“分步骤构建算法”的需求变动。
注意点：
在不同语言中，需要注意构造器调用虚函数的区别。
构建器CPP代码实现如下
Product.h

#pragma once
class Product {
public:
	Product();
	~Product();
	void ProduceProduct();
};

Product.cpp

#include"Proudct.h"
#include<iostream>
using namespace std;
Product::Product() {
	cout << "Product" << endl;
}
Product::~Product() {

}
void Product::ProduceProduct() {
	cout << "ProduceProduct" << endl;
}

Builder.h

#pragma once
#include<string>
using namespace std;
class Product;
class Builder {
public:
	virtual ~Builder();
	virtual void BuildePartA(const string& str) = 0;
	virtual void BuildePartB(const string& str) = 0;
	virtual void BuildePartC(const string& str) = 0;
	virtual Product* getProduct()=0;
protected:
	Builder();
};
class CreateBuilder :public Builder{
public:
	virtual void BuildePartA(const string& str);
	virtual void BuildePartB(const string& str);
	virtual void BuildePartC(const string& str);
	Product* getProduct();
	CreateBuilder();
	~CreateBuilder();
};

Builder.cpp

#include"Builder.h"
#include"Proudct.h"
#include<iostream>
using namespace std;
Builder::Builder() {

}
Builder::~Builder() {

}
CreateBuilder::CreateBuilder() {

}
CreateBuilder::~CreateBuilder() {

}
Product* CreateBuilder::getProduct() {
	BuildePartA("pre_defined");
	BuildePartB("pre_defined");
	BuildePartC("pre_defined");
	return new Product;
}
void CreateBuilder::BuildePartA(const string& str) {
	cout << "PartA..." << str << endl;
}
void CreateBuilder::BuildePartB(const string& str) {
	cout << "PartB..." << str<<endl;
}
void CreateBuilder::BuildePartC(const string& str) {
	cout << "PartC..." << str << endl;
}

Director.h

#pragma once
class Builder;
class Director {
public:
	Director(Builder* build);
	~Director();
	void construct();
private:
	Builder* build;
};

Director.cpp

#include"Builder.h"
#include"Director.h"
#include<iostream>
using namespace std;
Director::Director(Builder* build) {
	this->build = build;
}
Director::~Director() {

}
void Director::construct() {
	
	build->BuildePartA("users defined");
	build->BuildePartB("users defined");
	build->BuildePartC("users defined");
	build->getProduct();
}

Main.cpp

#include"Builder.h"
#include"Director.h"
#include"Proudct.h"
#include<iostream>
using namespace std;
int main() {
	Director* dirct = new Director(new CreateBuilder());
	dirct->construct();
	return 0;
}

运行结果图