设计模式之建造者模式

Grazve

已于 2024-06-07 09:48:17 修改

阅读量487

点赞数 9

分类专栏：设计模式文章标签：设计模式建造者模式

于 2024-06-07 09:44:07 首次发布

本文链接：https://blog.csdn.net/weixin_38492525/article/details/139517348

版权

设计模式专栏收录该内容

16 篇文章 0 订阅

订阅专栏

建造者模式（Builder Pattern）是一种创建型设计模式，用于分离一个复杂对象的构建和表示，使得同样的构建过程可以创建不同的表示。建造者模式通常用于构建那些由多个部分组成的复杂对象，比如汽车、房子、计算机等。想象一下，你要造一辆车，不同部件都得精心挑选，这时你就需要一个牛逼哄哄的建造者模式来帮你忙。建造者模式就像是个专业的汽车改装店，有个总设计师（Director）指挥，几位技术大牛（Builder）各司其职，最后整出一辆你梦寐以求的车。

UML类图

   +-------------------+
   |      Director     |
   +-------------------+
   | -builder: Builder*|
   +-------------------+
   | +construct()      |
   +-------------------+
            |
            |
            v
   +-------------------+
   |      Builder      |
   +-------------------+
   | +buildPartA()     |
   | +buildPartB()     |
   | +getResult()      |
   +-------------------+
            ^
            |
            |
   +-------------------------+
   |     ConcreteBuilder     |
   +-------------------------+
   | +buildPartA()           |
   | +buildPartB()           |
   | +getResult()            |
   +-------------------------+
            ^
            |
            |
   +-------------------+
   |      Product      |
   +-------------------+
   | -partA            |
   | -partB            |
   +-------------------+
   | +setPartA()       |
   | +setPartB()       |
   +-------------------+

示例代码

假设你要造两种车：运动型和家庭型。我们用建造者模式来实现。

#include <iostream>
#include <string>
#include <memory>

// 产品类：汽车
class Car {
public:
    void setEngine(const std::string& engine) {
        engine_ = engine;
    }

    void setTires(const std::string& tires) {
        tires_ = tires;
    }

    void setBody(const std::string& body) {
        body_ = body;
    }

    void show() const {
        std::cout << "Car with " << engine_ << " engine, " 
                  << tires_ << " tires, and " << body_ << " body." << std::endl;
    }

private:
    std::string engine_;
    std::string tires_;
    std::string body_;
};

// 抽象建造者类
class CarBuilder {
public:
    virtual ~CarBuilder() = default;

    virtual void buildEngine() = 0;
    virtual void buildTires() = 0;
    virtual void buildBody() = 0;
    virtual std::unique_ptr<Car> getResult() = 0;
};

// 具体建造者类：运动型汽车建造者
class SportsCarBuilder : public CarBuilder {
public:
    SportsCarBuilder() {
        car_ = std::make_unique<Car>();
    }

    void buildEngine() override {
        car_->setEngine("V8");
    }

    void buildTires() override {
        car_->setTires("Racing");
    }

    void buildBody() override {
        car_->setBody("Sporty");
    }

    std::unique_ptr<Car> getResult() override {
        return std::move(car_);
    }

private:
    std::unique_ptr<Car> car_;
};

// 具体建造者类：家庭型汽车建造者
class FamilyCarBuilder : public CarBuilder {
public:
    FamilyCarBuilder() {
        car_ = std::make_unique<Car>();
    }

    void buildEngine() override {
        car_->setEngine("V6");
    }

    void buildTires() override {
        car_->setTires("Regular");
    }

    void buildBody() override {
        car_->setBody("Sedan");
    }

    std::unique_ptr<Car> getResult() override {
        return std::move(car_);
    }

private:
    std::unique_ptr<Car> car_;
};

// 指挥者类
class Director {
public:
    void setBuilder(CarBuilder* builder) {
        builder_ = builder;
    }

    void construct() {
        builder_->buildEngine();
        builder_->buildTires();
        builder_->buildBody();
    }

private:
    CarBuilder* builder_;
};

// 客户端代码
int main() {
	Director director;

	// 建造运动型汽车
	CarBuilder* sportsBuilder = new SportsCarBuilder; 
	director.setBuilder(sportsBuilder);
	director.construct();
	std::unique_ptr<Car> sportsCar = sportsBuilder->getResult();
	sportsCar->show();

	// 建造家庭型汽车
	CarBuilder* familyBuilder = new FamilyCarBuilder ;
	director.setBuilder(familyBuilder);
	director.construct();
	std::unique_ptr<Car> familyCar = familyBuilder->getResult();
	familyCar->show();

	return 0;
}