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

时间：2024-06-01 18:42:15

工厂模式

Step 1: 更新基类

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

model.h

#ifndef MODEL_H
#define MODEL_H

class 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_H

class 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. 可扩展性：子类可以提供各自的具体实现，而无需修改基类，使系统具有良好的扩展性和灵活性。

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

相关文章