设计模式学习(七)：建造者模式

将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
代码

#include <iostream>
using namespace std;

class Product{ //最终产品
public:
    void show(){cout<<"a:"<<a<<" b:"<<b<<" c:"<<c<<endl;}
    void setPartA(int x){a = x;}
    void setPartB(int y){b = y;}
    void setPartC(int z){c = z;}
private:
    int a,b,c;
};

class Builder{//抽象基类
public:
    virtual void concreate() = 0;
    virtual Product * getPro() = 0;
    virtual void buildPartA() = 0 ;
    virtual void buildPartB() = 0 ;
    virtual void buildPartC() = 0 ;
};

class BuilderA:public Builder{
public:

    void concreate(){
        p = new Product();
    }
    void buildPartA() {
        p->setPartA(1);
    }
    void buildPartB() {
         p->setPartB(2);
    }
    void buildPartC() {
         p->setPartC(3);
    }
    Product * getPro() {
        return p;
    }
private:
    Product * p;
};

class BuilderB:public Builder{
public:

    void concreate(){
        p = new Product();
    }
    void buildPartA() {
        p->setPartA(100);
    }
    void buildPartB() {
         p->setPartB(200);
    }
    void buildPartC() {
         p->setPartC(300);
    }
    Product * getPro() {
        return p;
    }
private:
    Product * p;
};

class Direct{ //导向类
public:
    Direct(Builder * builder):b(builder){}
    void create(){
        b->concreate();
        b->buildPartA();
        b->buildPartB();
        b->buildPartC();
    }


private:
    Builder *b;

};

使用方法

int main() {
    Builder * b = new BuilderA();
    Direct direct(b);
    direct.create();
    Product *p = b->getPro();
    p->show();

    b = new BuilderB();
    Direct direct1(b);
    direct1.create();
    p = b->getPro();
    p->show();

    return 1;
}

结果

a:1 b:2 c:3
a:100 b:200 c:300