#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();
}
builder模式实例
最新推荐文章于 2024-01-12 16:13:50 发布