C++计划模式之构造器

发表于 2025-12-18 10:57:53

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

动机

在软件体系中，偶然候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用肯定的算法构成；由于需求的厘革，这个复杂对象的各个部分常常面临着剧烈的厘革，但是将它们组合在一起的算法却相对稳固。
怎样应对这种厘革？怎样提供一种“封装机制”来隔离出“复杂对象的各个部分”的厘革，从而保持体系中的“稳固构建算法”不随着需求改变而改变？
代码示例：创建各种房子，好比砖瓦房，高楼，别墅等房子

class House{
//....
};
class HouseBuilder {
public:
House* GetResult(){
return pHouse;
}
virtual ~HouseBuilder(){}
protected:
House* pHouse;
virtual void BuildPart1()=0;
virtual void BuildPart2()=0;
virtual void BuildPart3()=0;
virtual void BuildPart4()=0;
virtual void BuildPart5()=0;
};
class StoneHouse: public House{
};
// 石头房子的创建，override HouseBuilder里面的流程
class StoneHouseBuilder: public HouseBuilder{
protected:
virtual void BuildPart1(){
//pHouse->Part1 = ...;
}
virtual void BuildPart2(){
}
virtual void BuildPart3(){
}
virtual void BuildPart4(){
}
virtual void BuildPart5(){
}
};
// 房子具体构建过程
class HouseDirector{
public:
// 有一个HouseBuilder的指针
HouseBuilder* pHouseBuilder;
HouseDirector(HouseBuilder* pHouseBuilder){
this->pHouseBuilder=pHouseBuilder;
}
House* Construct(){ // 整个构建流程是稳定的
pHouseBuilder->BuildPart1();
for (int i = 0; i < 4; i++){
pHouseBuilder->BuildPart2();
}
bool flag=pHouseBuilder->BuildPart3();
if(flag){
pHouseBuilder->BuildPart4();
}
pHouseBuilder->BuildPart5();
return pHouseBuilder->GetResult();
}
};
int main() {
// 创建石头房子的建造者
StoneHouseBuilder stoneHouseBuilder;
// 创建房子Director，并指定建造者
HouseDirector houseDirector(&stoneHouseBuilder);
// 构建房子
House* stoneHouse = houseDirector.Construct();
// 输出结果
if (stoneHouse != nullptr) {
// 假设 House 类有适当的输出方法
// 这里只是简单示例，实际使用时需要根据具体类的实现调用相应的方法
std::cout << "Stone House constructed." << std::endl;
} else {
std::cout << "Failed to construct Stone House." << std::endl;
}
// 释放资源
delete stoneHouse;
return 0;
}

复制代码

上述代码涉及了Builder计划模式，包罗以下几个类：
House 类:
表现待构建的产物，即房子。在示例中，StoneHouse 类是 House 的详细实现。
HouseBuilder 抽象类:
界说了构建产物（房子）的抽象接口。详细的制作者（比方 StoneHouseBuilder）须要继续这个抽象类并实现接口中的方法，以完成详细产物的构建。
StoneHouseBuilder 类:
是HouseBuilder的详细实现，负责构建石头房子。它通过实现抽象接口中的方法来完成详细的制作流程。
HouseDirector 类:
起到引导制作的作用，通过构造函数吸收一个详细的制作者对象。通过调用制作者的方法，按照肯定的构建流程构造制作者完成产物的构建。
main 函数:
在 main 函数中，创建了 StoneHouseBuilder 的实例，然后创建了一个HouseDirector的实例，并将制作者转达给导演。通过导演的 Construct 方法，按照肯定的构建流程构建了石头房子，并输出结果。
总体而言，Builder计划模式的目的是将一个复杂对象的构建与它的表现分离，使得同样的构建过程可以创建差别的表现。在这个示例中，HouseBuilder 抽象类界说了构建房子的接口，StoneHouseBuilder 实现了详细的石头房子构建流程，而 HouseDirector 则负责和谐制作者完成整个构建流程。
Builder要点总结
Builder 模式紧张用于“分步调构建一个复杂的对象”。在这此中“分步调”是一个稳固的算法，而复杂对象的各个部分则常常厘革。
厘革点在那边，封装那边—— Builder模式紧张在于应对“复杂对象各个部分”的频仍需求变更。其缺点在于难以应对“分步调构建算法”的需求变更。
在Builder模式中，要留意差别语言中构造器内调用虚函数的差别（C++ vs. C#) 。
chatGPT给出的builder的例子
以下是一个简单的C++示例代码，演示Builder计划模式：

#include <iostream>
#include <string>
// 产品类
class Product {
public:
void AddPart(const std::string& part) {
parts += part + " ";
}
void Show() const {
std::cout << "Product Parts: " << parts << std::endl;
}
private:
std::string parts;
};
// 抽象建造者类
class Builder {
public:
virtual void BuildPart1() = 0;
virtual void BuildPart2() = 0;
virtual Product* GetResult() = 0;
};
// 具体建造者类
class ConcreteBuilder : public Builder {
public:
ConcreteBuilder() {
product = new Product();
}
void BuildPart1() override {
product->AddPart("Part1");
}
void BuildPart2() override {
product->AddPart("Part2");
}
Product* GetResult() override {
return product;
}
private:
Product* product;
};
// 指导者类
class Director {
public:
Director(Builder* builder) : builder(builder) {}
void Construct() {
builder->BuildPart1();
builder->BuildPart2();
}
private:
Builder* builder;
};
int main() {
// 创建具体建造者
ConcreteBuilder concreteBuilder;
// 创建指导者，并传入具体建造者
Director director(&concreteBuilder);
// 指导者构建产品
director.Construct();
// 获取最终产品
Product* product = concreteBuilder.GetResult();
// 展示产品
if (product != nullptr) {
product->Show();
delete product;
}
return 0;
}

复制代码

在这个示例中，Product 表现终极构建的复杂对象，Builder 是抽象制作者类，ConcreteBuilder 是详细制作者类，Director 是引导者类。通过引导者调用详细制作者的方法，终极得到构建完成的产物。这个例子中的产物是简单的包罗两个部分的字符串，现实应用中可以根据需求界说更复杂的产物布局。

C++计划模式之构造器

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

浏览过的版块

天津储鑫盛钢材现货供应商