状态、命令和观察者模式(行为型设计模式)的 C++ 代码示例模板

2023-12-23 19:26:55

前言

状态、命令和观察者模式(行为型设计模式)的 C++ 代码示例模板。


代码仓库


状态模式(State)

结构

  • 抽象状态类
  • 具体状态类
  • 上下文类
  • 抽象状态类 封装 处理方法
  • 具体状态类 重写 处理方法
  • 上下文类 封装 抽象状态指针(实际上指向一个具体状态对象)
  • 上下文类 封装 转换状态方法(删除上一个状态即当前状态, 保存下一个状态为当前状态)
  • 上下文类 封装 处理状态方法(形式上 调用 上下文类的 处理状态方法,实际上 调用 具体状态对象的处理方法)

代码

#include <iostream>

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

// 抽象状态类
// 抽象状态类 封装 处理方法
class AbstractState
{
public:
    virtual void handle() = 0;
};

// 具体状态1类
// 具体状态类 重写 处理方法
class ConcreteState1 : public AbstractState
{
public:
    void handle() override
    {
        cout << "ConcreteState1" << endl;
    }
};

// 具体状态2类
class ConcreteState2 : public AbstractState
{
public:
    void handle() override
    {
        cout << "ConcreteState2" << endl;
    }
};

// 上下文类
// 上下文类 封装 抽象状态指针(实际上指向一个具体状态对象)
class Context
{
public:
    // 转换状态方法
    void convert_state(AbstractState *next_state)
    {
        delete this->current_state;       // 删除上一个状态即当前状态
        this->current_state = next_state; // 保存下一个状态为当前状态
    }

    // 处理状态方法
    void handle_state() // 形式上 调用 上下文类的 处理状态方法
    {
        this->current_state->handle(); // 实际上 调用 具体状态对象的处理方法
    }

private:
    AbstractState *current_state = nullptr; // 当前状态,默认为空
};

// 客户端
int main()
{
    // 抽象状态指针(实际上指向一个具体状态对象)
    AbstractState *abstract_state_1 = new ConcreteState1();
    AbstractState *abstract_state_2 = new ConcreteState2();

    // 上下文对象
    Context context;

    context.convert_state(abstract_state_1); // 转换状态 nullptr -> abstract_state_1
    context.handle_state();                  // 处理状态

    context.convert_state(abstract_state_2);
    context.handle_state();

    delete abstract_state_2;
    // delete abstract_state_1; 转换状态时隐式析构

    return 0;
}
/*
输出:
ConcreteState1
ConcreteState2
*/

命令模式(Command)

结构

  • 接收者类
  • 抽象命令类
  • 具体命令类
  • 发送者类
  • 接收者类 封装 行为方法
  • 抽象命令类 封装 执行方法
  • 具体命令类 重写 执行方法(形式上 调用 具体命令对象的执行方法,实际上 调用 接收者对象的行为方法)
  • 具体命令类 封装 接收者对象(如果在 抽象命令类 封装 接收者对象,接收者类型一致;如果在 具体命令类 封装 接收者对象,接收者类型可以不同)
  • 发送者类 封装 抽象命令指针(实际上指向一个具体命令对象)
  • 发送者类 封装 设置命令方法 和 执行命令方法(形式上 调用 发送者对象的执行命令方法,实际上 调用 具体命令对象的执行方法)
  • 命令执行过程:发送者 调用 执行命令方法 -> 命令 调用 执行方法 -> 接收者 调用 行为方法

代码

#include <iostream>

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

// 接收者类
// 接收者类 封装 行为方法
class Receiver
{
public:
    void action()
    {
        cout << "Receiver" << endl;
    }
};

// 抽象命令类
// 抽象命令类 封装 执行方法
class AbstractCommand
{
public:
    virtual void execute() = 0;
};

// 具体命令类
// 具体命令类 重写 执行方法
// 具体命令类 封装 接收者对象
class ConcreteCommand : public AbstractCommand
{
public:
    ConcreteCommand() : receiver() {} // 接收者类的默认构造方法 初始化 接收者对象

    virtual void execute() override // 形式上 调用 具体命令对象的执行方法
    {
        receiver.action(); // 实际上 调用 接收者对象的行为方法
    }

private:
    Receiver receiver;
    // 如果在 抽象命令类 封装 接收者对象,接收者类型一致
    // 如果在 具体命令类 封装 接收者对象,接收者类型可以不同
};

// 发送者类
class Sender
{
public:
    // 设置命令方法
    void set_command(AbstractCommand *abstract_command)
    {
        this->abstract_command = abstract_command;
    }

    // 执行命令方法
    void execute_command() // 形式上 调用 发送者对象的执行命令方法
    {
        this->abstract_command->execute(); // 实际上 调用 具体命令对象的执行方法
    }

private:
    // 封装 抽象命令指针(实际上指向一个具体命令对象)
    AbstractCommand *abstract_command;
};

