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

【Linux网络系列】：JSON+HTTP，用C++手搓一个web计算器服务器！

【Linux网络系列】：JSON+HTTP，用C++手搓一个web计算器服务器！

🔥 本文专栏：Linux网络Linux实践系列 🌸作者主页：努力努力再努力wz 💪 今日博客励志语录：别害怕选错，人生最遗憾的从不是‘选错了’，而是‘我本可以’。每一次推倒重来的勇气，都是在给灵魂贴上更坚韧的勋章。 ★★★ 本文前置知识： 序列化与反序列化 引入 在之前的博客中，我详细介绍了序列化 与反序列化 的概念。对于使用 TCP 协议进行通信的双方，由于 TCP 是面向字节流的，在发送数据之前，我们通常需要定义一种结构化的数据来描述传输内容，并以此作为数据的容器。在 C++ 中，这种结构化数据通常表现为对象或结构体。然而，我们不能直接将结构体内存中对应的字节原样发送到另一端，因为直接传递内存字节会引发字节序 和结构体内存对齐 的问题。不同平台、不同编译器所遵循的内存对齐规则可能不同，这可能导致接收方在解析结构体字段时出现错误。 因此，我们需要借助序列化 。序列化 是指将结构化的数据按照预定的规则转换为连续的字节流。其主要目的是屏蔽平台差异，使得位于不同平台的进程能够以统一的方式解析该字节流。序列化通常分为两种形式：文本序列化 与二进制序列化 。 文

By Ne0inhk
【算法一周目】位间流转，数字律动——洞察 C++ 位运算中的精妙与哲思

【算法一周目】位间流转，数字律动——洞察 C++ 位运算中的精妙与哲思

文章目录 * 常见位运算 * 1. 位1的个数 * 2. 比特位计数 * 3.汉明距离 * 4. 只出现一次的数字 * 5. 只出现一次的数字 III * 6. 只出现一次的数字 II * 7. 判定字符是否唯一 * 8. 丢失的数字 * 9. 两整数之和 * 10. 只出现一次的数字 II 常见位运算 1. 判断一个数的二进制表示的第x位是0还是1 * (n >> x) & 1 2. 将一个数的二进制表示的第x位修改成1 * n |= (1 << x) 3. 将一个数的二进制表示的第x位修改成0 * n &= ~ (1 << x) 4.

By Ne0inhk
探索实现C++ STL容器适配器：优先队列priority_queue

探索实现C++ STL容器适配器：优先队列priority_queue

前引： 在算法竞赛中，选手们常常能在0.01秒内分出胜负；在实时交易系统中，毫秒级的延迟可能意味着数百万的盈亏；在高并发服务器中，每秒需要处理数万条不同优先级的请求——这些系统背后，都隐藏着同一种强大的数据结构： 优先队列（priority_queue） 作为C++标准库中最优雅的数据结构适配器，priority_queue完美封装了堆算法的高效性，却只需几行代码即可实现复杂优先级管理。本文将深入剖析： （1） 堆原理与优先队列的机械美学 （2）定制化优先级策略的高级技巧 （3）实战性能对比与编译器级优化 （4）在万亿级数据处理中的独特优势 目录 优先队列介绍 优先队列的渊源 实例化 插入元素 访问元素 获取元素个数 判断优先队列是否为空 删除堆顶元素 · 优先队列的模拟实现 类模板 插入元素 访问元素 获取元素个数 判断优先队列是否为空 删除堆顶元素 效果展示 优先队列介绍 优先队列priority_queue 是 C++ 标准模板库（

By Ne0inhk

2.22 STL 中string的学习

1.什么是STL STL standard template libarary 标准模板库:是C++标准库的重要组成部分 不仅是一个可复用的组件库 而且是一个包罗数据结构和算法的软件框架 2.STL六大组件 容器 算法 迭代器 仿函数 适配器 分配器 3.STL三大境界 学习 熟练 扩展 string的学习 通俗理解 string就是一个会自己长大的字符数组 自带了很多工具函数 为什么使用string 自动内存管理 方便操作 安全(不会越界) 与C兼容 C++ string 类常用接口说明 1. 简介 string 是 C++ 标准库中的字符串类，封装了动态字符数组，自动管理内存，提供丰富的成员函数。使用 string 比 C

By Ne0inhk