【设计模式】——建造者模式（Builder Pattern）

目录

引言

一、建造者模式的基本概念

核心思想

建造者模式的结构

UML图

应用场景

二、建造者模式的优点与缺点

优点

缺点

三、C++ 实现建造者模式

产品类（Bike）

抽象建造者类（Builder）

具体建造者类（ConcreteBuilder）

指挥者类（Director）

客户端代码

总代码

四、总结

---

引言

在软件开发中，设计模式是解决特定问题的最佳实践。建造者模式（Builder Pattern）是创建型设计模式的一种，主要用于构建复杂对象。它通过将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建出具有不同表示的对象。本文将详细介绍建造者模式的基本概念、原理，并通过C++代码示例来展示如何实现这一模式。

一、建造者模式的基本概念

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式允许用户通过指定复杂对象的类型和内容来构建它们，而无需知道对象内部的具体构建细节。

核心思想

建造者模式的核心思想是将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建出不同的表示。它允许用户通过指定复杂对象的类型和内容来构建它们，而无需知道对象内部的具体构建细节。建造者模式隐藏了复杂对象的创建细节，通过一步一步构建一个复杂的对象，使得构建过程更加清晰和易于控制。

建造者模式的结构

1. 产品类（Product）：表示要构建的复杂对象。
2. 抽象建造者类（Builder）：定义构建复杂对象的接口，但不具体实现这些接口。
3. 具体建造者类（ConcreteBuilder）：具体实现抽象建造者接口，负责复杂对象的各个部件的具体创建和装配。
4. 指挥者类（Director）：负责构建过程的指导，它不涉及具体产品的信息，只保证对象各部分按某种顺序完整创建。

UML图

应用场景

建造者模式适用于以下场景：

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
• 当构造过程必须允许被构造的对象有不同的表示时。
• 当需要构造的对象具有较多的组成部分，这些部分经常面临着复杂的变化，但构造过程（包括部件的创建和装配）在多数情况下比较稳定时。

二、建造者模式的优点与缺点

优点

1. 封装性好：将复杂对象的创建过程封装在建造者类中，客户端不需要知道对象创建的细节。
2. 扩展性好：当需要增加新的部件或修改构建算法时，只需修改或增加具体的建造者类，不需要修改指挥者类和其他客户端代码。
3. 灵活性高：可以通过不同的具体建造者类来创建不同的产品，实现了构建和表示的分离。
4. 易于控制构建过程：通过指挥者类可以很容易地控制构建过程，可以很方便地添加或删除构建步骤。

缺点

1. 设计复杂：对于简单的对象，如果采用建造者模式，可能会增加设计的复杂性，因为需要定义多个类（抽象建造者、具体建造者、指挥者等）。
2. 增加类的数量：使用建造者模式会增加类的数量，这可能会使项目的结构变得复杂。
3. 不易于理解：对于不熟悉建造者模式的开发者来说，理解其内部结构和原理可能需要一定的时间。

三、C++ 实现建造者模式

以下是一个使用C++实现的建造者模式示例，我们以构建一辆自行车为例，自行车由车架和车座等部件组成。

产品类（Bike）

首先定义自行车产品类，包含车架和车座等属性。

// 产品类
class Bike {
private:
    std::string frame;
    std::string seat;

public:
    void setFrame(const std::string& frame) {
        this->frame = frame;
    }

    void setSeat(const std::string& seat) {
        this->seat = seat;
    }

    std::string getFrame() const {
        return frame;
    }

    std::string getSeat() const {
        return seat;
    }

    void display() const {
        std::cout << "车架: " << frame << std::endl;
        std::cout << "车座: " << seat << std::endl;
    }
}

抽象建造者类（Builder）

定义抽象建造者接口，定义创建自行车部件的方法。

// 抽象建造者类
class Builder {
public:
    virtual void buildFrame(const std::string& frame) = 0;
    virtual void buildSeat(const std::string& seat) = 0;
    virtual Bike* getBike() = 0;
    virtual ~Builder() {}
};

具体建造者类（ConcreteBuilder）

具体实现建造者接口，为不同类型的自行车创建部件。

// 具体建造者类
class HelloBuilder : public Builder {
private:
    Bike* bike;

public:
    HelloBuilder() : bike(new Bike()) {}

    void buildFrame(const std::string& frame) override {
        bike->setFrame("碳纤维车架");
    }

