模板方法、策略和职责链模式(行为型设计模式)的 C++ 代码示例模板

2023-12-22 12:09:46

前言

模板方法、策略和职责链模式(行为型设计模式)的 C++ 代码示例模板。


代码仓库


模板方法模式(Template Method)

结构

  • 抽象类
  • 具体类
  • 抽象类 声明 步骤方法(零个或多个)(由派生类重写/实现)
  • 抽象类 定义 模板方法。形式上 调用 模板方法,实际上 调用 步骤方法。即 哪些 步骤方法 何时 调用(规定组合内容和执行时序)(抽象的模板,不变行为)
  • 具体类(零个或多个) 重写/实现 步骤方法 (具体的步骤,变化行为)
  • 抽象类指针(实际上指向一个具体类) 调用 抽象类/父类的模板方法 就是一个方案

代码

#include <iostream>

using std::cout;
using std::endl;

// 抽象类
class Abstraction
{
public:
    // 抽象类 定义 模板方法
    void template_method() // 形式上 调用 模板方法
    {
        cout << "template_method()" << endl;
        // 实际上 调用 步骤方法。即 哪些 步骤方法 何时 调用(规定组合内容和执行时序) (抽象的模板,不变行为)
        step_func_1();
        step_func_2();
    }

protected:
    // 抽象类 声明 步骤方法(零个或多个)(由派生类重写/实现)
    // 步骤方法1
    virtual void step_func_1() = 0;
    // 步骤方法2
    virtual void step_func_2() = 0;
};

// 具体1类
// 具体类(零个或多个) 重写/实现 步骤方法 (具体的步骤,变化行为)
class Concreteness1 : public Abstraction
{
protected:
    void step_func_1() override
    {
        cout << "Concreteness1 - step_func_1()" << endl;
    }

    void step_func_2() override
    {
        cout << "Concreteness1 - step_func_2()" << endl;
    }
};

// 具体1类
class Concreteness2 : public Abstraction
{
protected:
    void step_func_1() override
    {
        cout << "Concreteness2 - step_func_1()" << endl;
    }

    void step_func_2() override
    {
        cout << "Concreteness2 - step_func_2()" << endl;
    }
};

// 客户端
int main()
{
    // 抽象类指针(实际上指向一个具体类)
    Abstraction *abstraction_1 = new Concreteness1();
    abstraction_1->template_method(); // 抽象类指针(实际上指向一个具体类) 调用 抽象类/父类的模板方法 就是一个方案
    delete abstraction_1;

    cout << endl;

    Abstraction *abstraction_2 = new Concreteness2();
    abstraction_2->template_method();
    delete abstraction_2;

    return 0;
}
/*
输出:
template_method()
Concreteness1 - step_func_1()
Concreteness1 - step_func_2()

template_method()
Concreteness2 - step_func_1()
Concreteness2 - step_func_2()
*/

策略模式(Strategy)

结构

  • 抽象策略类
  • 具体策略类
  • 上下文类
  • 上下文类 封装 抽象策略指针(实际上指向一个具体策略对象)
  • 上下文类 封装 设置策略方法 和 执行策略方法
  • 形式上调用 上下文对象的 执行策略方法,实际上调用 具体策略对象的 执行方法

代码

#include <iostream>

using std::cout;
using std::endl;

// 抽象策略类
class AbstractStrategy
{
public:
    virtual void execute() = 0;
};

// 具体策略1类
class ConcreteStrategy1 : public AbstractStrategy
{
public:
    void execute() override
    {
        cout << "ConcreteStrategy1" << endl;
    }
};

// 具体策略2类
class ConcreteStrategy2 : public AbstractStrategy
{
public:
    void execute() override
    {
        cout << "ConcreteStrategy2" << endl;
    }
};

// 上下文类
// 上下文类 封装 抽象策略指针(实际上指向一个具体策略对象)
class Context
{
public:
    Context(AbstractStrategy *strategy) : strategy(strategy) {}

    // 设置策略方法
    void set_strategy(AbstractStrategy *strategy)
    {
        this->strategy = strategy;
    }

    // 执行策略方法
    void execute_strategy() // 形式上调用 上下文对象的 执行策略方法
    {
        this->strategy->execute(); // 实际上调用 具体策略对象的 执行方法
    }

private:
    AbstractStrategy *strategy;
};

// 客户端
int main()
{
    // 具体策略对象
    ConcreteStrategy1 concrete_strategy_1;
    ConcreteStrategy2 concrete_strategy_2;

    // 上下文对象
    Context context(&concrete_strategy_1); // 设置策略
    context.execute_strategy();            // 执行策略

    context.set_strategy(&concrete_strategy_2); // 设置策略
    context.execute_strategy();

    return 0;
}
/*
输出:
ConcreteStrategy1
ConcreteStrategy2
*/

