键造者模式（Builder）

建造者模式（Builder Pattern）是一种创建型设计模式，用于创建复杂对象，而无需直接在客户端代码中使用复杂的构造函数或多个参数。建造者模式将对象的构建过程和表示分离，使得同样的构建过程可以创建不同的表示。

以下是建造者模式的几个关键角色：

1. 产品（Product）：表示最终构建的复杂对象。产品类通常包含多个属性，这些属性由建造者设置并最终组合成一个完整的对象。

2. 抽象建造者（Abstract Builder）：定义了构建产品的抽象接口。它通常包含设置产品各个部分的方法，例如设置产品属性、组装产品等。

3. 具体建造者（Concrete Builder）：实现了抽象建造者接口，负责具体的产品构建。每个具体建造者类都可以定义自己的构建过程和步骤，以及构建的具体细节。

4. 指导者（Director）：负责使用建造者来构建最终产品。指导者根据具体的构建步骤和顺序，通过调用建造者的方法来构建产品。

建造者模式的核心思想是通过将复杂对象的构建过程委派给具体的建造者，以便于创建不同的表示。客户端只需通过指导者来调用建造者的方法，而不需要了解具体的构建细节。这样可以将构建过程与最终产品的表示解耦，使得构建过程更加灵活和可扩展。

下面是一个简单的示例，演示了如何使用建造者模式来构建一个汽车对象：

// 产品 - 汽车
class Car {
private:
    string brand;
    string model;
    int year;

public:
    void setBrand(const string& brand) {
        this->brand = brand;
    }

    void setModel(const string& model) {
        this->model = model;
    }

    void setYear(int year) {
        this->year = year;
    }

    void showInfo() {
        cout << "Car: " << brand << " " << model << " (" << year << ")" << endl;
    }
};

// 抽象建造者
class CarBuilder {
public:
    virtual void buildBrand() = 0;
    virtual void buildModel() = 0;
    virtual void buildYear() = 0;
    virtual Car* getCar() = 0;
};

// 具体建造者 - 奔驰汽车建造者
class MercedesCarBuilder : public CarBuilder {
private:
    Car* car;

public:
    MercedesCarBuilder() {
        car = new Car();
    }

    void buildBrand() override {
        car->setBrand("Mercedes");
    }

    void buildModel() override {
        car->setModel("S-Class");
    }

    void buildYear() override {
        car->setYear(2022);
    }

    Car* getCar() override {
        return car;
    }
};

// 具体建造者 - 宝马汽车建造者
class BMWCarBuilder : public CarBuilder {
private:
    Car* car;

public:
    BMWCarBuilder() {
        car = new Car();
    }

    void buildBrand() override {
        car->setBrand("BMW");
    }

    void buildModel() override {
        car->setModel("5-Series");
    }

    void buildYear() override {
        car->setYear(2021);
    }

    Car* getCar() override {
        return car;
    }
};

// 指导者
class CarManufacturer {
public:
    Car* manufactureCar(CarBuilder* builder) {
        builder->buildBrand();
        builder->buildModel();
        builder->buildYear();
        return builder->getCar();
    }
};

int main() {
    CarManufacturer carManufacturer;

    CarBuilder* mercedesBuilder = new MercedesCarBuilder();
    Car* mercedesCar = carManufacturer.manufactureCar(mercedesBuilder);
    mercedesCar->showInfo();

    CarBuilder* bmwBuilder = new BMWCarBuilder();
    Car* bmwCar = carManufacturer.manufactureCar(bmwBuilder);
    bmwCar->showInfo();

    delete mercedesCar;
    delete mercedesBuilder;
    delete bmwCar;
    delete bmwBuilder;

    return 0;
}

在上述示例中，产品类是Car，表示最终构建的汽车对象。抽象建造者是CarBuilder，定义了构建汽车的抽象接口。具体建造者包括MercedesCarBuilder和BMWCarBuilder，分别负责构建奔驰汽车和宝马汽车。指导者是CarManufacturer，负责使用具体建造者来构建最终的汽车对象。

在主函数中，我们首先使用奔驰汽车建造者创建了一个奔驰汽车对象，然后使用宝马汽车建造者创建了一个宝马汽车对象。最后，我们展示了每个汽车对象的信息。

通过建造者模式，我们将复杂对象的构建过程和表示分离开来，使得同样的构建过程可以创建不同的表示。客户端只需与指导者进行交互，而不需要了解具体的构建细节，从而实现了解耦和灵活的对象构建。