1、观察者模式（Observer）
原理：实现一对多的依赖关系。被观察者（发布者）维护一份观察者订阅列表；当自身状态发生改变，主动遍历列表发送通知，所有订阅的观察者自动收到回调。发布方和订阅方解耦。 使用场景：网络事件通知、配置热更新、消息订阅‑发布、事件驱动系统。
#include <iostream>
#include <vector>
using namespace std;
class Observer
{
public:
virtual void update(int msg) = 0;
virtual ~Observer() = default;
};
class Subject
{
private:
vector<Observer*> obsList;
public:
void attach(Observer* o)
{
obsList.push_back(o);
}
void notify(int msg)
{
for(auto o : obsList)
{
o->update(msg);
}
}
};
class ConcreteObserver : public Observer
{
public:
void update(int msg) override
{
cout << "观察者收到消息：" << msg << endl;
}
};
int main()
{
Subject publisher;
ConcreteObserver sub;
publisher.attach(&sub);
publisher.notify(666);
return 0;
}
一句话归纳：发布者状态变更，自动通知所有订阅者。
2、模板方法模式（Template‑Method）
原理：父类定义好算法完整的执行骨架与步骤顺序，部分可变步骤声明为纯虚函数交给子类重写实现。父类把控流程，子类只能填充细节，不能修改执行顺序。 使用场景：任务生命周期流程、框架固定流程、初始化‑执行‑释放三步流程。
#include <iostream>
using namespace std;
class Template
{
public:
void run()
{
step1();
step2();
step3();
}
protected:
virtual void step1(){cout<<"通用前置步骤1\n";}
virtual void step2() = 0;
virtual void step3(){cout<<"通用收尾步骤3\n";}
virtual ~Template()=default;
};
class BusinessTask : public Template
{
protected:
void step2() override
{
cout<<"子类实现的业务步骤2\n";
}
};
int main()
{
BusinessTask task;
task.run();
return 0;
}
一句话归纳：父类定流程骨架，子类实现可变步骤。
3、策略模式（Strategy）
原理：把一系列可互换的算法，各自封装成独立的策略类；上下文类持有策略对象，运行期可以动态替换不同算法，消除大量 if‑else 分支判断。 使用场景：加密算法切换、调度策略、序列化方案选择。
#include <iostream>
using namespace std;
class Strategy
{
public:
virtual void execute() = 0;
virtual ~Strategy() = default;
};
class FastStrategy : public Strategy
{
public:
void execute() override {cout<<"执行快速模式算法\n";}
};
class SafeStrategy : public Strategy
{
public:
void execute() override {cout<<"执行安全稳定算法\n";}
};
class Context
{
private:
Strategy* st;
public:
void setStrategy(Strategy* s){st = s;}
void run(){st->execute();}
};
int main()
{
Context ctx;
FastStrategy fast;
ctx.setStrategy(&fast);
ctx.run();
return 0;
}
一句话归纳：算法独立封装，运行时可动态切换替换。
4、命令模式（Command）
原理：将一次请求、一条操作封装成为独立的命令对象；命令对象保存接收者，调用者只触发命令，不需要关心具体执行逻辑；支持命令排队、日志记录、撤销重做。 使用场景：异步任务队列、操作撤销功能、网络远程请求封装。
#include <iostream>
using namespace std;
//接收者，实际干活
class Receiver
{
public:
void action(){cout<<"接收者执行真实业务操作\n";}
};
class Command
{
public:
virtual void execute() = 0;
virtual ~Command() = default;
};
class ConcreteCommand : public Command
{
private:
Receiver* rec;
public:
ConcreteCommand(Receiver* r):rec(r){}
void execute() override
{
rec->action();
}
};
//调用者，发起请求
class Invoker
{
private:
Command* cmd;
public:
void setCmd(Command* c){cmd = c;}
void trigger(){cmd->execute();}
};
int main()
{
Receiver r;
Command* cmd = new ConcreteCommand(&r);
Invoker inv;
inv.setCmd(cmd);
inv.trigger();
delete cmd;
return 0;
}
一句话归纳：把请求封装成对象，实现请求排队与撤销。
5、迭代器模式（Iterator）
原理：提供统一的迭代遍历接口，顺序访问容器内部元素，同时对外隐藏容器底层存储的数据结构。C++ STL 迭代器就是典型实现。 使用场景：自定义容器遍历，统一不同容器的遍历接口。
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
class Iterator
{
public:
virtual bool hasNext() = 0;
virtual T next() = 0;
virtual ~Iterator() = default;
};
template<typename T>
class VectorIterator : public Iterator<T>
{
private:
vector<T>& vec;
int index = 0;
public:
VectorIterator(vector<T>& v):vec(v){}
bool hasNext() override
{
return index < vec.size();
}
T next() override
{
return vec[index++];
}
};
int main()
{
vector<int> arr{10,20,30,40};
Iterator<int>* it = new VectorIterator<int>(arr);
while(it->hasNext())
{
cout<<it->next()<<" ";
}
delete it;
return 0;
}
一句话归纳：统一遍历容器元素，隐藏容器内部存储细节。
6、责任链模式（Chain‑of‑Responsibility）
原理：多个处理器对象连成一条链条；请求沿着链条依次向下传递，直到某个处理器选择处理该请求；请求发送者不知道最终谁处理了请求，发送者与处理者解耦。 使用场景：网关鉴权过滤器、日志分级打印、请求多级校验。
#include <iostream>
using namespace std;
class Handler
{
protected:
Handler* next = nullptr;
public:
void setNext(Handler* h){next = h;}
virtual void handle(int req) = 0;
virtual ~Handler() = default;
};
class HandlerA : public Handler
{
public:
void handle(int req) override
{
if(req < 10)
{
cout<<"处理器A处理请求:"<<req<<endl;
}
else if(next)
{
next->handle(req);
}
}
};
class HandlerB : public Handler
{
public:
void handle(int req) override
{
cout<<"处理器B处理请求:"<<req<<endl;
}
};
int main()
{
Handler* a = new HandlerA();
Handler* b = new HandlerB();
a->setNext(b);
a->handle(20);
delete a;
delete b;
return 0;
}
一句话归纳：请求沿处理器链条传递，直至被对象处理。
7、状态模式（State）
原理：把对象每一种状态封装为独立的状态类；当上下文对象内部状态发生切换时，自动调用对应状态类的行为；消除大量状态判断的 if‑else，实现状态机。 使用场景：网络连接状态机、协议状态流转、任务生命周期管理。
#include <iostream>
using namespace std;
class Context;
class State
{
public:
virtual void handle(Context* ctx) = 0;
virtual ~State() = default;
};
class Context
{
public:
State* state;
Context(State* s):state(s){}
void setState(State* s){state = s;}
void request(){state->handle(this);}
};
class ConnectedState : public State
{
public:
void handle(Context* ctx) override
{
cout<<"当前处于连接成功状态\n";
}
};
int main()
{
State* conn = new ConnectedState();
Context ctx(conn);
ctx.request();
delete conn;
return 0;
}
一句话归纳：对象状态改变，自动切换对应的行为逻辑。
8、备忘录模式（Memento）
原理：在不破坏封装性的前提下，捕获一个对象某一刻的内部状态并保存为快照；之后可以将对象恢复到此快照状态。分为原发器、备忘录、负责人。 使用场景：操作撤销回滚、游戏存档、配置版本恢复。
#include <iostream>
#include <string>
using namespace std;
//备忘录，存储状态快照
class Memento
{
private:
string state;
public:
Memento(string s):state(s){}
string getState(){return state;}
};
//原发器
class Originator
{
private:
string state;
public:
void setState(string s){state = s;}
Memento* save(){return new Memento(state);}
void restore(Memento* m)
{
state = m->getState();
cout<<"恢复后的状态："<<state<<endl;
}
};
int main()
{
Originator obj;
obj.setState("版本A");
Memento* snap = obj.save();
obj.setState("版本B");
obj.restore(snap);
delete snap;
return 0;
}
一句话归纳：保存对象状态快照，支持后续回滚恢复。
9、中介者模式（Mediator）
原理：引入一个中介调度中心；各个同事对象之间禁止直接互相通信，所有交互都必须经过中介转发；解除多对象之间网状依赖关系，降低耦合。 使用场景：聊天室、多模块消息中转、组件之间调度中心。
#include <iostream>
#include <string>
using namespace std;
class Colleague;
class Mediator
{
public:
virtual void send(string msg, Colleague* sender) = 0;
virtual ~Mediator() = default;
};
class Colleague
{
protected:
Mediator* med;
public:
Colleague(Mediator* m):med(m){}
virtual void receive(string msg) = 0;
virtual void send(string msg) = 0;
virtual ~Colleague() = default;
};
class ChatRoom : public Mediator
{
public:
void send(string msg, Colleague* sender) override
{
sender->receive(msg);
}
};
class User : public Colleague
{
public:
User(Mediator* m):Colleague(m){}
void send(string msg) override
{
med->send(msg, this);
}
void receive(string msg) override
{
cout<<"用户收到消息："<<msg<<endl;
}
};
int main()
{
Mediator* chat = new ChatRoom();
User u(chat);
u.send("Hello World");
delete chat;
return 0;
}
一句话归纳：所有对象通过中间人通信，消除对象间直接依赖。
10、访问者模式（Visitor）
原理：把数据结构和数据操作解耦。在不修改原有元素类代码的前提下，新增访问者类来定义新的操作；适合数据结构稳定，但算法操作经常变化的场景。 使用场景：语法树遍历、对一组稳定元素执行多种统计操作。
#include <iostream>
using namespace std;
class Element;
class Visitor
{
public:
virtual void visit(Element* e) = 0;
virtual ~Visitor() = default;
};
class Element
{
public:
virtual void accept(Visitor* v) = 0;
virtual ~Element() = default;
};
class ConcreteElement : public Element
{
public:
void accept(Visitor* v) override
{
v->visit(this);
}
};
class PrintVisitor : public Visitor
{
public:
void visit(Element* e) override
{
cout<<"访问者执行打印操作\n";
}
};
int main()
{
Element* elem = new ConcreteElement();
Visitor* vis = new PrintVisitor();
elem->accept(vis);
delete elem;
delete vis;
return 0;
}
一句话归纳：不改动元素类，通过访问者新增元素操作。
11、解释器模式（Interpreter）
原理：定义一套文法规则，构建解释器，用来解析自定义表达式或者小型脚本语言。 使用场景：简单表达式解析、自定义规则脚本引擎；后端业务开发极少使用。
#include <iostream>
using namespace std;
class Expression
{
public:
virtual int interpret() = 0;
virtual ~Expression() = default;
};
class NumberExpr : public Expression
{
private:
int val;
public:
NumberExpr(int v):val(v){}
int interpret() override
{
return val;
}
};
int main()
{
Expression* num = new NumberExpr(100);
cout<<num->interpret()<<endl;
delete num;
return 0;
}
一句话归纳：用于解析自定义语法表达式，实现简单脚本解释。