【C++设计模式】建造者模式

建造者模式

概念

Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。

Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法

适用情况

一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离。

重构的视角下理解建造者模式

不采用构造模式下的代码

类图

代码

房子

class House {
public:
    // 建造房间的各个部分
    void setDoor(string door) {
        this->m_door = door;
    }

    void setWall(string wall) {
        this->m_wall = wall;
    }

    void setWindow(string window) {
        this->m_window = window;
    }

    // 展示房间的每个部分
    string getDoor() {
        return this->m_door;
    }
    string getWall() {
        return this->m_wall;
    }
    string getWindow() {
        return m_window;
    }

private:
    string m_door;
    string m_wall;
    string m_window;
};

建造者

class Build {
public:
    Build() {
        m_house = new House;
    }
    // 建造房间
    void makeBuild() {
        buildDoor(m_house);
        buildWall(m_house);
        buildWindow(m_house);
    }

    // 建造房间的每个部分
    void buildDoor(House *h) {
        h->setDoor("门1");
    }
    void buildWall(House *h) {
        h->setWall("墙1");
    }
    void buildWindow(House *h) {
        h->setWindow("窗1");
    }

    // 获取房间
    House *getHouse() {
        return m_house;
    }

private:
    House *m_house;
};

调用

// 客户直接造房子
House *house = new House;
house->setDoor("门");
house->setWall("墙面");
house->setWindow("窗口");
delete house;


//通过建造者建造房子
House *house = nullptr;
// 1. 创建建造者
Build *build = new Build;
// 通过建造者建造房子
build->makeBuild();
// 返回建造者创建的房子
house = build->getHouse();
// 展示房子的每个部分
cout << house->getDoor() << endl;
cout << house->getWall() << endl;
cout << house->getWindow() << endl;

// 释放内存
if (nullptr == house) {
	delete house;
	house = nullptr;
}
if (nullptr == build) {
	delete build;
	house = nullptr;
}

构造模式下的代码

类图

代码

房子 House

class House{
public:
    // 建造房子的每个部分
	void setDoor(string door){
		this->m_door = door;
	}

	void setWall(string wall){
		this->m_wall = wall;
	}
	void setWindow(string window){
		this->m_window = window;
	}

	// 展示房子的每个部分
	string getDoor( ){
		cout << m_door << endl;
		return this->m_door ;
	}
	string getWall(){
		cout << m_wall << endl;
		return this->m_wall;
	}
	string getWindow(){
		cout << m_window << endl;
		return m_window;
	}
private:
	string	m_door;
	string	m_wall;
	string	m_window;
};

抽象建造者 Builder

// 抽象的建造者
class  Builder{
public:
	virtual void buildWall() = 0;
	virtual void buildDoor() = 0;
	virtual void buildWindow() = 0;
	virtual House* getHouse() = 0;
};

具体建造者

公寓工程队

//公寓工程队
class  FlatBuilder : public Builder{
public:
	FlatBuilder(){
		m_house = new House;
	}
	virtual void buildWall(){
		m_house->setWall(" flat wall");
	}

	virtual void buildDoor(){
		m_house->setDoor("flat door");
	}

	virtual void buildWindow(){
		m_house->setWindow("flat window");
	}

	virtual House* getHouse(){
		return m_house;
	}
private:
	House *m_house;
};

别墅 villa工程队

//别墅villa工程队
class  VillaBuilder : public Builder{
public:
	VillaBuilder(){
		m_house = new House;
	}
	virtual void buildWall(){
		m_house->setWall(" villa wall");
	}

	virtual void buildDoor(){
		m_house->setDoor("villa door");
	}

	virtual void buildWindow(){
		m_house->setWindow("villa window");
	}

	virtual House* getHouse(){
		return m_house;
	}
private:
	House *m_house;
};

设计师 Director

//设计师(指挥者) 负责建造逻辑  
//建筑队 干具体的活
class Director{
public:
	Director( Builder * build){
		m_build = build;
	}

	// 建造房子的具体逻辑
	void Construct(){
		m_build->buildWall();
		m_build->buildWindow();
		m_build->buildDoor();
	}
private:
	 Builder * m_build;
};

调用

House *house  = nullptr;
Builder *builder = nullptr;
Director *director = nullptr;

// 1. 创造一个工程队
builder = new VillaBuilder;  // 变化点
builder = new FlatBuilder;  // 创建不同的工程队会建造出不同的房子

// 2. 创造一个设计师
director = new Director(builder);  // 将建造者传递给设计师
// 3. 设计师指挥通过工程队制造房子
director->Construct();  // 具体的建造逻辑
// 4. 设计师交付房子
house  =  builder->getHouse();
// 5. 展示房子
house->getWindow();
house->getDoor();

// 6. 释放内存
if (nullptr == house){
	delete house;
	house == nullptr;
}
if (nullptr == builder){
	delete builder;
	builder == nullptr;
}
if (nullptr == director){
    delete director;
    director == nullptr;
}