C++设计模式13——建造者（Bulider）模式

1. 建造者（Bulider）模式介绍

定义：
指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

应用实例： =去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

关键代码：建造者：创建和提供实例，指挥者：管理建造出来的实例的依赖关系。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

模式的结构：

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个滅部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

类图：

2. 为了方便理解，举个例子

把车的属性，和车的组装分离，然后对不同种类的车进行建造

#include 
#include 
using namespace std;

//car属性类
class Car {
  public:
    void setEngine(string engine) {
        m_Engine = engine;
    }
    void setWheel(string wheel) {
        m_Wheel = wheel;
    }
    void setBody(string body) {
        m_Body = body;
    }
    void disPlay() { 
        cout<<"engine is : "<<this->m_Engine<<endl;
        cout<<"wheel is : "<<this->m_Wheel<<endl;
        cout<<"body is : "<<this->m_Body<<endl;
    }
  private:
    string  m_Engine;
    string  m_Wheel;
    string  m_Body;
};
//建造者模式抽象类，组装流程
class Assemble {
  public:
    virtual void assembleEngine() {};
    virtual void assembleWheel() {};
    virtual void assembleBody() {};
    virtual Car* getCar() {
        return nullptr;
    };
};
//a型车组装流程
class AssembleCarA : public Assemble {
  public:
    AssembleCarA() {
        _carA = new Car();
    }
    virtual void assembleEngine( ) {
        _carA->setEngine("engineA");
    };
    virtual void assembleWheel( ) {
        _carA->setWheel("whellA");
    }
    virtual void assembleBody( ) {
        _carA->setBody("bodyA");
    };
    virtual Car* getCar() {
        return _carA;
    }
  private:
    Car *_carA;
};
//b型车组装流程
class AssembleCarB : public Assemble {
  public:
    AssembleCarB() {
        _carB = new Car();
    }
    virtual void assembleEngine( ) {
        _carB->setEngine("engineB");
    };
    virtual void assembleWheel( ) {
        _carB->setWheel("wheelB");
    }
    virtual void assembleBody( ) {
        _carB->setBody("bodyB");
    };
    virtual Car* getCar() {
        return _carB;
    }
  private:
    Car *_carB;
};
//工厂类
class Factory {
  public:
    Factory(Assemble* assemble) {
        m_assemble = assemble;
    }
    void assembleCar() {
        m_assemble->assembleEngine();
        m_assemble->assembleWheel();
        m_assemble->assembleBody();
    }
    Car* getCar() {
        return m_assemble->getCar();
    }
  private:
    Assemble* m_assemble;
};
int main() {
    Assemble *m_assemble = new AssembleCarA();
    Factory *m_factory = new Factory(m_assemble);
    m_factory->assembleCar();
    m_factory->getCar()->disPlay();
    return 0;
}

3. 建造者（Bulider）模式优缺点

主要优点如下：

1. 各个具体的建造者相互独立，有利于系统的扩展。
2. 客户端不必知道产品内部组成的细节，便于控制细节风险。

其缺点如下：

1. 产品的组成部分必须相同，这限制了其使用范围。
2. 如果产品的内部变化复杂，该模式会增加很多的建造者类。