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

2023-12-23 19:26:55

文章目录

前言
代码仓库
状态模式（State）
命令模式（Command）
观察者模式（Observer）
总结
参考资料
作者的话

前言

状态、命令和观察者模式（行为型设计模式）的 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++ 代码示例模板。

参考资料

行为型设计模式总结_设计模式行为型模式的设计与实现心得体会-CSDN博客

作者的话

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

文章来源:https://blog.csdn.net/m0_62083249/article/details/135147468
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！