建造者模式-设计模式coding

• 适用于：复杂对象的构造，将对象的构建和对象的表示进行分离，解耦合

• 对象的表示：产品类Product

• 对象的构建：建造者Builder

• 客户端：设计师Director

• 核心思路：House、Builder、Director对象的类的抽象

#include <iostream>
#include "string"

using namespace std;
class House
{
public:
    void setDoor(string door)
    {
        this->m_door = door;
    }
    void setWindow(string door)
    {
        this->m_window = door;
    }
    void setWall(string door)
    {
        this->m_wall = door;
    }
    //-----------
    string getDoor( )
    {
        return m_door;
    }
    string getWindow( )
    {
        return m_window;
    }
    string getWall()
    {
        return m_wall;
    }
private:
    string m_door;
    string m_window;
    string m_wall;
};

class Builder
{
public:
    virtual void makeDoor() = 0;
    virtual void makeWall() = 0;
    virtual void makeWindow() = 0;
    virtual House* getHouse() = 0;

};

class FlatBuilder: public Builder
{
public:
    FlatBuilder()
    {
        pHouse = new House;
    }
    virtual void makeDoor()
    {
        pHouse->setDoor("FlatDoor");
    }
    virtual void makeWall()
    {
        pHouse->setWall("FlatWall");
    }
    virtual void makeWindow()
    {
        pHouse->setWindow("FlatWindow");
    }
    virtual House* getHouse()
    {
        return pHouse;
    }
private:
    House* pHouse;
};

class Director
{
public:
    void Construct(Builder* builder)
    {
        builder->makeDoor();
        builder->makeWall();
        builder->makeWindow();}
};


int main()
{
    House* house = nullptr;
    Builder* builder = nullptr;
    
    builder = new FlatBuilder;
    Director* dir = new Director;
    dir->Construct(builder);
    house = builder->getHouse();
    cout << house->getWall() << endl;

    delete house;
    delete builder;
    delete dir;

    std::cout << "Hello World!\n";
}