实现一个C++的建造者模式

建造者模式是一种对象创建型模式，它将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。下面是一个简单的 C++ 实现：

假设我们要创建一个包含车轮、发动机、座椅等部件的汽车，而这些部件的创建又比较复杂，可以使用建造者模式来解决这个问题。

创建抽象建造者类

class CarBuilder
{
public:
    virtual void buildWheel() = 0;
    virtual void buildEngine() = 0;
    virtual void buildSeat() = 0;
    virtual Car getCar() = 0;
};

创建具体建造者类

class JeepBuilder : public CarBuilder
{
private:
    Car car;

public:
    void buildWheel() { car.setWheel("Jeep wheel"); }
    void buildEngine() { car.setEngine("Jeep engine"); }
    void buildSeat() { car.setSeat("Jeep seat"); }
    Car getCar() { return car; }
};

class SportsCarBuilder : public CarBuilder
{
private:
    Car car;

public:
    void buildWheel() { car.setWheel("Sports car wheel"); }
    void buildEngine() { car.setEngine("Sports car engine"); }
    void buildSeat() { car.setSeat("Sports car seat"); }
    Car getCar() { return car; }
};

创建产品类

class Car
{
private:
    string wheel;
    string engine;
    string seat;

public:
    void setWheel(string wheel) { this->wheel = wheel; }
    void setEngine(string engine) { this->engine = engine; }
    void setSeat(string seat) { this->seat = seat; }

    void display()
    {
        cout << "Wheel: " << wheel << endl;
        cout << "Engine: " << engine << endl;
        cout << "Seat: " << seat << endl;
    }
};

创建指挥者类

class Director
{
public:
    Car construct(CarBuilder& builder)
    {
        builder.buildWheel();
        builder.buildEngine();
        builder.buildSeat();

        return builder.getCar();
    }
};

使用建造者模式创建对象

int main()
{
    CarBuilder* builder = new SportsCarBuilder();
    Director director;
    Car car = director.construct(*builder);
    car.display();
    delete builder;

    builder = new JeepBuilder();
    car = director.construct(*builder);
    car.display();
    delete builder;

    return 0;
}

运行结果如下：

Wheel: Sports car wheel
Engine: Sports car engine
Seat: Sports car seat
Wheel: Jeep wheel
Engine: Jeep engine
Seat: Jeep seat