设计模式——9.建造者模式

建造者模式（Builder）

Builder模式简介：

将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定部分）可以创建不同的表示（变化）。

Builder模式结构：

Builder模式要点：

• Builder模式主要用于分步骤构建一个复杂对象，其中的构建步骤是稳定的，而负责对象的各个部分则经常变化。

• 要注意不同语言例如C++、C#中构造函数内调用虚函数机制的差别。

C++代码

具体产品类Product：

#pragma once
#include<string>
#include<iostream>
using namespace std;

class Product
{
public:
	Product();
	virtual ~Product();
	void setPartA(string pA);
	void setPartB(string pB);
	void setPartC(string pC);
	void echo();

private:
	string m_pA;
	string m_pB;
	string m_pC;
};

//file: Product.cpp
#include "pch.h"
#include "Product.h"

Product::Product() {}

Product::~Product() {}

void Product::setPartA(string pA)
{
	m_pA = pA;
}

void Product::setPartB(string pB)
{
	m_pB = pB;
}

void Product::setPartC(string pC)
{
	m_pC = pC;
}

void Product::echo()
{
	cout << "The Product's PartA name : " <<m_pA << " , PartB name : " << m_pB << " , PartC name : " << m_pC << " ." << endl;
}

创建具体产品各个部分的接口类Builder以及其具体实现类：

//file: Builder.h
#pragma once
#include "Product.h"
class Builder
{
public:
	Builder();
	virtual ~Builder();
	virtual void buildPartA() =0;
	virtual void buildPartB() = 0;
	virtual void buildPartC() = 0;
	virtual Product* getProduct();

protected:
	Product* m_prod;
};

class ConcreteBuilder1 : public Builder
{
public:
	ConcreteBuilder1();
	virtual ~ConcreteBuilder1();
	virtual void buildPartA();
	virtual void buildPartB();
	virtual void buildPartC();
};

//file: Builder.cpp
#include "pch.h"
#include "Builder.h"

Builder::Builder() 
{
	m_prod = new Product();
}

Builder::~Builder() {}

Product* Builder::getProduct()
{
	return m_prod;
}

ConcreteBuilder1::ConcreteBuilder1() {}

ConcreteBuilder1::~ConcreteBuilder1() {}

void ConcreteBuilder1::buildPartA()
{
	m_prod->setPartA("PartA 1");
}

void ConcreteBuilder1::buildPartB()
{
	m_prod->setPartB("PartB 1");
}

void ConcreteBuilder1::buildPartC()
{
	m_prod->setPartC("PartC 1");
}

Director指挥者类：

//Director.h
#pragma once
#include "Builder.h"
class Director
{
public:
	Director();
	virtual ~Director();
	void setBuilder(Builder* pB);
	Product* construct();
protected:
	Builder* m_builder;
};

//file:Director.cpp
#include "pch.h"
#include "Director.h"

Director::Director() {}

Director::~Director() {}

void Director::setBuilder(Builder* pB)
{
	m_builder = pB;
}

Product* Director::construct()
{
	m_builder->buildPartA();
	m_builder->buildPartB();
	m_builder->buildPartC();
	return m_builder->getProduct();
}

客户端实例代码：

// BuilderPattern.cpp : This file contains the 'main' function. Program execution begins and ends there.
#include "pch.h"
#include <iostream>
#include "Director.h"

int main()
{
	Builder* builder1 = new ConcreteBuilder1();
	Director* director = new Director();
	director->setBuilder(builder1);
	Product* p1 = director->construct();
	p1->echo();

	delete p1, builder1 ,director;
	return 0;
}

输出实例：

C#代码

具体产品类Product：

public class Product
{
	public string PartA { get; set; }
	public string PartB { get; set; }
	public string PartC { get; set; }

	public void Echo()
	{
		Console.WriteLine("The Product's PartA name :{0} , PartB name : {1} , PartC name : {2} .",PartA,PartB,PartC);
	}
}

创建具体产品各个部分的接口类Builder以及其具体实现类：

public abstract class Builder
{
	public Builder()
	{
		product = new Product();
	}

	public abstract void BuildPartA();
	public abstract void BuildPartB();
	public abstract void BuildPartC();

	public virtual Product GetProduct()
	{
		return product;
	}

	protected Product product;
}

public class ConcreteBuilder1 : Builder
{
	public override void BuildPartA()
	{
		product.PartA = "PartA 1";
	}

	public override void BuildPartB()
	{
		product.PartB = "PartB 1";
	}

	public override void BuildPartC()
	{
		product.PartC = "PartC 1";
	}
}

public class ConcreteBuilder2 : Builder
{
	public override void BuildPartA()
	{
		product.PartA = "PartA 2";
	}

	public override void BuildPartB()
	{
		product.PartB = "PartB 2";
	}

	public override void BuildPartC()
	{
		product.PartC = "PartC 2";
	}
}

Director指挥者类：

public class Director
{
	Builder builder;

	public Director() { }

	public Director(Builder pBuilder)
	{
		builder = pBuilder;
	}

	public void SetBuilder(Builder pBuilder)
	{
		builder = pBuilder;
	}

	public Product Construct()
	{
		builder.BuildPartA();
		builder.BuildPartB();
		builder.BuildPartC();
		return builder.GetProduct();
	}
}

客户端实例代码：

class Program
{
	static void Main(string[] args)
	{
		Builder builder1 = new ConcreteBuilder1();
		Director director = new Director(builder1);
		Product p1 = director.Construct();
		p1.Echo();

		Builder builder2 = new ConcreteBuilder2();
		director.SetBuilder(builder2);
		Product p2 = director.Construct();
		p2.Echo();

		Console.ReadKey();
	}
}

实例输出：

REF

书籍：

设计模式与游戏开发、大话设计模式

GitHub：

https://github.com/me115/design_patterns