// 客户端
int main()
{
    // 抽象命令指针(实际上指向一个具体命令对象)
    AbstractCommand *abstract_command = new ConcreteCommand();

    // 发送者对象
    Sender sender;
    sender.set_command(abstract_command); // 设置命令
    sender.execute_command();             // 执行命令
    // 命令执行过程:发送者 调用 执行命令方法 -> 命令 调用 执行方法 -> 接收者 调用 行为方法
    // ender.execute_command() -> this->abstract_command->execute() -> receiver.action()

    delete abstract_command;

    return 0;
}
/*
输出:
Receiver
*/

观察者模式(Observer)

结构

  • 抽象观察者类
  • 具体观察者类
  • 抽象目标类
  • 具体目标类
  • 抽象观察者类 封装 更新方法
  • 具体观察者类 重写 更新方法
  • 抽象目标类 封装 抽象观察者指针(实际上指向一个具体观察者对象)的集合属性,添加观察者方法,移除观察者方法,通知观察者方法(形式上 调用 具体目标对象的 通知观察者方法,实际上 调用 具体观察者对象的 更新方法)
  • 抽象目标类 封装 状态属性,设置状态方法(设置状态后,通知观察者),获取状态方法
  • 观察过程:目标设置(改变)状态 -> 通知观察者 -> 观察者更新

代码

#include <string>
#include <iostream>
#include <vector>
#include <algorithm>

using std::cout;
using std::endl;
using std::string;
using std::vector;

// 抽象观察者类
class AbstractObserver
{
public:
    // 更新方法
    virtual void update(string message) = 0;
};

// 具体观察者
class ConcreteObserver : public AbstractObserver
{
public:
    ConcreteObserver(string name) : name(name) {}

    // (重写)更新方法
    void update(string message) override
    {
        cout << "Observer " << this->name << " receives message: " << message << endl;
    }

private:
    string name; // 名称
};

// 抽象目标类
class AbstractTarget
{
public:
    virtual ~AbstractTarget()
    {
        for (AbstractObserver *observer : this->observer_vec)
        {
            delete observer;
        }
        this->observer_vec.clear();
    }

    // 添加观察者方法
    void add_observer(AbstractObserver *observer)
    {
        this->observer_vec.push_back(observer);
    }

    // 移除观察者方法
    void remove_observer(AbstractObserver *observer)
    {
        vector<AbstractObserver *>::iterator it = std::remove(this->observer_vec.begin(), this->observer_vec.end(), observer);
        this->observer_vec.erase(it, this->observer_vec.end());
        // 移除的观察者可能还需要,这里不 delete,由客户端构造和析构
    }

    // 通知观察者方法
    void notify_observer(string message)
    {
        for (AbstractObserver *observer : this->observer_vec) // 形式上 调用 具体目标对象的 通知观察者方法
        {
            observer->update(message); // 实际上 调用 具体观察者对象的 更新方法
        }
    }

    // 设置状态方法
    void set_state(string state)
    {
        this->state = state;
        this->notify_observer("State changes to: " + this->state); // 设置状态后,通知观察者
    }

    // 获取状态方法
    // string get_state()
    // {
    //     return this->state;
    // }

private:
    // 抽象观察者指针(实际上指向一个具体观察者对象)的集合属性
    vector<AbstractObserver *> observer_vec;
    string state; // 状态属性
};

// 具体目标类
class ConcreteTarget : public AbstractTarget
{
    // 简单实现,不需要额外内容
};

// 客户端
int main()
{
    // 具体目标类
    ConcreteTarget concrete_target;

    // 具体观察者对象
    AbstractObserver *concrete_observer_1 = new ConcreteObserver("concrete_observer_1");
    AbstractObserver *concrete_observer_2 = new ConcreteObserver("concrete_observer_2");

    // 添加观察者
    concrete_target.add_observer(concrete_observer_1); // 具体观察者对象1 观察 具体目标
    concrete_target.add_observer(concrete_observer_2); // 具体观察者对象2 观察 具体目标

    // 设置状态
    concrete_target.set_state("state1");
    // 观察过程:
    // 目标设置(改变)状态 -> 通知观察者 -> 观察者更新
    // concrete_target.set_state() -> this->notify_observer() -> observer->update()

    // 移除观察者
    concrete_target.remove_observer(concrete_observer_1);
    delete concrete_observer_1;

    // 设置状态
    concrete_target.set_state("state2");

    // 局部变量 concrete_target 销毁,隐式析构 delete concrete_observer_2

    return 0;
}
/*
输出:
Observer concrete_observer_1 receives message: State changes to: state1
Observer concrete_observer_2 receives message: State changes to: state1
Observer concrete_observer_2 receives message: State changes to: state2
*/

总结

状态、命令模式和观察者模式(行为型设计模式)的 C++ 代码示例模板。


参考资料


作者的话

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

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