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

C++ 模板进阶：特化、萃取与可变参数模板

C++ 模板进阶：特化、萃取与可变参数模板

C++ 模板进阶：特化、萃取与可变参数模板 💡 学习目标：掌握模板进阶技术的核心用法，理解模板特化的深层应用、类型萃取的实现原理，以及可变参数模板的灵活使用，提升泛型编程的实战能力。 💡 学习重点：模板特化的进阶场景、类型萃取工具的设计与应用、可变参数模板的展开技巧、折叠表达式的使用方法。 一、模板特化进阶：处理复杂类型场景 💡 模板特化不只是针对单一类型的定制，还能处理指针、引用、数组等复杂类型，实现更精细的类型适配逻辑。 1.1 指针类型的模板特化 通用模板默认处理普通类型，我们可以为指针类型单独编写特化版本，实现指针专属的逻辑。 #include<iostream>#include<string>usingnamespace std;// 通用模板：处理普通类型template<typenameT>classTypeProcessor{public:staticvoidprocess(T data){ cout

By Ne0inhk
C++测试与调试：确保代码质量与稳定性

C++测试与调试：确保代码质量与稳定性

C++测试与调试：确保代码质量与稳定性 一、学习目标与重点 本章将深入探讨C++测试与调试的核心知识，帮助你确保代码的质量与稳定性。通过学习，你将能够： 1. 理解测试与调试的基本概念，掌握测试方法和工具 2. 学会使用单元测试框架，如Google Test和Catch2 3. 理解集成测试的重要性，确保系统的功能正确性 4. 学会使用调试工具，如GDB和Visual Studio调试器 5. 培养测试与调试思维，设计高质量的代码 二、测试的基本概念 2.1 测试的分类 测试可以分为以下几类： * 单元测试：测试单个函数或类的功能 * 集成测试：测试多个模块的集成功能 * 系统测试：测试整个系统的功能 * 验收测试：测试系统是否满足用户需求 * 性能测试：测试系统的性能指标 2.2 测试原则 测试应该遵循以下原则： * 测试应该尽可能早地进行 * 测试应该覆盖所有可能的场景 * 测试应该是自动化的

By Ne0inhk

Java + Vue 毕业设计选题效率提升指南：从脚手架到自动化部署的全链路优化

毕业设计季又到了，对于计算机专业的同学来说，用 Java 做后端，Vue 做前端，是一个非常经典且实用的技术栈组合。但很多同学在真正动手时，常常被各种“琐事”绊住，比如环境配半天、前后端接口对不上、部署时手忙脚乱，导致宝贵的开发时间被大量浪费。今天，我就结合自己带学弟学妹做毕设的经验，聊聊如何通过一套标准化的流程和工具，把 Java + Vue 毕设的开发效率提上去，让你把精力真正花在业务逻辑和创新点上。 1. 毕业设计效率痛点：我们到底在哪儿“卡”住了？ 在开始技术选型之前，我们先得搞清楚，做 Java + Vue 毕设时，哪些环节最容易“掉链子”。根据我的观察，主要有这么几个： 1. 环境配置地狱：这是第一个拦路虎。A 同学的 MySQL 是 8.0，B 同学是

By Ne0inhk

Java 接口：从‘空架子’到‘万能遥控器’

🚀Java接口通关秘籍：从“空架子”到“万能遥控器”的逆袭！ 发布时间：2026-01-09 专栏：Java基础通关指南 😮 先唠个嗑：为啥接口总被新手“嫌弃”？ 刚学Java的小伙伴大概率都有这感受：“接口这玩意儿啥也干不了，就一堆空方法，写了半天还得靠实现类干活，纯纯的‘空架子’？” NONONO！今天咱就把Java接口的底裤扒干净——它不是“空架子”，而是编程界的“万能遥控器”：定义好了按钮（方法），不管是电视、空调还是投影仪（实现类），只要按规矩接这个遥控器，就能按统一的方式干活！ 📚 一、啥是Java接口？（人话版解释） 1. 官方定义（快速略过） 接口（Interface）是Java中的一种引用类型，是方法的集合，只能包含常量、抽象方法（Java 8前），以及默认方法、静态方法、私有方法（Java

By Ne0inhk