状态、命令和观察者模式(行为型设计模式)的 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
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!