看动画，轻松学习23种C++设计模式完结无密
获取ZY↑↑方打开链接↑↑
C++设计模式的系统讲解
C++中的设计模式是解决特定问题的通用解决方案，它们提供了经过验证的结构和方法来组织代码，从而提高软件的可维护性、复用性和灵活性。以下是关于C++中常见设计模式的系统讲解，分为创建型、结构型和行为型三大类。
1. 创建型模式
创建型模式关注对象的创建过程，旨在使系统更加独立于如何创建、组合和表示这些对象。
单例模式（Singleton）
- 目的：确保一个类只有一个实例，并提供全局访问点。
- 实现要点：
-
- 私有化构造函数，防止外部直接创建对象。
- 使用静态成员变量保存唯一实例。
- 提供公共静态方法获取该实例。
cpp深色版本class Singleton {private: static Singleton* instance; Singleton() {} // Private constructorpublic: static Singleton* getInstance() { if (instance == nullptr) { instance = new Singleton(); } return instance; }
};Singleton* Singleton::instance = nullptr;
工厂方法模式（Factory Method）
- 目的：定义一个用于创建对象的接口，但让子类决定实例化哪一个类。
- 应用场景：当需要根据某些条件动态选择不同类型的对象时使用。
cpp深色版本class Creator {public: virtual Product* factoryMethod() const = 0;};class ConcreteCreator : public Creator {public: Product* factoryMethod() const override { return new ConcreteProduct(); }
};
抽象工厂模式（Abstract Factory）
- 目的：提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。
- 优点：易于扩展产品族，且保持一致性。
cpp深色版本class AbstractFactory {public: virtual ProductA* createProductA() = 0; virtual ProductB* createProductB() = 0;};class ConcreteFactory1 : public AbstractFactory {public: ProductA* createProductA() override { /* ... */ } ProductB* createProductB() override { /* ... */ }};
建造者模式（Builder）
- 目的：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
- 适用情况：适用于构建具有多个属性的对象，特别是当这些属性之间存在复杂的依赖关系时。
cpp深色版本class Director {public: void construct(Builder& builder) { builder.buildPartA();
builder.buildPartB();
}
};class Builder {public: virtual void buildPartA() = 0; virtual void buildPartB() = 0; virtual Product* getResult() = 0;};
原型模式（Prototype）
- 目的：通过复制现有对象来创建新对象，而不是通过常规构造函数。
- 优点：简化对象创建流程，尤其是当构造参数复杂时。
cpp深色版本class Prototype {public: virtual Prototype* clone() const = 0;};class ConcretePrototype : public Prototype {public: Prototype* clone() const override { return new ConcretePrototype(*this); }};
2. 结构型模式
结构型模式处理类与对象之间的组合，主要用于简化接口或改进系统的组织方式。
适配器模式（Adapter）
- 目的：允许不兼容的接口一起工作，通常用于遗留代码的现代化改造。
- 类型：类适配器 vs 对象适配器。
cpp深色版本class Target {public: virtual void request() = 0;};class Adapter : public Target {private: Adaptee* adaptee;public: Adapter(Adaptee* a) : adaptee(a) {} void request() override { adaptee->specificRequest();
}
};
桥接模式（Bridge）
- 目的：将抽象部分与其实现部分分离开来，使两者都可以独立变化。
- 特点：避免了由于继承带来的紧耦合问题。
cpp深色版本class Implementor {public: virtual void operationImpl() = 0;};class Abstraction {protected: Implementor* impl;public: void setImplementor(Implementor* i) { impl = i; } virtual void operation() = 0;};
组合模式（Composite）
- 目的：将对象组合成树形结构以表示“部分-整体”的层次结构，客户可以统一地对待单个对象和对象容器。
- 应用范围：文件系统、图形界面等。
cpp深色版本class Component {public: virtual void operation() = 0;};class Leaf : public Component {public: void operation() override { /* ... */ }};class Composite : public Component {private: std::vector<Component*> children;public: void add(Component* c) { children.push_back(c); } void remove(Component* c) { children.erase(std::remove(children.begin(), children.end(), c), children.end()); } void operation() override { for (auto& child : children) { child->operation();
}
}
};
装饰模式（Decorator）
- 目的：动态地给一个对象添加一些额外的责任，而不影响其他对象。
- 优势：比生成子类更灵活。
cpp深色版本class Component {public: virtual void operation() = 0;};class Decorator : public Component {protected: Component* component;public: Decorator(Component* c) : component(c) {} void operation() override { if (component != nullptr) { component->operation();
}
}
};class ConcreteDecoratorA : public Decorator {public: ConcreteDecoratorA(Component* c) : Decorator(c) {} void addedBehavior() { /* ... */ } void operation() override { Decorator::operation();
addedBehavior();
}
};
外观模式（Facade）
- 目的：为复杂子系统提供一个简化的接口，隐藏内部细节。
- 用途：简化高层模块对底层模块的调用。
cpp深色版本class SubsystemA {public: void operationA() { /* ... */ }};class SubsystemB {public: void operationB() { /* ... */ }};class Facade {private: SubsystemA* subsystemA;
SubsystemB* subsystemB;public: Facade() : subsystemA(new SubsystemA()), subsystemB(new SubsystemB()) {} void operation() { subsystemA->operationA();
subsystemB->operationB();
}
};
享元模式（Flyweight）
- 目的：通过共享技术有效地支持大量细粒度的对象。
- 适用场景：内存受限环境下优化资源利用。
cpp深色版本class Flyweight {public: virtual void operation(int extrinsicState) = 0;};class ConcreteFlyweight : public Flyweight {public: void operation(int extrinsicState) override { /* ... */ }};class FlyweightFactory {private: std::map<std::string, Flyweight*> flyweights;public: Flyweight* getFlyweight(const std::string& key) { if (flyweights.find(key) == flyweights.end()) { flyweights[key] = new ConcreteFlyweight(); } return flyweights[key]; }
};
代理模式（Proxy）
- 目的：为另一个对象提供一种代理以控制对该对象的访问。
- 分类：远程代理、虚拟代理、保护代理等。
cpp深色版本class Subject {public: virtual void request() = 0;};class RealSubject : public Subject {public: void request() override { /* ... */ }};class Proxy : public Subject {private: RealSubject* realSubject;public: void request() override { if (realSubject == nullptr) { realSubject = new RealSubject(); } realSubject->request(); }};
3. 行为型模式
行为型模式专注于对象之间的职责分配，强调对象间的通信和协作机制。
责任链模式（Chain of Responsibility）
- 目的：避免请求发送者与接收者耦合在一起，让多个对象都有机会处理请求。
- 好处：增强了系统的灵活性和可扩展性。
cpp深色版本class Handler {public: virtual bool handleRequest(int request) = 0;};class ConcreteHandler1 : public Handler {private: Handler* successor;public: void setSuccessor(Handler* h) { successor = h; } bool handleRequest(int request) override { if (request >= 0 && request < 10) { // Handle the request here... return true; } else if (successor != nullptr) { return successor->handleRequest(request); } return false; }
};
命令模式（Command）
- 目的：将请求封装成对象，从而使你可以参数化其他对象以执行、排队或者记录/恢复操作。
- 应用场景：GUI控件绑定、事务管理等。
cpp深色版本class Command {public: virtual void execute() = 0;};class Receiver {public: void action() { /* ... */ }};class ConcreteCommand : public Command {private: Receiver* receiver;public: ConcreteCommand(Receiver* r) : receiver(r) {} void execute() override { receiver->action();
}
};
解释器模式（Interpreter）
- 目的：为语言定义语法表示，并提供解释器来解析这个语法。
- 适用范围：小型DSL（领域特定语言）的设计。
cpp深色版本class Expression {public: virtual bool interpret(const std::string& context) = 0;};class TerminalExpression : public Expression {public: bool interpret(const std::string& context) override { // Interpret terminal expression... return true; }
};class NonterminalExpression : public Expression {public: bool interpret(const std::string& context) override { // Interpret non-terminal expression... return true; }
};
迭代器模式（Iterator）
- 目的：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露其内部表示。
- 优点：提高了代码的可读性和重用性。
cpp深色版本class Iterator {public: virtual bool hasNext() = 0; virtual void next() = 0;};class Aggregate {public: virtual Iterator* createIterator() = 0;};class ConcreteAggregate : public Aggregate {public: Iterator* createIterator() override { return new ConcreteIterator(this); }
};
中介者模式（Mediator）
- 目的：用一个中介对象来封装一系列对象之间的交互，降低它们之间的耦合度。
- 实际案例：聊天室消息转发、组件间通信等。
cpp深色版本class Mediator {public: virtual void send(const std::string& message, Colleague* colleague) = 0;};class Colleague {protected: Mediator* mediator;public: void setMediator(Mediator* m) { mediator = m; } virtual void send(const std::string& message) = 0; virtual void receive(const std::string& message) = 0;};class ConcreteMediator : public Mediator {private: ColleagueA* colleagueA;
ColleagueB* colleagueB;public: void setColleagueA(ColleagueA* ca) { colleagueA = ca; } void setColleagueB(ColleagueB* cb) { colleagueB = cb; } void send(const std::string& message, Colleague* colleague) override { if (colleague == colleagueA) { colleagueB->receive(message); } else { colleagueA->receive(message);
}
}
};
备忘录模式（Memento）
- 目的：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
- 典型用法：撤销功能、快照保存等。
cpp深色版本class Memento {private: int state;public: Memento(int s) : state(s) {} int getState() const { return state; }};class Originator {private: int state;public: void setState(int s) { state = s; } int getState() const { return state; } Memento* saveToMemento() { return new Memento(state); } void restoreFromMemento(Memento* memento) { state = memento->getState();
}
};
观察者模式（Observer）
- 目的：定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
- 广泛使用：事件驱动编程、UI框架等。
cpp深色版本class Observer {public: virtual void update() = 0;};class Subject {private: std::vector<Observer*> observers;public: void attach(Observer* observer) { observers.push_back(observer); } void detach(Observer* observer) { observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end()); } void notify() { for (auto& observer : observers) { observer->update();
}
}
};class ConcreteObserver : public Observer {public: void update() override { // React to the notification... }
};
状态模式（State）
- 目的：允许一个对象在其内部状态改变时改变它的行为，看起来像是改变了它的类。
- 应用场景：有限状态机、游戏AI等。
cpp深色版本class Context {private: State* state;public: void setState(State* s) { state = s; } void request() { state->handle(this); }
};class State {public: virtual void handle(Context* context) = 0;};class ConcreteStateA : public State {public: void handle(Context* context) override { // Change state or perform actions... context->setState(new ConcreteStateB()); }
};
策略模式（Strategy）
- 目的：定义一系列算法，把它们一个个封装起来，并使它们可以互相替换。
- 优点：策略模式使得算法可以在不影响客户端的情况下发生变化。
cpp深色版本class Strategy {public: virtual void algorithmInterface() = 0;};class ConcreteStrategyA : public Strategy {public: void algorithmInterface() override { // Implementation of strategy A... }
};class Context {private: Strategy* strategy;public: void setStrategy(Strategy* s) { strategy = s; } void contextInterface() { if (strategy != nullptr) { strategy->algorithmInterface();
}
}
};
模板方法模式（Template Method）
- 目的：定义一个操作中的算法骨架，而将一些步骤延迟到子类中实现。
- 典型例子：框架提供的默认行为，用户可以选择性地覆盖某些步骤。
cpp深色版本class AbstractClass {public: void templateMethod() { primitiveOperation1();
primitiveOperation2();
}protected: virtual void primitiveOperation1() = 0; virtual void primitiveOperation2() = 0;};class ConcreteClass : public AbstractClass {protected: void primitiveOperation1() override { // Implementation of primitive operation 1... } void primitiveOperation2() override { // Implementation of primitive operation 2... }
};
访问者模式（Visitor）
- 目的：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
- 应用场景：遍历复合结构、报表生成等。
cpp深色版本class Element {public: virtual void accept(Visitor* visitor) = 0;};class ConcreteElementA : public Element {public: void accept(Visitor* visitor) override { visitor->visitConcreteElementA(this); }};class Visitor {public: virtual void visitConcreteElementA(ConcreteElementA* element) = 0;};class ConcreteVisitor : public Visitor {public: void visitConcreteElementA(ConcreteElementA* element) override { // Perform operations on concrete element A... }};
总结
设计模式并不是银弹，也不是必须严格遵守的规定，而是解决问题的一种指导思想。理解每种模式背后的意图和适用场景可以帮助我们在面对复杂问题时找到合适的解决方案。然而，过度使用设计模式也可能导致代码变得过于复杂和难以理解，因此应该根据具体需求谨慎选择和应用。希望上述介绍能够为你提供有价值的参考！如果你有任何疑问或需要进一步的帮助，请随时提问。