职责链模式(Chain of Responsibility/CoR)

结构

  • 请求类
  • 抽象处理者类
  • 具体处理者类
  • 抽象处理者类 封装 抽象处理者指针(实际上指向一个具体处理者对象,该对象是当前具体处理对象的下一个具体处理对象/下一个处理者/继任者)
  • 抽象处理者类 封装 设置继任者方法 和 处理请求方法(如果有继任者,继任者 调用 处理请求方法处理请求;如果没有继任者,无法处理请求)
  • 具体处理者类 重写 处理请求方法(获取并判断请求的类型,如果有权处理请求,当前具体处理对象处理请求;如果无权处理请求,调用基类/抽象处理者类的处理请求方法(将请求交给继任者处理))

代码

#include <iostream>

using std::cout;
using std::endl;

// 请求类
class Request
{
public:
    Request(int type) : type(type) {}

    // 获取请求的类型
    int get_type()
    {
        return this->type;
    }

private:
    int type; // 请求的类型
};

// 抽象处理者类
class AbstractHandler
{
public:
    virtual ~AbstractHandler()
    {
        delete this->successor;
    }

    // 设置继任者方法
    void set_successor(AbstractHandler *successor)
    {
        this->successor = successor;
    }

    // 处理请求方法
    virtual void handle_request(Request request)
    {
        if (this->successor != nullptr) // 如果有继任者,继任者 调用 处理请求方法处理请求
        {
            this->successor->handle_request(request);
        }
        else // 如果没有继任者,无法处理请求
        {
            cout << "Request not handled" << endl;
        }
    }

protected:
    // 抽象处理者类 封装 抽象处理者指针(实际上指向一个具体处理者对象,该对象是当前具体处理对象的下一个具体处理对象/下一个处理者/继任者)
    AbstractHandler *successor = nullptr; // 默认没有继任者
};

// 具体处理者1类
// 具体处理者类 重写 处理请求方法
class ConcreteHandler1 : public AbstractHandler
{
public:
    void handle_request(Request request) override
    {
        // 获取并判断请求的类型
        if (request.get_type() == 1) // 如果有权处理请求,当前具体处理对象处理请求
        {
            cout << "ConcreteHandler1 handles the request" << endl;
        }
        else // 如果无权处理请求,调用基类/抽象处理者类的处理请求方法(将请求交给继任者处理)
        {
            AbstractHandler::handle_request(request);
        }
    }
};

// 具体处理者2
class ConcreteHandler2 : public AbstractHandler
{
public:
    void handle_request(Request request) override
    {
        if (request.get_type() == 2)
        {
            cout << "ConcreteHandler2 handles the request" << endl;
        }
        else
        {
            AbstractHandler::handle_request(request);
        }
    }
};

// 客户端
int main()
{
    // 抽象处理者指针(实际上指向一个具体处理者对象)
    AbstractHandler *concrete_handler_1 = new ConcreteHandler1();
    AbstractHandler *concrete_handler_2 = new ConcreteHandler2();

    // 设置处理者链:concrete_handler_1 -> concrete_handler_2
    concrete_handler_1->set_successor(concrete_handler_2);

    // 请求对象
    Request request_1(1); // 1类型的请求
    Request request_2(2);
    Request request_3(3);

    // 处理请求
    concrete_handler_1->handle_request(request_1);
    concrete_handler_1->handle_request(request_2);
    concrete_handler_1->handle_request(request_3);
    // 1类型的请求,具体处理1对象有权处理
    // 2类型的请求,具体处理1对象无权处理,将请求交给继任者处理;具体处理2对象有权处理
    // 3类型的请求,具体处理1对象无权处理,将请求交给继任者处理;具体处理2对象无权处理,没有继任者;无法处理请求

    delete concrete_handler_1; // 递归析构 delete concrete_handler_2

    return 0;
}
/*
输出:
ConcreteHandler1 handles the request
ConcreteHandler2 handles the request
Request not handled
*/

总结

模板方法、策略和职责链模式(行为型设计模式)的 C++ 代码示例模板。


参考资料


作者的话

  • 感谢参考资料的作者/博主
  • 作者:夜悊
  • 版权所有,转载请注明出处,谢谢~
  • 如果文章对你有帮助,请点个赞或加个粉丝吧,你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方,请留言,定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获

文章来源:https://blog.csdn.net/m0_62083249/article/details/135124340
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。