在C++中，建造者模式是一种设计模式，它提供了一种方法来分离对象的构建过程和它的表示，使得同样的构建过程可以创建不同的表示。
建造者模式通常包括以下几个角色：
Builder：抽象建造者，定义了用于构建对象各个部分的抽象接口。
ConcreteBuilder：具体建造者，实现了Builder接口，提供了具体的构建逻辑。
Director：指挥者，负责使用Builder接口构建对象。
Product：产品，表示被构建的对象。
class Product {
public:
virtual ~Product() {}
virtual void operationA() = 0;
virtual void operationB() = 0;
virtual void operationC() = 0;
};
class ConcreteProduct : public Product {
public:
void operationA() override {
}
void operationB() override {
}
void operationC() override {
}
};
class Builder {
public:
virtual ~Builder() {}
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual void buildPartC() = 0;
virtual Product* getProduct() = 0;
};
class ConcreteBuilder : public Builder {
public:
void buildPartA() override {
}
void buildPartB() override {
}
void buildPartC() override {
}
Product* getProduct() override {
return product_;
}
private:
ConcreteProduct* product_;
};
class Director {
public:
void setBuilder(Builder* builder) {
builder_ = builder;
}
void build() {
builder_->buildPartA();
builder_->buildPartB();
builder_->buildPartC();
}
private:
Builder* builder_;
};
int main() {
Director director;
ConcreteBuilder builder;
director.setBuilder(&builder);
director.build();
Product* product = builder.getProduct();
product->operationA();
product->operationB();
product->operationC();
delete product;
return 0;
}
建造者模式的优点：
可以使得构建过程与表示分离，从而使得同样的构建过程可以创建不同的表示。可以使用不同的具体建造者来构建不同的产品。可以使用指挥者来控制构建过程。建造者模式的缺点：
实现建造者模式可能会比较复杂。如果产品的内部发生变化，那么需要修改所有的具体建造者。 示例：定义一个汽车类型，包括汽车的型号、颜色、轮胎数量和引擎类型，并提供了一个建造者来创建汽车对象；
#include <iostream>
#include <string>
class Car {
public:
std::string model;
std::string color;
int numWheels;
std::string engineType;
void setModel(std::string model) {
this->model = model;
}
void setColor(std::string color) {
this->color = color;
}
void setNumWheels(int numWheels) {
this->numWheels = numWheels;
}
void setEngineType(std::string engineType) {
this->engineType = engineType;
}
};
class CarBuilder {
protected:
Car car;
public:
CarBuilder() {}
Car* getCar() {
return &car;
}
};
class SedanCarBuilder : public CarBuilder {
public:
SedanCarBuilder() {
car.setNumWheels(4);
car.setEngineType("V6");
}
void setModel(std::string model) {
car.setModel(model);
}
void setColor(std::string color) {
car.setColor(color);
}
};
class SUVCarBuilder : public CarBuilder {
public:
SUVCarBuilder() {
car.setNumWheels(4);
car.setEngineType("V8");
}
void setModel(std::string model) {
car.setModel(model);
}
void setColor(std::string color) {
car.setColor(color);
}
};
class CarDirector {
private:
CarBuilder* builder;
public:
void setBuilder(CarBuilder* builder) {
this->builder = builder;
}
Car* getCar() {
return builder->getCar();
}
void buildCar() {
builder->setModel("Model X");
builder->setColor("Red");
}
};
int main() {
CarDirector director;
CarBuilder* builder = new SedanCarBuilder();
director.setBuilder(builder);
director.buildCar();
Car* car = director.getCar();
std::cout << "Model: " << car->model << std::endl;
std::cout << "Color: " << car->color << std::endl;
std::cout << "Num wheels: " << car->numWheels << std::endl;
std::cout << "Engine type: " << car->engineType<< std::endl;
}
