c++建造者设计模式
时间: 2024-06-22 13:01:33 浏览: 6
建造者(Builder)设计模式是一种创建型设计模式,它提供了一种灵活的方式来构造复杂对象,而无需暴露其内部表示。这种模式将构建过程与对象的实例化分离,使得同样的构建过程可以创建不同的产品,同时保持构造过程的清晰和模块化。
在C++中,建造者模式通常通过以下几个关键元素实现:
1. **Builder接口**:定义了一系列方法,用于逐步构建对象的不同部分。这些方法通常返回Builder自身,以便链式调用。
2. **Concrete Builder**:实现了Builder接口的具体类,负责执行构建步骤并生成最终产品。
3. **Product接口/类**:定义了用户期望的对象,但不包含构建逻辑。Builder通过一系列操作创建Product实例。
4. **Director类/对象**:负责管理Builder的使用,根据需求调用Builder的方法来构建产品。Director对外部并不直接依赖于具体的Builder类型。
例如,如果你正在创建一个复杂的图形对象,比如一个带有多边形和颜色属性的Shape,你可以有一个Builder类序列化这些属性,而Director类负责决定如何组合这些属性来创建最终的Shape。
相关问题
C++设计模式 建造者
建造者模式是一种创建型设计模式,它允许您创建不同类型的对象,而无需暴露对象的创建逻辑。它将对象的构建步骤分解为可重用的部分,并允许您按顺序执行它们。这使得您能够创建具有不同属性的对象,而无需编写大量的重复代码。
在建造者模式中,有一个建造者类,它负责创建对象的特定部分,如电脑的CPU、内存和硬盘等。该类具有一个公共接口,该接口定义了每个部分的构建步骤。在构建步骤完成后,该类可以返回一个完整的对象。
建造者模式也包括一个指导者类,它负责调用建造者类的构建步骤,并按照正确的顺序执行它们。指导者类知道如何创建对象,但不知道如何创建对象的每个部分,因此它将这个工作委托给建造者类。
以下是一个简单的C++实现建造者模式的示例代码:
```cpp
#include <iostream>
#include <string>
class Computer {
public:
void setCPU(const std::string& cpu) {
m_cpu = cpu;
}
void setMemory(const std::string& memory) {
m_memory = memory;
}
void setHardDisk(const std::string& hardDisk) {
m_hardDisk = hardDisk;
}
void show() {
std::cout << "CPU: " << m_cpu << std::endl;
std::cout << "Memory: " << m_memory << std::endl;
std::cout << "Hard Disk: " << m_hardDisk << std::endl;
}
private:
std::string m_cpu;
std::string m_memory;
std::string m_hardDisk;
};
class Builder {
public:
virtual ~Builder() {}
virtual void buildCPU() = 0;
virtual void buildMemory() = 0;
virtual void buildHardDisk() = 0;
virtual Computer* getResult() = 0;
};
class Director {
public:
void setBuilder(Builder* builder) {
m_builder = builder;
}
void construct() {
m_builder->buildCPU();
m_builder->buildMemory();
m_builder->buildHardDisk();
}
private:
Builder* m_builder;
};
class DesktopBuilder : public Builder {
public:
DesktopBuilder() {
m_computer = new Computer;
}
~DesktopBuilder() {
delete m_computer;
}
void buildCPU() {
m_computer->setCPU("Intel Core i7");
}
void buildMemory() {
m_computer->setMemory("16GB DDR4 RAM");
}
void buildHardDisk() {
m_computer->setHardDisk("2TB SATA Hard Disk");
}
Computer* getResult() {
return m_computer;
}
private:
Computer* m_computer;
};
int main() {
Director director;
DesktopBuilder desktopBuilder;
director.setBuilder(&desktopBuilder);
director.construct();
Computer* computer = desktopBuilder.getResult();
computer->show();
return 0;
}
```
在这个示例中,我们创建了一个Computer类,它有三个成员变量:CPU、内存和硬盘。我们还创建了一个Builder类,它定义了创建Computer对象的构建步骤,并且为每个部分提供了一个抽象接口。我们还创建了一个Director类,它负责调用建造者类的构建步骤,并按照正确的顺序执行它们。
在具体的建造者实现中,我们创建了一个DesktopBuilder类,它实现了Builder接口,并具有一个Computer成员变量。在DesktopBuilder类的构建步骤中,我们设置了Computer对象的CPU、内存和硬盘。最后,我们返回一个完整的Computer对象。
在main函数中,我们创建了一个Director对象,并将DesktopBuilder对象传递给setBuilder函数。然后我们调用construct函数,它将调用DesktopBuilder的构建步骤,并返回一个完整的Computer对象。我们最后打印出这个对象的属性,以验证它是否被正确构建。
C++ 建造者模式实现
建造者模式是一种创建型设计模式,它允许逐步创建复杂对象,同时使得创建过程更加灵活。在 C++ 中,可以使用类和对象来实现建造者模式。
以下是一个使用 C++ 实现建造者模式的示例:
首先,我们需要定义一个产品类,该类包含了需要创建的对象的属性:
```cpp
class Product {
public:
void setPartA(const std::string& partA) {
this->partA = partA;
}
void setPartB(const std::string& partB) {
this->partB = partB;
}
void setPartC(const std::string& partC) {
this->partC = partC;
}
std::string getInfo() const {
return "Part A: " + partA + ", Part B: " + partB + ", Part C: " + partC;
}
private:
std::string partA;
std::string partB;
std::string partC;
};
```
接下来,我们需要定义一个抽象建造者类,该类定义了创建产品所需的所有方法:
```cpp
class Builder {
public:
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual void buildPartC() = 0;
virtual Product* getResult() = 0;
};
```
然后,我们可以定义具体的建造者类,该类实现了抽象建造者类中定义的所有方法,并负责创建具体的产品对象:
```cpp
class ConcreteBuilder : public Builder {
public:
ConcreteBuilder() {
product = new Product();
}
void buildPartA() override {
product->setPartA("Part A");
}
void buildPartB() override {
product->setPartB("Part B");
}
void buildPartC() override {
product->setPartC("Part C");
}
Product* getResult() override {
return product;
}
private:
Product* product;
};
```
最后,我们需要定义一个指挥者类,该类负责使用建造者对象来构建具体的产品:
```cpp
class Director {
public:
void construct(Builder* builder) {
builder->buildPartA();
builder->buildPartB();
builder->buildPartC();
}
};
```
现在,我们可以使用建造者模式来创建具体的产品对象:
```cpp
int main() {
Director director;
ConcreteBuilder builder;
director.construct(&builder);
Product* product = builder.getResult();
std::cout << product->getInfo() << std::endl;
return 0;
}
```
输出结果为:
```
Part A: Part A, Part B: Part B, Part C: Part C
```
这就是一个简单的 C++ 建造者模式的实现。