builder模式实例

点击打开 builder模式解析

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <memory>

//产品抽象类
class Product{
public:
	virtual void AddPart(const std::string& str) = 0;
	virtual ~Product() = 0;
public:
	virtual void DoAction() const = 0;
};
Product::~Product(){}

//产品实例类
class ConcreteProductA : public Product{
public:
	ConcreteProductA();
	virtual ~ConcreteProductA() override;
public:
	virtual void AddPart(const std::string& str) override;
	virtual void DoAction() const override;
private:
	std::vector<std::string> _strs;
};
ConcreteProductA::ConcreteProductA() : _strs(std::vector<std::string>()){}
ConcreteProductA::~ConcreteProductA(){
	std::cout << "~ConcreteProductA()" << std::endl;
}
void ConcreteProductA::AddPart(const std::string& str){
	_strs.push_back(str);
}
void ConcreteProductA::DoAction() const{
	std::for_each(_strs.cbegin(), _strs.cend(), [](const std::string& str)
	{
		std::cout << str << "->";
	});
	std::cout << std::endl;
}

//产品实例类
class ConcreteProductB : public Product{
public:
	ConcreteProductB();
	virtual ~ConcreteProductB() override;
	virtual void AddPart(const std::string& str) override;
	virtual void DoAction() const override;
private:
	std::list<std::string> _strs;
};
ConcreteProductB::ConcreteProductB() : _strs(std::list<std::string>()){}
ConcreteProductB::~ConcreteProductB(){
	std::cout << "~ConcreteProductB" << std::endl;
}
void ConcreteProductB::AddPart(const std::string& str){
	_strs.push_back(str);
}
void ConcreteProductB::DoAction() const{
	std::for_each(_strs.cbegin(), _strs.cend(), [](const std::string& str)
    {   
        std::cout << str << "<>";
    });
	std::cout << std::endl;
}
//构建抽象类
class Builder{
public:
	Builder(Product* product);
	virtual ~Builder() = 0;
public:
	virtual Product* GetProduct() = 0;
	virtual void BuildPart1() = 0;
	virtual void BuildPart2() = 0;
	virtual void BuildPart3() = 0;
protected:
	Product* _product;
};
Builder::Builder(Product* product) : _product(product){}
Builder::~Builder(){}

//构建实例类
class ConcreteBuilderA : public Builder{
public:
	ConcreteBuilderA();
	virtual ~ConcreteBuilderA();
public:
	virtual Product* GetProduct() override;
	virtual void BuildPart1() override;
    virtual void BuildPart2() override;
    virtual void BuildPart3() override;
};
ConcreteBuilderA::ConcreteBuilderA() : Builder(new ConcreteProductA()){}
ConcreteBuilderA::~ConcreteBuilderA(){}
void ConcreteBuilderA::BuildPart1(){
	_product->AddPart(std::string("A1"));
}
void ConcreteBuilderA::BuildPart2(){
	_product->AddPart(std::string("A2"));
}
void ConcreteBuilderA::BuildPart3(){
	_product->AddPart(std::string("A3"));
}
Product* ConcreteBuilderA::GetProduct(){
	return _product;
}

class ConcreteBuilderB : public Builder{
public:
	ConcreteBuilderB();
	~ConcreteBuilderB();
public:
	virtual Product* GetProduct() override;
    virtual void BuildPart1() override;
    virtual void BuildPart2() override;
    virtual void BuildPart3() override;
};
ConcreteBuilderB::ConcreteBuilderB() : Builder(new ConcreteProductB()){}
ConcreteBuilderB::~ConcreteBuilderB(){}
void ConcreteBuilderB::BuildPart1(){
    _product->AddPart("B1");
}
void ConcreteBuilderB::BuildPart2(){
    _product->AddPart("B2");
}
void ConcreteBuilderB::BuildPart3(){
    _product->AddPart("B3");
}
Product* ConcreteBuilderB::GetProduct(){
    return _product;
}
//导向器
class Direction{
public:
	Product* ConstructProduct1(Builder& builder); //构造只含有部分1的产品
	Product* ConstructProduct12(Builder& builder); //构造只含有部分1,2的产品
	Product* ConstructProduct13(Builder& builder); //构造只含有部分1,3的产品
};
Product* Direction::ConstructProduct1(Builder& builder){
	builder.BuildPart1();
	return builder.GetProduct();
}
Product* Direction::ConstructProduct12(Builder& builder){
	builder.BuildPart1();
	builder.BuildPart2();
	return builder.GetProduct();
}
Product* Direction::ConstructProduct13(Builder& builder){
	builder.BuildPart1();
	builder.BuildPart3();
	return builder.GetProduct();
}

int main()
{
	//构建只有1部分的产品A
	ConcreteBuilderA builder1;
	std::shared_ptr<Product> product1(Direction().ConstructProduct13(builder1));
	product1->DoAction();
	//构建只有13部分的产品A
	ConcreteBuilderA builder2;
	std::shared_ptr<Product> product2(Direction().ConstructProduct13(builder2));
	product2->DoAction();
	//构建只有12部分的产品B
	ConcreteBuilderB builder3;
	std::shared_ptr<Product> product3(Direction().ConstructProduct12(builder3));
	product3->DoAction();
}