网站空间邮箱每年要续费吗,怎么备份网站数据库,网站广告牌制作教程,用ssh做的网站解决的问题
生成器模式#xff08;Builder Pattern#xff09;主要解决复杂对象的构建问题。当一个对象的创建过程非常复杂#xff0c;涉及多个步骤和多个部件时#xff0c;使用生成器模式可以将对象的构建过程与其表示分离#xff0c;使得同样的构建过程可以创建不同的表…解决的问题
生成器模式Builder Pattern主要解决复杂对象的构建问题。当一个对象的创建过程非常复杂涉及多个步骤和多个部件时使用生成器模式可以将对象的构建过程与其表示分离使得同样的构建过程可以创建不同的表示。
适用场景
复杂对象的构建当对象的构建过程非常复杂涉及多个步骤和多个部件时。不同的构建过程当需要不同的表示时可以使用相同的构建过程。逐步构建当对象的构建过程可以逐步进行时。
模式的参与者角色
Builder生成器接口定义构建产品的各个部件的抽象接口。ConcreteBuilder具体生成器实现 Builder 接口负责构建产品的各个部件。Product产品表示正在构建的复杂对象。Director指导者使用 Builder 接口来构建产品。
以生产汽车为例的生成器模式示例代码
#include iostream
#include string// 产品类汽车
class Car {
public:void setBody(const std::string body) { body_ body; }void setEngine(const std::string engine) { engine_ engine; }void setWheels(const std::string wheels) { wheels_ wheels; }void setInterior(const std::string interior) { interior_ interior; }void show() const {std::cout Car Configuration: std::endl;std::cout Body: body_ std::endl;std::cout Engine: engine_ std::endl;std::cout Wheels: wheels_ std::endl;std::cout Interior: interior_ std::endl;}private:std::string body_;std::string engine_;std::string wheels_;std::string interior_;
};// 抽象生成器接口
class CarBuilder {
public:virtual ~CarBuilder() {}virtual void buildBody() 0;virtual void buildEngine() 0;virtual void buildWheels() 0;virtual void buildInterior() 0;virtual Car* getCar() 0;
};// 具体生成器SUV 汽车
class SUVBuilder : public CarBuilder {
public:SUVBuilder() { car_ new Car(); }~SUVBuilder() { delete car_; }void buildBody() override { car_-setBody(SUV Body); }void buildEngine() override { car_-setEngine(SUV Engine); }void buildWheels() override { car_-setWheels(SUV Wheels); }void buildInterior() override { car_-setInterior(SUV Interior); }Car* getCar() override { return car_; }private:Car* car_;
};// 具体生成器Sedan 汽车
class SedanBuilder : public CarBuilder {
public:SedanBuilder() { car_ new Car(); }~SedanBuilder() { delete car_; }void buildBody() override { car_-setBody(Sedan Body); }void buildEngine() override { car_-setEngine(Sedan Engine); }void buildWheels() override { car_-setWheels(Sedan Wheels); }void buildInterior() override { car_-setInterior(Sedan Interior); }Car* getCar() override { return car_; }private:Car* car_;
};// 指导者
class Director {
public:void setBuilder(CarBuilder* builder) { builder_ builder; }Car* constructCar() {builder_-buildBody();builder_-buildEngine();builder_-buildWheels();builder_-buildInterior();return builder_-getCar();}private:CarBuilder* builder_;
};// 客户端代码
int main() {Director director;// 创建 SUVstd::cout Building SUV... std::endl;SUVBuilder suvBuilder;director.setBuilder(suvBuilder);Car* suv director.constructCar();suv-show();delete suv;// 创建 Sedanstd::cout \nBuilding Sedan... std::endl;SedanBuilder sedanBuilder;director.setBuilder(sedanBuilder);Car* sedan director.constructCar();sedan-show();delete sedan;return 0;
}代码说明
Car 类表示正在构建的汽车产品包含汽车的各个部件。CarBuilder 是一个抽象生成器接口定义了构建汽车各个部件的方法和一个获取最终产品的接口。SUVBuilder 和 SedanBuilder 是具体生成器类分别实现了 CarBuilder 接口用于构建 SUV 和 Sedan 汽车。Director 类负责使用 CarBuilder 接口来构建汽车。它通过调用生成器的各个构建方法来逐步构建汽车。Client 在 main 函数中使用 Director 和具体生成器来构建不同类型的汽车并展示汽车配置。
总结
生成器模式通过将复杂对象的构建过程与其表示分离使得同样的构建过程可以创建不同的表示。在需要逐步构建复杂对象或需要不同表示的场景中生成器模式非常有用。 模板方法Template Method模式与生成器Builder模式
形式相似点
抽象类与具体类两种模式都涉及抽象类或接口和具体实现类。分步构建都需要分步骤构建复杂对象或执行算法。
目的的不同点
模板方法模式定义一个算法的框架允许子类在不改变算法结构的情况下重新定义算法的某些步骤。目的是为了代码复用和算法的一致性。生成器模式将复杂对象的构建过程与其表示分离使得同样的构建过程可以创建不同的表示。目的是为了构建复杂对象时的灵活性和可扩展性。
模板方法模式的代码示例
#include iostream
#include string// 抽象类定义模板方法
class AbstractClass {
public:// 模板方法void templateMethod() {step1();step2();step3();}protected:virtual void step1() 0;virtual void step2() 0;virtual void step3() 0;
};// 具体类1
class ConcreteClass1 : public AbstractClass {
protected:void step1() override {std::cout ConcreteClass1: Step 1 std::endl;}void step2() override {std::cout ConcreteClass1: Step 2 std::endl;}void step3() override {std::cout ConcreteClass1: Step 3 std::endl;}
};// 具体类2
class ConcreteClass2 : public AbstractClass {
protected:void step1() override {std::cout ConcreteClass2: Step 1 std::endl;}void step2() override {std::cout ConcreteClass2: Step 2 std::endl;}void step3() override {std::cout ConcreteClass2: Step 3 std::endl;}
};// 客户端代码
int main() {AbstractClass* class1 new ConcreteClass1();class1-templateMethod();delete class1;std::cout std::endl;AbstractClass* class2 new ConcreteClass2();class2-templateMethod();delete class2;return 0;
}生成器模式的代码示例
#include iostream
#include string// 产品类
class Product {
public:void setPartA(const std::string partA) { partA_ partA; }void setPartB(const std::string partB) { partB_ partB; }void setPartC(const std::string partC) { partC_ partC; }void show() const {std::cout Product parts: partA_ , partB_ , partC_ std::endl;}private:std::string partA_;std::string partB_;std::string partC_;
};// 抽象生成器接口
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:ConcreteBuilder() { product_ new Product(); }~ConcreteBuilder() { delete product_; }void buildPartA() override { product_-setPartA(PartA); }void buildPartB() override { product_-setPartB(PartB); }void buildPartC() override { product_-setPartC(PartC); }Product* getProduct() override { return product_; }private:Product* product_;
};// 指导者
class Director {
public:void setBuilder(Builder* builder) { builder_ builder; }Product* constructProduct() {builder_-buildPartA();builder_-buildPartB();builder_-buildPartC();return builder_-getProduct();}private:Builder* builder_;
};// 客户端代码
int main() {Director director;// 创建具体生成器ConcreteBuilder builder;director.setBuilder(builder);// 构建产品Product* product director.constructProduct();product-show();delete product;return 0;
}代码说明
模板方法示例
AbstractClass定义了一个模板方法 templateMethod()其中包含了三个抽象步骤 step1(), step2(), step3()。ConcreteClass1 和 ConcreteClass2具体子类分别实现了抽象步骤但模板方法的结构保持不变。客户端代码通过创建 ConcreteClass1 和 ConcreteClass2 的对象调用 templateMethod() 方法来执行算法子类可以在不改变算法结构的情况下重新定义算法的某些步骤。
生成器模式示例
Product表示正在构建的复杂对象。Builder抽象生成器接口定义了构建产品的各个部件的方法和一个获取最终产品的接口。ConcreteBuilder具体生成器类实现了 Builder 接口负责构建产品的各个部件。Director指导者类使用 Builder 接口来构建产品。通过调用生成器的各个构建方法来逐步构建产品。客户端代码通过 Director 和 ConcreteBuilder 来构建产品并展示产品配置。
总结
模板方法模式目的是为了代码复用和算法的一致性通过定义算法的框架允许子类在不改变算法结构的情况下重新定义算法的某些步骤。生成器模式目的是为了构建复杂对象时的灵活性和可扩展性通过将复杂对象的构建过程与其表示分离使得同样的构建过程可以创建不同的表示。