    void buildSeat(const std::string& seat) override {
        bike->setSeat("橡胶车座");
    }

    Bike* getBike() override {
        return bike;
    }
};


class MobikeBuilder : public Builder {
private:
    Bike* bike;

public:
    MobikeBuilder() : bike(new Bike()) {}

    void buildFrame(const std::string& frame) override {
        bike->setFrame("铝合金车架");
    }

    void buildSeat(const std::string& seat) override {
        bike->setSeat("真皮车座");
    }

    Bike* getBike() override {
        return bike;
    }
};

指挥者类（Director）

定义指挥者类，负责调用具体建造者来创建自行车。

// 指挥者类
class Director {
private:
    Builder* builder;

public:
    Director(Builder* builder) : builder(builder) {}

    Bike* construct() {
        builder->buildFrame("默认车架"); // 可以在这里设置默认参数，或者从外部传入  
        builder->buildSeat("默认车座");
        return builder->getBike();
    }
};

客户端代码

最后，客户端代码使用建造者模式来创建不同类型的自行车。

int main() {
    HelloBuilder helloBuilder;
    Director director(&helloBuilder);
    Bike* helloBike = director.construct();
    helloBike->display(); // 显示 HelloBuilder 构建的自行车  

    MobikeBuilder mobikeBuilder;
    Director mobikeDirector(&mobikeBuilder);
    Bike* mobike = mobikeDirector.construct();

    mobike->display(); // 显示 MobikeBuilder 构建的自行车  

    // 清理资源  
    delete helloBike;
    delete mobike;

    return 0;
}

总代码

#include <string>  
#include <iostream>  

// 产品类
class Bike {
private:
    std::string frame;
    std::string seat;

public:
    void setFrame(const std::string& frame) {
        this->frame = frame;
    }

    void setSeat(const std::string& seat) {
        this->seat = seat;
    }

    std::string getFrame() const {
        return frame;
    }

    std::string getSeat() const {
        return seat;
    }

    void display() const {
        std::cout << "车架: " << frame << std::endl;
        std::cout << "车座: " << seat << std::endl;
    }
};

// 抽象建造者类
class Builder {
public:
    virtual void buildFrame(const std::string& frame) = 0;
    virtual void buildSeat(const std::string& seat) = 0;
    virtual Bike* getBike() = 0;
    virtual ~Builder() {}
};

// 具体建造者类
class HelloBuilder : public Builder {
private:
    Bike* bike;

public:
    HelloBuilder() : bike(new Bike()) {}

    void buildFrame(const std::string& frame) override {
        bike->setFrame("碳纤维车架");
    }

    void buildSeat(const std::string& seat) override {
        bike->setSeat("橡胶车座");
    }

    Bike* getBike() override {
        return bike;
    }
};

class MobikeBuilder : public Builder {
private:
    Bike* bike;

public:
    MobikeBuilder() : bike(new Bike()) {}

    void buildFrame(const std::string& frame) override {
        bike->setFrame("铝合金车架");
    }

    void buildSeat(const std::string& seat) override {
        bike->setSeat("真皮车座");
    }

    Bike* getBike() override {
        return bike;
    }
};

// 指挥者类
class Director {
private:
    Builder* builder;

public:
    Director(Builder* builder) : builder(builder) {}

    Bike* construct() {
        builder->buildFrame("默认车架"); // 可以在这里设置默认参数，或者从外部传入  
        builder->buildSeat("默认车座");
        return builder->getBike();
    }
};

int main() {
    HelloBuilder helloBuilder;
    Director director(&helloBuilder);
    Bike* helloBike = director.construct();
    helloBike->display(); // 显示 HelloBuilder 构建的自行车  

    MobikeBuilder mobikeBuilder;
    Director mobikeDirector(&mobikeBuilder);
    Bike* mobike = mobikeDirector.construct();

    mobike->display(); // 显示 MobikeBuilder 构建的自行车  

    // 清理资源  
    delete helloBike;
    delete mobike;

    return 0;
}

四、总结

建造者模式通过分离复杂对象的构建与表示，提供了灵活的构建过程。它增强了封装性，使得构建细节对客户端透明，同时易于扩展和修改。然而，对于简单对象，使用建造者模式可能增加设计复杂性，增加类数量，且理解其内部结构需要一定时间。因此，在选择是否使用建造者模式时，应基于对象构建的复杂性和未来修改的可能性来权衡其优缺点。