C++建造者模式（Builder Pattern）

建造者模式名曰建造者，着重于建造的过程也

需求

1、要造一台电脑
2、电脑有CPU，显卡，主板，内存
2、电脑是是工厂A、工厂B两家厂家，甚至更多的厂家
面对这样的需求，如果使用工厂方法，但仔细分析，工厂方法的着重点会放在电脑的创建上，没有考虑到电脑的CPU、显卡、主板、内存的建造，而建造者模式恰恰能够应付这样的需求

构造者模式意图

1、将复杂对象的创建和表示分离
2、创建过程中可以创建不同的表示方法

构造者参与者

Product(构建的产品)
Builder（构造者，抽象类）
ConcreteBuilder(构造者，具体类)
Director（指挥者，具体类）

UML类图

建造者优缺点

优点

1、实现了建造者的独立，容易扩展
2、独特的体现了建造过程

缺点

十分依赖过程的模式，如果后期建造过程发生改变，不利于扩展。

源代码

下面以建造一台电脑为例，显示源代码

Computer.h

#pragma once

#include <string>

class Computer
{
public:
	Computer();
	~Computer();

	std::string getCPU();
	std::string getGraphicsCard();
	std::string getRAM();
	std::string getMainBoard();

	void setCPU(std::string cpu);
	void setGraphicsCard(std::string graphicsCard);
	void setRAM(std::string ram);
	void setMainBoard(std::string mainBoard);

private:
	std::string m_CPU;//CPU
	std::string m_GraphicsCard;//显卡
	std::string m_RAM;//内存
	std::string m_MainBoard;//主板
};

Computer.cpp

#include "Computer.h"

Computer::Computer()
{
}

Computer::~Computer()
{
}

std::string Computer::getCPU()
{
	return m_CPU;
}

std::string Computer::getGraphicsCard()
{
	return m_GraphicsCard;
}

std::string Computer::getRAM()
{
	return m_RAM;
}

std::string Computer::getMainBoard()
{
	return m_MainBoard;
}

void Computer::setCPU(std::string cpu)
{
	m_CPU = cpu;
}

void Computer::setGraphicsCard(std::string graphicsCard)
{
	m_GraphicsCard = graphicsCard;
}

void Computer::setRAM(std::string ram)
{
	m_RAM = ram;
}

void Computer::setMainBoard(std::string mainBoard)
{
	m_MainBoard = mainBoard;
}

IBuilder.h

#pragma once
#include "Computer.h"

class IBuilder
{
public:
	IBuilder(){};
	virtual ~IBuilder(){};

	virtual void createCPU() = 0;
	virtual void createRAM() = 0;
	virtual void createGraphicsCard() = 0;
	virtual void createMainBoard() = 0;

	virtual Computer* getComputer() = 0;
};

FactoryA.h

#pragma once

#include "IBuilder.h"
#include "Computer.h"

class FactoryA:public IBuilder
{
public:
	FactoryA();
	~FactoryA();
	void createCPU()override;
	void createGraphicsCard()override;
	void createMainBoard()override;
	void createRAM()override;
	Computer* getComputer()override;
private:
	Computer* m_Computer;
};

FactoryA.cpp

```cpp
#include "FactoryA.h"


FactoryA::FactoryA()
	:m_Computer(new Computer)
{
}

FactoryA::~FactoryA()
{
	if (!m_Computer)
	{
		delete m_Computer;
		m_Computer = nullptr;
	}
}

void FactoryA::createCPU()
{
	m_Computer->setCPU("The A factory of CPU");
}

void FactoryA::createGraphicsCard()
{
	m_Computer->setGraphicsCard("The A factory of graphics card");
}

void FactoryA::createMainBoard()
{
	m_Computer->setMainBoard("The A factory of main board");
}

void FactoryA::createRAM()
{
	m_Computer->setRAM("The A factory of RAM");
}

Computer* FactoryA::getComputer()
{
	return m_Computer;
}

FactoryB.h

#pragma once

#include "IBuilder.h"
#include "Computer.h"

class FactoryB :public IBuilder
{
public:
	FactoryB();
	~FactoryB();

	void createCPU()override;
	void createGraphicsCard()override;
	void createMainBoard()override;
	void createRAM()override;
	Computer* getComputer()override;
private:
	Computer* m_Computer;
};

FactoryB.cpp

#include "FactoryB.h"

FactoryB::FactoryB()
	:m_Computer(new Computer)
{
}

FactoryB::~FactoryB()
{
}

void FactoryB::createCPU()
{
	m_Computer->setCPU("The B factory of CPU");
}

void FactoryB::createGraphicsCard()
{
	m_Computer->setGraphicsCard("The B factory of graphics card");
}

void FactoryB::createMainBoard()
{
	m_Computer->setMainBoard("The B factory of graphics card");
}

void FactoryB::createRAM()
{
	m_Computer->setRAM("The B factory of RAM");
}

Computer* FactoryB::getComputer()
{
	return m_Computer;
}

void FactoryB::createComputer()
{
	//如果建造方法一样，还可以放进IBuiler类中
	createCPU();
	createGraphicsCard();
	createMainBoard();
	createRAM();
}

Director.h

#pragma once

#include "IBuilder.h"

class Director
{
public:
	Director();
	~Director();
	IBuilder* createComputer(IBuilder* factory);
};

Director.cpp

#include "Director.h"


Director::Director()
{
}


Director::~Director()
{
}

IBuilder* Director::createComputer(IBuilder* factory)
{
	factory->createCPU();
	factory->createGraphicsCard();
	factory->createMainBoard();
	factory->createRAM();
	return factory;
}

main.cpp

#include <iostream>
#include "FactoryA.h"
#include "Director.h"

#ifndef SafeDelete
#define SafeDelete(p) {if(p){delete(p);(p)=nullptr;}}
#endif

int main(int argc, char* argv[])
{
	IBuilder* factoryA = new FactoryA;
	Director* director = new Director;
	director->createComputer(factoryA);
	Computer* computer = factoryA->getComputer();

	std::cout << computer->getCPU() << std::endl;
	std::cout << computer->getGraphicsCard() << std::endl;
	std::cout << computer->getMainBoard() << std::endl;
	std::cout << computer->getRAM() << std::endl;

	SafeDelete(director);
	SafeDelete(factoryA);

	system("pause");
	return 0;
}

本人不才，希望各位多多指点，在此谢谢读到此处的你。

欢迎大家评论下方留言，相互交流