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