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

前言

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

---

代码仓库

• yezhening/Programming-examples: 编程实例 (github.com)
• Programming-examples: 编程实例 (gitee.com)

---

状态模式（State）

结构

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

代码

#include 

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 

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 
#include 
#include 
#include 

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博客

---

作者的话

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

---