当前位置: 首页> 健康> 母婴 > 工厂模式和装饰器模式在程序设计中的体现

工厂模式和装饰器模式在程序设计中的体现

时间:2025/7/11 23:34:27来源:https://blog.csdn.net/jh__chen/article/details/139251126 浏览次数:0次

工厂模式

Step 1: 更新基类

在基类中添加保护方法,这些方法可以被子类调用以实现公共的逻辑。

model.h

#ifndef MODEL_H
#define MODEL_Hclass Model {
public:virtual ~Model() {}void init() {preInit();doInit();postInit();}void process() {preProcess();doProcess();postProcess();}void destroy() {preDestroy();doDestroy();postDestroy();}protected:virtual void doInit() = 0;virtual void doProcess() = 0;virtual void doDestroy() = 0;virtual void preInit() {// 公共的初始化前逻辑}virtual void postInit() {// 公共的初始化后逻辑}virtual void preProcess() {// 公共的处理前逻辑}virtual void postProcess() {// 公共的处理后逻辑}virtual void preDestroy() {// 公共的销毁前逻辑}virtual void postDestroy() {// 公共的销毁后逻辑}
};#endif // MODEL_H

Step 2: 更新具体模型

在具体模型中实现纯虚函数,并在需要的地方调用基类的保护方法。

ModelA.h
#ifndef MODELA_H
#define MODELA_H#include "model.h"class ModelA : public Model {
protected:void doInit() override;void doProcess() override;void doDestroy() override;
};#endif // MODELA_H
ModelA.cpp
#include "ModelA.h"
#include <iostream>void ModelA::doInit() {std::cout << "ModelA specific initialization." << std::endl;
}void ModelA::doProcess() {std::cout << "ModelA specific processing." << std::endl;
}void ModelA::doDestroy() {std::cout << "ModelA specific destruction." << std::endl;
}

Step 3: 更新工厂和主程序

工厂和主程序的代码无需改变,因为它们依然通过基类接口与模型进行交互。

ModelFactory.h
#ifndef MODELFACTORY_H
#define MODELFACTORY_H#include "model.h"
#include <string>
#include <memory>class ModelFactory {
public:static std::unique_ptr<Model> createModel(const std::string& modelName);
};#endif // MODELFACTORY_H
ModelFactory.cpp
#include "ModelFactory.h"
#include "ModelA.h"
// #include "ModelB.h" // 包含其他模型头文件std::unique_ptr<Model> ModelFactory::createModel(const std::string& modelName) {if (modelName == "ModelA") {return std::make_unique<ModelA>();}// else if (modelName == "ModelB") {//     return std::make_unique<ModelB>();// }// 可以添加更多的模型创建逻辑return nullptr;
}
main.cpp
#include <iostream>
#include "ModelFactory.h"int main() {std::unique_ptr<Model> model = ModelFactory::createModel("ModelA");if (model) {model->init();model->process();model->destroy();} else {std::cerr << "Model creation failed." << std::endl;}return 0;
}

装饰器模式:

Step 1: 定义基类

定义一个基类 Model,其中包含纯虚函数 doInit()doProcess()doDestroy(),这些函数将由具体模型类实现。

model.h
#ifndef MODEL_H
#define MODEL_Hclass Model {
public:virtual ~Model() {}virtual void init() = 0;virtual void process() = 0;virtual void destroy() = 0;
};#endif // MODEL_H

Step 2: 定义具体模型

具体模型继承自 Model 并实现必要的方法。

ModelA.h
#ifndef MODELA_H
#define MODELA_H#include "model.h"class ModelA : public Model {
public:void init() override;void process() override;void destroy() override;
};#endif // MODELA_H
ModelA.cpp
#include "ModelA.h"
#include <iostream>void ModelA::init() {std::cout << "ModelA specific initialization." << std::endl;
}void ModelA::process() {std::cout << "ModelA specific processing." << std::endl;
}void ModelA::destroy() {std::cout << "ModelA specific destruction." << std::endl;
}

Step 3: 定义装饰器

定义一个装饰器基类 ModelDecorator,它继承自 Model 并包含一个 Model 对象的引用。这个装饰器基类将实现 Model 接口,并委托调用给被装饰的模型对象。

ModelDecorator.h
#ifndef MODELDECORATOR_H
#define MODELDECORATOR_H#include "model.h"
#include <memory>class ModelDecorator : public Model {
public:ModelDecorator(std::shared_ptr<Model> model) : model_(model) {}void init() override {model_->init();}void process() override {model_->process();}void destroy() override {model_->destroy();}protected:std::shared_ptr<Model> model_;
};#endif // MODELDECORATOR_H

Step 4: 定义具体装饰器

具体装饰器实现共享的逻辑,例如在初始化前后执行一些操作。

LoggingDecorator.h
#ifndef LOGGINGDECORATOR_H
#define LOGGINGDECORATOR_H#include "ModelDecorator.h"
#include <iostream>class LoggingDecorator : public ModelDecorator {
public:LoggingDecorator(std::shared_ptr<Model> model) : ModelDecorator(model) {}void init() override {preInit();ModelDecorator::init();postInit();}void process() override {preProcess();ModelDecorator::process();postProcess();}void destroy() override {preDestroy();ModelDecorator::destroy();postDestroy();}protected:void preInit() {std::cout << "Common pre-initialization logic." << std::endl;}void postInit() {std::cout << "Common post-initialization logic." << std::endl;}void preProcess() {std::cout << "Common pre-processing logic." << std::endl;}void postProcess() {std::cout << "Common post-processing logic." << std::endl;}void preDestroy() {std::cout << "Common pre-destruction logic." << std::endl;}void postDestroy() {std::cout << "Common post-destruction logic." << std::endl;}
};#endif // LOGGINGDECORATOR_H

Step 5: 使用模型和装饰器

在主程序中组合模型和装饰器。

main.cpp
#include <iostream>
#include <memory>
#include "ModelA.h"
#include "LoggingDecorator.h"int main() {std::shared_ptr<Model> model = std::make_shared<ModelA>();std::shared_ptr<Model> decoratedModel = std::make_shared<LoggingDecorator>(model);if (decoratedModel) {decoratedModel->init();decoratedModel->process();decoratedModel->destroy();} else {std::cerr << "Model creation failed." << std::endl;}return 0;
}

解释虚函数 doInit(), doProcess(), doDestroy()

在基类中定义纯虚函数 doInit(), doProcess(), doDestroy() 的原因是:

  1. 强制子类实现:这些纯虚函数确保所有具体模型必须实现这些方法,定义了模型的基本行为接口。
  2. 实现分离:通过将公共逻辑和具体实现分离,基类可以实现公共的逻辑框架,而具体模型实现细节。
  3. 可扩展性:子类可以提供各自的具体实现,而无需修改基类,使系统具有良好的扩展性和灵活性。

通过使用装饰器模式,我们将公共逻辑封装在装饰器中,同时保留了具体模型的灵活性和可扩展性。这种设计既满足了代码复用的需求,又保持了系统的模块化和可维护性。

关键字:工厂模式和装饰器模式在程序设计中的体现

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

责任编辑: