C++ 设计模式概述
本文介绍了C++中23种设计模式的分类及实现示例，主要分为三大类：
创建型模式（5个）：单例模式（常用）、工厂方法模式（常用）、抽象工厂模式（常用）、建造者模式和原型模式。这些模式专注于对象的创建机制。
结构型模式（7个）：适配器模式（常用）、桥接模式、组合模式和装饰器模式（常用）等。这些模式处理类和对象的组合方式。
行为型模式：未完整列出，但包含观察者模式等（未展示完整代码）。
文章通过简洁的C++代码示例展示了常用设计模式的实现方法，如单例模式通过私有构造函数和静态方法确保唯一实例，工厂方法模式通过抽象工厂类创建产品等。这些模式为解决特定设计问题提供了可重用的解决方案。
C++ 设计模式概述及常用模式
设计模式可分为三大类：创建型、结构型、行为型。以下是23个设计模式的分类及代码示例：
一、创建型模式（5个）
1. 单例模式（Singleton）⭐常用
classSingleton{private:staticSingleton*instance;Singleton(){}// 私有构造函数public:staticSingleton*getInstance(){if(instance==nullptr){instance=newSingleton();}returninstance;}// 删除拷贝构造和赋值操作符Singleton(constSingleton&)=delete;Singleton&operator=(constSingleton&)=delete;};2. 工厂方法模式（Factory Method）⭐常用
// 产品接口classProduct{public:virtual~Product(){}virtualvoidoperation()=0;};// 具体产品classConcreteProductA:publicProduct{public:voidoperation()override{cout<<"Product A operation"<<endl;}};// 工厂接口classCreator{public:virtual~Creator(){}virtualProduct*factoryMethod()=0;};// 具体工厂classConcreteCreatorA:publicCreator{public:Product*factoryMethod()override{returnnewConcreteProductA();}};3. 抽象工厂模式（Abstract Factory）⭐常用
// 抽象产品AclassAbstractProductA{public:virtual~AbstractProductA(){}virtualvoidoperationA()=0;};// 抽象产品BclassAbstractProductB{public:virtual~AbstractProductB(){}virtualvoidoperationB()=0;};// 抽象工厂classAbstractFactory{public:virtualAbstractProductA*createProductA()=0;virtualAbstractProductB*createProductB()=0;};// 具体工厂1classConcreteFactory1:publicAbstractFactory{public:AbstractProductA*createProductA()override{returnnewConcreteProductA1();}AbstractProductB*createProductB()override{returnnewConcreteProductB1();}};4. 建造者模式（Builder）
classProduct{private:string partA;string partB;public:voidsetPartA(conststring&a){partA=a;}voidsetPartB(conststring&b){partB=b;}};classBuilder{public:virtual~Builder(){}virtualvoidbuildPartA()=0;virtualvoidbuildPartB()=0;virtualProduct*getResult()=0;};classDirector{private:Builder*builder;public:Director(Builder*b):builder(b){}voidconstruct(){builder->buildPartA();builder->buildPartB();}};5. 原型模式（Prototype）
classPrototype{public:virtual~Prototype(){}virtualPrototype*clone()const=0;virtualvoidprint()const=0;};classConcretePrototype:publicPrototype{private:intdata;public:ConcretePrototype(intd):data(d){}Prototype*clone()constoverride{returnnewConcretePrototype(*this);}voidprint()constoverride{cout<<"Data: "<<data<<endl;}};二、结构型模式（7个）
6. 适配器模式（Adapter）⭐常用
// 目标接口classTarget{public:virtual~Target(){}virtualvoidrequest(){cout<<"Target request"<<endl;}};// 需要适配的类classAdaptee{public:voidspecificRequest(){cout<<"Adaptee specific request"<<endl;}};// 适配器classAdapter:publicTarget{private:Adaptee*adaptee;public:Adapter(Adaptee*a):adaptee(a){}voidrequest()override{adaptee->specificRequest();}};7. 桥接模式（Bridge）
// 实现接口classImplementor{public:virtual~Implementor(){}virtualvoidoperationImpl()=0;};// 抽象类classAbstraction{protected:Implementor*impl;public:Abstraction(Implementor*i):impl(i){}virtual~Abstraction(){}virtualvoidoperation(){impl->operationImpl();}};8. 组合模式（Composite）
classComponent{public:virtual~Component(){}virtualvoidoperation()=0;virtualvoidadd(Component*){}virtualvoidremove(Component*){}virtualComponent*getChild(int){returnnullptr;}};classLeaf:publicComponent{public:voidoperation()override{cout<<"Leaf operation"<<endl;}};classComposite:publicComponent{private:vector<Component*>children;public:voidoperation()override{cout<<"Composite operation"<<endl;for(autochild:children){child->operation();}}voidadd(Component*c)override{children.push_back(c);}};9. 装饰器模式（Decorator）⭐常用
classComponent{public:virtual~Component(){}virtualvoidoperation()=0;};classConcreteComponent:publicComponent{public:voidoperation()override{cout<<"ConcreteComponent operation"<<endl;}};classDecorator:publicComponent{protected:Component*component;public:Decorator(Component*c):component(c){}voidoperation()override{component->operation();}};classConcreteDecorator:publicDecorator{public:ConcreteDecorator(Component*c):Decorator(c){}voidoperation()override{Decorator::operation();addedBehavior();}voidaddedBehavior(){cout<<"Added behavior"<<endl;}};10. 外观模式（Facade）⭐常用
classSubsystemA{public:voidoperationA(){cout<<"Subsystem A operation"<<endl;}};classSubsystemB{public:voidoperationB(){cout<<"Subsystem B operation"<<endl;}};classFacade{private:SubsystemA*a;SubsystemB*b;public:Facade():a(newSubsystemA()),b(newSubsystemB()){}voidoperation(){a->operationA();b->operationB();}};11. 享元模式（Flyweight）
classFlyweight{public:virtual~Flyweight(){}virtualvoidoperation(intextrinsicState)=0;};classConcreteFlyweight:publicFlyweight{private:intintrinsicState;public:ConcreteFlyweight(intstate):intrinsicState(state){}voidoperation(intextrinsicState)override{cout<<"Intrinsic: "<<intrinsicState<<", Extrinsic: "<<extrinsicState<<endl;}};classFlyweightFactory{private:unordered_map<int,Flyweight*>flyweights;public:Flyweight*getFlyweight(intkey){if(flyweights.find(key)==flyweights.end()){flyweights[key]=newConcreteFlyweight(key);}returnflyweights[key];}};12. 代理模式（Proxy）⭐常用
classSubject{public:virtual~Subject(){}virtualvoidrequest()=0;};classRealSubject:publicSubject{public:voidrequest()override{cout<<"RealSubject request"<<endl;}};classProxy:publicSubject{private:RealSubject*realSubject;public:Proxy():realSubject(nullptr){}voidrequest()override{if(realSubject==nullptr){realSubject=newRealSubject();}realSubject->request();}};三、行为型模式（11个）
13. 责任链模式（Chain of Responsibility）
classHandler{protected:Handler*successor;public:Handler():successor(nullptr){}virtual~Handler(){}voidsetSuccessor(Handler*s){successor=s;}virtualvoidhandleRequest(intrequest)=0;};classConcreteHandler1:publicHandler{public:voidhandleRequest(intrequest)override{if(request<10){cout<<"Handler1 handled request "<<request<<endl;}elseif(successor!=nullptr){successor->handleRequest(request);}}};14. 命令模式（Command）⭐常用
classReceiver{public:voidaction(){cout<<"Receiver action"<<endl;}};classCommand{public:virtual~Command(){}virtualvoidexecute()=0;};classConcreteCommand:publicCommand{private:Receiver*receiver;public:ConcreteCommand(Receiver*r):receiver(r){}voidexecute()override{receiver->action();}};classInvoker{private:Command*command;public:voidsetCommand(Command*c){command=c;}voidexecuteCommand(){command->execute();}};15. 解释器模式（Interpreter）
classContext{// 上下文信息};classExpression{public:virtual~Expression(){}virtualboolinterpret(Context&context)=0;};classTerminalExpression:publicExpression{public:boolinterpret(Context&context)override{// 终结符解释逻辑returntrue;}};16. 迭代器模式（Iterator）⭐常用
template<typenameT>classIterator{public:virtual~Iterator(){}virtualTnext()=0;virtualboolhasNext()=0;};template<typenameT>classConcreteIterator:publicIterator<T>{private:vector<T>collection;size_t position;public:ConcreteIterator(constvector<T>&col):collection(col),position(0){}Tnext()override{returncollection[position++];}boolhasNext()override{returnposition<collection.size();}};17. 中介者模式（Mediator）
classColleague;classMediator{public:virtual~Mediator(){}virtualvoidnotify(Colleague*sender,string event)=0;};classColleague{protected:Mediator*mediator;public:Colleague(Mediator*m=nullptr):mediator(m){}voidsetMediator(Mediator*m){mediator=m;}};classConcreteColleague1:publicColleague{public:voiddoSomething(){// ... 自己的逻辑mediator->notify(this,"event1");}};18. 备忘录模式（Memento）
classMemento{private:string state;public:Memento(conststring&s):state(s){}stringgetState()const{returnstate;}};classOriginator{private:string state;public:voidsetState(conststring&s){state=s;}stringgetState()const{returnstate;}Memento*createMemento(){returnnewMemento(state);}voidrestoreMemento(Memento*m){state=m->getState();}};19. 观察者模式（Observer）⭐常用
classObserver{public:virtual~Observer(){}virtualvoidupdate(floattemperature)=0;};classSubject{private:vector<Observer*>observers;public:voidattach(Observer*o){observers.push_back(o);}voiddetach(Observer*o){// 移除观察者逻辑}voidnotify(floattemperature){for(autoobserver:observers){observer->update(temperature);}}};classConcreteObserver:publicObserver{public:voidupdate(floattemperature)override{cout<<"Temperature updated: "<<temperature<<endl;}};20. 状态模式（State）
classContext;classState{public:virtual~State(){}virtualvoidhandle(Context*context)=0;};classContext{private:State*state;public:Context(State*s):state(s){}voidsetState(State*s){state=s;}voidrequest(){state->handle(this);}};classConcreteStateA:publicState{public:voidhandle(Context*context)override;};21. 策略模式（Strategy）⭐常用
classStrategy{public:virtual~Strategy(){}virtualvoidalgorithm()=0;};classConcreteStrategyA:publicStrategy{public:voidalgorithm()override{cout<<"Strategy A algorithm"<<endl;}};classContext{private:Strategy*strategy;public:Context(Strategy*s):strategy(s){}voidsetStrategy(Strategy*s){strategy=s;}voidexecuteStrategy(){strategy->algorithm();}};22. 模板方法模式（Template Method）⭐常用
classAbstractClass{public:virtual~AbstractClass(){}voidtemplateMethod(){primitiveOperation1();primitiveOperation2();}virtualvoidprimitiveOperation1()=0;virtualvoidprimitiveOperation2()=0;};classConcreteClass:publicAbstractClass{public:voidprimitiveOperation1()override{cout<<"Concrete operation 1"<<endl;}voidprimitiveOperation2()override{cout<<"Concrete operation 2"<<endl;}};23. 访问者模式（Visitor）
classConcreteElementA;classConcreteElementB;classVisitor{public:virtual~Visitor(){}virtualvoidvisit(ConcreteElementA*element)=0;virtualvoidvisit(ConcreteElementB*element)=0;};classElement{public:virtual~Element(){}virtualvoidaccept(Visitor*visitor)=0;};classConcreteElementA:publicElement{public:voidaccept(Visitor*visitor)override{visitor->visit(this);}voidoperationA(){cout<<"Operation A"<<endl;}};四、最常用的设计模式（建议优先掌握）
必须掌握的5个核心模式：
- 单例模式- 全局唯一实例，如配置管理器、日志管理器
- 工厂方法模式- 对象创建解耦，易于扩展
- 观察者模式- 事件处理、消息通知系统
- 策略模式- 算法封装，运行时切换
- 装饰器模式- 动态添加功能
次常用的5个模式：
- 适配器模式- 接口转换
- 代理模式- 访问控制、延迟加载
- 模板方法模式- 算法框架定义
- 命令模式- 命令封装、撤销/重做
- 外观模式- 简化复杂子系统接口
学习建议：
- 先从单例、工厂、观察者、策略开始学习
- 理解每种模式的应用场景而不仅仅是代码
- 避免过度设计，只在必要时使用设计模式
- C++11/14/17的现代特性（智能指针、lambda等）可以简化某些模式的实现
这些模式提供了经过验证的解决方案，能帮助你构建更灵活、可维护的软件系统。