设计模式-------创建型模式（builder）

想学好一门知识或者技术，首先选好书（一定且必须）

菜鸟教程一直是多方面的多入门的网站，内容很多很强大https://www.runoob.com/?s=%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F

《设计模式C++》这本书简洁明了，并且提供了C++版本实现的代码

本博客由以上两方融合而成

本博客由以上两方融合而成

本博客由以上两方融合而成

建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

 

 

 

 

//Builder.h
#ifndef _BUILDER_H_
#define _BUILDER_H_
#include <string>
#include<iostream>
using namespace std;
class Dog
{
public:
	virtual void show() = 0;
};
class aDog
{
public:
	void show();

	string m_head;
	string m_teet;
	string m_leg;
};

class Builder
{
public:
	
	virtual string BuildPartA(const string& buildPara) = 0;
	virtual string BuildPartB(const string& buildPara) = 0;
	virtual string BuildPartC(const string& buildPara) = 0;
	
private:
};
class ConcreteBuilder: public Builder
{
public:
	ConcreteBuilder();
	~ConcreteBuilder();
	string BuildPartA(const string& buildPara);
	string BuildPartB(const string& buildPara);
	string BuildPartC(const string& buildPara);
private:
};
class ConcreteBuilderFat
{
public:
	ConcreteBuilderFat();
	~ConcreteBuilderFat();
	string BuildPartA(const string& buildPara);
	string BuildPartB(const string& buildPara);
	string BuildPartC(const string& buildPara);
private:
};
class Director
{
public:
	Director(Builder* bld);
	~Director();
	void Construct(aDog& adog);
protected:
private:
	Builder* _bld;
};
#endif //~_BUILDER_H_

#include "builder.h"

void  aDog::show()
{
	std::cout << m_leg << m_teet << m_head << std::endl;
}

ConcreteBuilder::ConcreteBuilder()
{
}

ConcreteBuilder::~ConcreteBuilder()
{
}

string ConcreteBuilder::BuildPartA(const string & buildPara)
{
	cout << buildPara << endl;
	return buildPara;
}

string ConcreteBuilder::BuildPartB(const string & buildPara)
{
	cout << buildPara << endl;
	return buildPara;
}

string ConcreteBuilder::BuildPartC(const string & buildPara)
{
	cout << buildPara << endl;
	return buildPara;
}

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

Director::~Director()
{
}

void Director::Construct(aDog &adog)
{
	string string1("A");
	string string2("B");
	string string3("C");
	adog.m_teet = _bld->BuildPartA(string1);
	adog.m_head = _bld->BuildPartB(string2);
	adog.m_leg = _bld->BuildPartC(string3);
}

ConcreteBuilderFat::ConcreteBuilderFat()
{
}

ConcreteBuilderFat::~ConcreteBuilderFat()
{
}

string ConcreteBuilderFat::BuildPartA(const string & buildPara)
{
	cout << buildPara << endl;
	return buildPara;
}

string ConcreteBuilderFat::BuildPartB(const string & buildPara)
{
	cout << buildPara << endl;
	return buildPara;
}

string ConcreteBuilderFat::BuildPartC(const string & buildPara)
{
	cout << buildPara << endl;
	return buildPara;
}

void bldEr()
{
	Builder *ptr = new ConcreteBuilder();
	Director myD(ptr);
	aDog zhujianrong;//某个二房东
	myD.Construct(zhujianrong);
	zhujianrong.show();
}

没有找到权威准确的类图，

从个人理解来看，对象（subject）的细节实现应该由direct 来调度处理，这样统一方便，他可以通过抽象类指针，选择合适的生成器