C++ 建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，用于将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。该模式特别适用于需要分步骤构建、且可能包含多种配置选项的对象。

概述

建造者模式通过以下核心组件实现解耦：

• 产品（Product）：最终要构建的复杂对象。
• 建造者（Builder）'：抽象接口，定义构建产品的各个步骤。
• 具体建造者（Concrete Builder）：实现Builder接口，提供构建过程的具体实现。
• 指挥者（Director）：控制构建过程，按步骤调用Builder的方法。

适用场景

• 对象包含多个部件，且构建顺序或组合方式可能变化。
• 需要隔离复杂对象的创建逻辑和其表示（例如，同一构建过程生成不同格式的结果）。
• 对象的构建过程需要分步骤完成（例如，生成报告、配置UI组件）。

结构

classDiagram class Product { +parts: List<string> +AddPart(part: string): void +ShowParts(): void } class Builder { <<interface>> +BuildPartA(): void +BuildPartB(): void +GetResult(): Product } class ConcreteBuilder { -product: Product +BuildPartA(): void +BuildPartB(): void +GetResult(): Product } class Director { -builder: Builder +Construct(): void } Director --> Builder Builder <|.. ConcreteBuilder ConcreteBuilder --> Product

代码示例

以下示例展示如何用C++实现建造者模式，构建一个包含不同部件的汽车对象。

  
#include <iostream>  
#include <vector>  
#include <string>  

// 产品类：汽车  
class Car {  
private:  
    std::vector<std::string> parts_;  
public:  
    void AddPart(const std::string& part) {  
        parts_.push_back(part);  
    }  
    void ShowParts() const {  
        std::cout << "Car parts: ";  
        for (const auto& part : parts_) {  
            std::cout << part << ", ";  
        }  
        std::cout << "\n";  
    }  
};  

// 抽象建造者  
class CarBuilder {  
public:  
    virtual ~CarBuilder() = default;  
    virtual void BuildEngine() = 0;  
    virtual void BuildWheels() = 0;  
    virtual void BuildBody() = 0;  
    virtual Car* GetCar() = 0;  
};  

// 具体建造者：运动汽车  
class SportsCarBuilder : public CarBuilder {  
private:  
    Car* car_;  
public:  
    SportsCarBuilder() : car_(new Car()) {}  
    void BuildEngine() override {  
        car_->AddPart("V8 Engine");  
    }  
    void BuildWheels() override {  
        car_->AddPart("20-inch Wheels");  
    }  
    void BuildBody() override {  
        car_->AddPart("Carbon Fiber Body");  
    }  
    Car* GetCar() override {  
        return car_;  
    }  
};  

// 指挥者  
class Director {  
private:  
    CarBuilder* builder_;  
public:  
    void SetBuilder(CarBuilder* builder) {  
        builder_ = builder;  
    }  
    void ConstructCar() {  
        builder_->BuildBody();  
        builder_->BuildEngine();  
        builder_->BuildWheels();  
    }  
};  

int main() {  
    Director director;  
    SportsCarBuilder sportsBuilder;  

    director.SetBuilder(&sportsBuilder);  
    director.ConstructCar();  

    Car* sportsCar = sportsBuilder.GetCar();  
    sportsCar->ShowParts();  // 输出：Car parts: Carbon Fiber Body, V8 Engine, 20-inch Wheels  

    delete sportsCar;  
    return 0;  
}

输出解释

程序输出展示了通过建造者模式构建的汽车部件：

  
Car parts: Carbon Fiber Body, V8 Engine, 20-inch Wheels  

实际应用案例

建造者模式在以下场景中广泛应用： 1. GUI框架：分步骤构建复杂UI组件（如对话框）。 2. 文档生成器：生成HTML、PDF等不同格式的文档。 3. 游戏开发：构建角色或地图（例如，角色包含装备、技能等部件）。

变体：链式调用建造者

通过返回建造者自身的引用，支持链式调用（Fluent Interface）：

  
class PizzaBuilder {  
private:  
    Pizza* pizza_;  
public:  
    PizzaBuilder() : pizza_(new Pizza()) {}  
    PizzaBuilder& AddCheese() {  
        pizza_->AddPart("Cheese");  
        return *this;  
    }  
    PizzaBuilder& AddPepperoni() {  
        pizza_->AddPart("Pepperoni");  
        return *this;  
    }  
    Pizza* Build() {  
        return pizza_;  
    }  
};  

// 使用示例  
Pizza* pizza = PizzaBuilder().AddCheese().AddPepperoni().Build();

与其他模式的关系

• 工厂模式：关注整体对象的创建，而建造者模式关注分步骤构建。
• 组合模式：建造者可能用于构建组合结构中的复杂节点。

总结

建造者模式通过分离构建逻辑和表示，提高了代码的灵活性和可维护性。它特别适合需要分步骤配置的复杂对象，同时避免了构造函数的“参数爆炸”问题。