建造者模式名曰建造者,着重于建造的过程也
需求
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
#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;
}