设计模式笔记：建造者模式

发表于 | 分类于

建造者模式

是一种创建型设计模式，它的主要目的是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。这种模式是为了解决在编程中一些复杂对象的创建和表示的问题。

当一个类的构造函数参数超过4个，而且这些参数有些是可选的时，考虑使用建造者模式

以下是使用C++实现建造者模式的一个例子，这里我们以创建一个简单的汽车为例。

首先，我们定义一个产品类，也就是我们要创建的复杂对象：

1
2
3
4
5
6
7
8
9
10
11
class Car {
public:
    void setEngine(const std::string& engine) { m_engine = engine; }
    void setBody(const std::string& body) { m_body = body; }
    void setWheels(int wheels) { m_wheels = wheels; }

private:
    std::string m_engine;
    std::string m_body;
    int m_wheels;
};

然后，我们定义一个抽象建造者类，定义创建复杂对象的各个部分的接口：

1
2
3
4
5
6
7
8
class CarBuilder {
public:
    virtual ~CarBuilder() {}
    virtual void buildEngine() = 0;
    virtual void buildBody() = 0;
    virtual void buildWheels() = 0;
    virtual Car* getCar() = 0;
};

接着，我们创建具体的建造者类，实现抽象建造者接口，提供具体的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class SportsCarBuilder : public CarBuilder {
public:
    SportsCarBuilder() { m_car = new Car(); }
    ~SportsCarBuilder() { delete m_car; }

    void buildEngine() override { m_car->setEngine("Sports engine"); }
    void buildBody() override { m_car->setBody("Sports body"); }
    void buildWheels() override { m_car->setWheels(4); }

    Car* getCar() override { return m_car; }

private:
    Car* m_car;
};

最后，我们创建指挥者类，用来规范产品对象的创建流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Director {
public:
    void setBuilder(CarBuilder* builder) { m_builder = builder; }

    Car* construct() {
        m_builder->buildBody();
        m_builder->buildEngine();
        m_builder->buildWheels();
        return m_builder->getCar();
    }

private:
    CarBuilder* m_builder;
};

在客户端代码中，我们可以像下面这样使用建造者模式来创建产品：

1
2
3
4
5
6
7
8
9
10
11
12
13
int main() {
    Director director;
    SportsCarBuilder builder;

    director.setBuilder(&builder);
    Car* car = director.construct();

    // Do something with the car...

    delete car;

    return 0;
}

在这个例子中，我们将汽车的创建过程（即引擎、车身和轮胎的创建）和汽车对象的表示（即汽车对象）分离开来。客户端代码不需要知道汽车是如何创建的，只需要通过指挥者和具体的建造者就可以得到汽车对象。

总结：

通过将具体建造者对象传递给指挥者对象，在具体建造者对象中完成复杂对象的创建

原型模式是一种创建型设计模式，它用于创建重复的对象，同时又能保证性能。这种类型的设计模式提供了一种创建对象的最佳方式。这种模式涉及到一个原型类，该类负责创建对象的克隆。

在C++中，我们可以使用复制构造函数来实现原型模式。下面是一个简单的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
cppCopy code
#include <iostream>

// 原型基类
class Prototype {
public:
    virtual Prototype* clone() = 0; // 纯虚函数，由派生类实现
};

// 具体原型类
class ConcretePrototype : public Prototype {
private:
    int m_value;

public:
    // 构造函数
    ConcretePrototype(int value) : m_value(value) {}

    // 复制构造函数
    ConcretePrototype(const ConcretePrototype& cp) : m_value(cp.m_value) {}

    // 实现克隆方法，返回一个新的复制对象
    Prototype* clone() override {
        return new ConcretePrototype(*this);
    }

    // 输出值的方法，用于验证
    void printValue() {
        std::cout << "Value: " << m_value << std::endl;
    }
};

int main() {
    // 创建原型对象
    ConcretePrototype* prototype = new ConcretePrototype(10);
    
    // 克隆原型对象
    ConcretePrototype* clonedPrototype = dynamic_cast<ConcretePrototype*>(prototype->clone());
    
    // 输出原型和克隆对象的值
    prototype->printValue();
    clonedPrototype->printValue();
    
    // 清理
    delete prototype;
    delete clonedPrototype;

    return 0;
}

在这个示例中，首先我们定义了一个原型基类 Prototype，它有一个纯虚函数 clone()，这个函数将被派生类实现以返回一个新的对象。

然后我们定义了一个具体的原型类 ConcretePrototype，它继承自 Prototype，并实现了 clone() 方法。它的 clone() 方法使用了复制构造函数来创建一个新的 ConcretePrototype 对象，并返回它。

在 main() 函数中，我们首先创建了一个 ConcretePrototype 对象 prototype，然后我们调用 prototype 的 clone() 方法来创建一个新的 ConcretePrototype 对象 clonedPrototype。然后我们可以看到，prototype 和 clonedPrototype 的值是一样的，这证明了 clone() 方法成功地复制了 prototype 对象。

原型模式主要用于减少创建对象的开销，尤其是在创建大量重复对象时，通过复制已有对象来生成新对象，可以提高性能。

设计模式23模式介绍_设计模式_哪 吒-Eolink 开发者社区 (csdn.net)