建造者模式Builder（c++设计模式）

建造者模式就是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可

模式优点

• 客户端不必知道产品内部组成细节，将产品本身与创建过程解耦，使相同的创建国产可以创建不同的产品对象
• 对于替换和增加新的具体建造者符合开闭原则
• 可以精细地控制产品创建过程
• 特点：高内聚低耦合

模式缺点

• 产品之间的差异性很大不适合用建造者模式
• 产品内部变化复杂的话会需要定义很多具体建造者类，导致系统开销大

适用环境

• 需要生成的产品有复杂的内部结构
• 需要生成的产品对象的属性相互依赖
• 对象的创建过程独立于创建该对象的类
• 隔离复杂对象的创建和使用

建造者模式代码

/*
 * @ Description: C++ Design Patterns___Builder
 * @ version: v1.0
 * @ Author: WeissxJ
 */
#include<iostream>
#include<string>

class Product
{
    
    
    private:
        std::string partA;
        std::string partB;
        std::string partC;
    public:
        void makeA(const std::string &part){
    
    
            partA=part;
        }
        void makeB(const std::string &part){
    
    
            partB=part;
        }
        void makeC(const std::string &part){
    
    
            partC=part;
        }
        std::string get(){
    
    
            return (partA+" "+partB+" "+partC);
        }
        // ...
};

class Builder
{
    
    
    protected:
        Product product;
    public:
        virtual ~Builder() {
    
    }

        Product get(){
    
    
            return product;
        }
        virtual void buildPartA()=0;
        virtual void buildPartB()=0;
        virtual void buildPartC()=0;
        // ...
};

class ConcretBuilderX : public Builder
{
    
    
    public:
        void buildPartA(){
    
    
            product.makeA("A-X");
        }
        void buildPartB(){
    
    
            product.makeB("B-X");
        }
        void buildPartC(){
    
    
            product.makeC("C-X");
        }
        // ...
};

class ConcretBuilderY : public Builder
{
    
    
    public:
        void buildPartA(){
    
    
            product.makeA("A-Y");
        }
        void buildPartB(){
    
    
            product.makeB("B-Y");
        }
        void buildPartC(){
    
    
            product.makeC("C-Y");
        }
        // ...
};

class Director
{
    
    
    private:
        Builder* builder;
    public:
        Director():builder() {
    
    }
        ~Director(){
    
    
            if(builder)
                delete builder;
        }
        void set(Builder* b){
    
    
            if(builder){
    
    
                delete builder;
            }
            builder=b;
        }
        Product get(){
    
    
            return builder->get();
        }
        void construct(){
    
    
            builder->buildPartA();
            builder->buildPartB();
            builder->buildPartC();
            // ...
        }
        // ...
};

int main(){
    
    
    Director director;
    director.set(new ConcretBuilderX);
    director.construct();

    Product product1=director.get();
    std::cout<<"1st product parts: "<<product1.get()<<std::endl;

    director.set(new ConcretBuilderY);
    director.construct();

    Product product2=director.get();
    std::cout<<"2nd product parts: "<<product2.get()<<std::endl;
    return 0;
}