C++ 设计模式概述及常用模式

Ne0inhk

— 7 min read
C++ 设计模式概述
本文介绍了C++中23种设计模式的分类及实现示例，主要分为三大类：

创建型模式（5个）：单例模式（常用）、工厂方法模式（常用）、抽象工厂模式（常用）、建造者模式和原型模式。这些模式专注于对象的创建机制。

结构型模式（7个）：适配器模式（常用）、桥接模式、组合模式和装饰器模式（常用）等。这些模式处理类和对象的组合方式。

行为型模式：未完整列出，但包含观察者模式等（未展示完整代码）。

文章通过简洁的C++代码示例展示了常用设计模式的实现方法，如单例模式通过私有构造函数和静态方法确保唯一实例，工厂方法模式通过抽象工厂类创建产品等。这些模式为解决特定设计问题提供了可重用的解决方案。

C++ 设计模式概述及常用模式

设计模式可分为三大类：创建型、结构型、行为型。以下是23个设计模式的分类及代码示例：

一、创建型模式（5个）

1. 单例模式（Singleton）⭐ 常用

classSingleton{private:static Singleton* instance;Singleton(){}// 私有构造函数public:static Singleton*getInstance(){if(instance ==nullptr){ instance =newSingleton();}return instance;}// 删除拷贝构造和赋值操作符Singleton(const Singleton&)=delete; Singleton&operator=(const Singleton&)=delete;};

2. 工厂方法模式（Factory Method）⭐ 常用

// 产品接口classProduct{public:virtual~Product(){}virtualvoidoperation()=0;};// 具体产品classConcreteProductA:publicProduct{public:voidoperation() override { cout <<"Product A operation"<< endl;}};// 工厂接口classCreator{public:virtual~Creator(){}virtual Product*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:virtual AbstractProductA*createProductA()=0;virtual AbstractProductB*createProductB()=0;};// 具体工厂1classConcreteFactory1:publicAbstractFactory{public: AbstractProductA*createProductA() override {returnnewConcreteProductA1();} AbstractProductB*createProductB() override {returnnewConcreteProductB1();}};

4. 建造者模式（Builder）

classProduct{private: string partA; string partB;public:voidsetPartA(const string& a){ partA = a;}voidsetPartB(const string& b){ partB = b;}};classBuilder{public:virtual~Builder(){}virtualvoidbuildPartA()=0;virtualvoidbuildPartB()=0;virtual Product*getResult()=0;};classDirector{private: Builder* builder;public:Director(Builder* b):builder(b){}voidconstruct(){ builder->buildPartA(); builder->buildPartB();}};

5. 原型模式（Prototype）

classPrototype{public:virtual~Prototype(){}virtual Prototype*clone()const=0;virtualvoidprint()const=0;};classConcretePrototype:publicPrototype{private:int data;public:ConcretePrototype(int d):data(d){} Prototype*clone()const override {returnnewConcretePrototype(*this);}voidprint()const override { 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*){}virtual Component*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(auto child : 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(int extrinsicState)=0;};classConcreteFlyweight:publicFlyweight{private:int intrinsicState;public:ConcreteFlyweight(int state):intrinsicState(state){}voidoperation(int extrinsicState) override { cout <<"Intrinsic: "<< intrinsicState <<", Extrinsic: "<< extrinsicState << endl;}};classFlyweightFactory{private: unordered_map<int, Flyweight*> flyweights;public: Flyweight*getFlyweight(int key){if(flyweights.find(key)== flyweights.end()){ flyweights[key]=newConcreteFlyweight(key);}return flyweights[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(int request)=0;};classConcreteHandler1:publicHandler{public:voidhandleRequest(int request) 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(){}virtual T next()=0;virtualboolhasNext()=0;};template<typenameT>classConcreteIterator:publicIterator<T>{private: vector<T> collection; size_t position;public:ConcreteIterator(const vector<T>& col):collection(col),position(0){} T next() override {return collection[position++];}boolhasNext() override {return position < 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(const string& s):state(s){} string getState()const{return state;}};classOriginator{private: string state;public:voidsetState(const string& s){ state = s;} string getState()const{return state;} Memento*createMemento(){returnnewMemento(state);}voidrestoreMemento(Memento* m){ state = m->getState();}};

19. 观察者模式（Observer）⭐ 常用

classObserver{public:virtual~Observer(){}virtualvoidupdate(float temperature)=0;};classSubject{private: vector<Observer*> observers;public:voidattach(Observer* o){ observers.push_back(o);}voiddetach(Observer* o){// 移除观察者逻辑}voidnotify(float temperature){for(auto observer : observers){ observer->update(temperature);}}};classConcreteObserver:publicObserver{public:voidupdate(float temperature) 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个核心模式：

  1. 单例模式 - 全局唯一实例，如配置管理器、日志管理器
  2. 工厂方法模式 - 对象创建解耦，易于扩展
  3. 观察者模式 - 事件处理、消息通知系统
  4. 策略模式 - 算法封装，运行时切换
  5. 装饰器模式 - 动态添加功能

次常用的5个模式：

  1. 适配器模式 - 接口转换
  2. 代理模式 - 访问控制、延迟加载
  3. 模板方法模式 - 算法框架定义
  4. 命令模式 - 命令封装、撤销/重做
  5. 外观模式 - 简化复杂子系统接口

学习建议：

  1. 先从单例、工厂、观察者、策略开始学习
  2. 理解每种模式的应用场景而不仅仅是代码
  3. 避免过度设计，只在必要时使用设计模式
  4. C++11/14/17的现代特性（智能指针、lambda等）可以简化某些模式的实现

这些模式提供了经过验证的解决方案，能帮助你构建更灵活、可维护的软件系统。

Read more

用 DeepSeek 打造你的超强代码助手

用 DeepSeek 打造你的超强代码助手

DeepSeek Engineer 是啥？ 简单来说，DeepSeek Engineer 是一个基于命令行的智能助手。它能帮你完成这些事： * 快速读文件内容：比如你有个配置文件，直接用命令把它加载进助手，后续所有操作都可以基于这个文件。 * 自动改文件：它不仅能提建议，还可以直接生成差异表（diff），甚至自动应用修改。 * 智能代码生成：比如你让它生成代码片段，它会按照指定格式和规则直接返回。 更重要的是，这一切都是通过 DeepSeek 的强大 API 来实现的。想象一下，你有个贴身助手，不仅能听懂你的代码需求，还能直接动手帮你写！ 核心功能拆解 我们先来看 DeepSeek Engineer 的几个核心能力，让你更好地理解它的强大之处。 1. 自动配置 DeepSeek 客户端 启动这个工具时，你只需要准备一个 .env 文件，里面写上你的 API Key，比如： DEEPSEEK_API_

By Ne0inhk
10分钟打造专属AI助手！ToDesk云电脑/顺网云/海马云操作DeepSeek哪家强？

10分钟打造专属AI助手！ToDesk云电脑/顺网云/海马云操作DeepSeek哪家强？

文章目录 * 一、引言 * 云计算平台概览 * ToDesk云电脑：随时随地用上高性能电脑 * 二 .云电脑初体验 * DeekSeek介绍 * 版本参数与特点 * 任务类型表现 * 1、ToDesk云电脑 * 2、顺网云电脑 * 3、海马云电脑 * 三、DeekSeek本地化实操和AIGC应用 * 1. ToDesk云电脑 * 2. 海马云电脑 * 3、顺网云电脑 * 四、结语 * 总结：云电脑如何选择？ 一、引言 DeepSeek这些大模型让 AI 开发变得越来越有趣，但真要跑起来，可没那么简单！ * 本地配置太麻烦：显卡不够、驱动难装、环境冲突，光是折腾这些就让人心态崩了。 * 云端性能参差不齐：选错云电脑，可能卡到爆、加载慢，还容易掉线，搞得效率直线下降。 * 成本难控：有的平台按小时计费，价格一会儿一个样，

By Ne0inhk
解锁DeepSeek潜能：Docker+Ollama打造本地大模型部署新范式

解锁DeepSeek潜能：Docker+Ollama打造本地大模型部署新范式

🐇明明跟你说过：个人主页 🏅个人专栏：《深度探秘：AI界的007》 🏅 🔖行路有良友，便是天堂🔖 目录 一、引言 1、什么是Docker 2、什么是Ollama 二、准备工作 1、操作系统 2、镜像准备 三、安装 1、安装Docker 2、启动Ollama 3、拉取Deepseek大模型 4、启动Deepseek  一、引言 1、什么是Docker Docker：就像一个“打包好的App” 想象一下，你写了一个很棒的程序，在自己的电脑上运行得很好。但当你把它发给别人，可能会遇到各种问题： * “这个软件需要 Python 3.8，但我只有 Python 3.6！

By Ne0inhk
深挖 DeepSeek 隐藏玩法·智能炼金术2.0版本

深挖 DeepSeek 隐藏玩法·智能炼金术2.0版本

前引：屏幕前的你还在AI智能搜索框这样搜索吗？“这道题怎么写”“苹果为什么红”“怎么不被发现翘课” ，。看到此篇文章的小伙伴们！请准备好你的思维魔杖，开启【霍格沃茨模式】，看我如何更新秘密的【知识炼金术】，我们一起来解锁更加刺激的剧情！友情提醒：《《《前方高能》》》 目录 在哪使用DeepSeek 如何对提需求  隐藏玩法总结 几个高阶提示词 职场打工人 自媒体创作 电商实战 程序员开挂 非适用场地 “服务器繁忙”如何解决 （1）硅基流动平台 （2）Chatbox + API集成方案 （3）各大云平台 搭建个人知识库 前置准备 下载安装AnythingLLM 选择DeepSeek作为AI提供商 创作工作区 导入文档 编辑  编辑 小编寄语 ——————————————————————————————————————————— 在哪使用DeepSeek 我们解锁剧情前，肯定要知道在哪用DeepSeek！咯，为了照顾一些萌新朋友，它的下载方式我放在下面了，拿走不谢！  （1）

By Ne0inhk