概述了 C++ 中的 23 种设计模式，分为创建型、结构型和行为型三类。通过具体代码示例展示了单例、工厂、观察者等常用模式的实现细节，包括类定义、接口设计及关键方法。文章总结了必须掌握的核心模式及学习建议，旨在帮助开发者理解设计模式的应用场景，构建更灵活、可维护的软件系统。
设计模式可分为三大类：创建型、结构型、行为型。以下是 23 个设计模式的分类及代码示例：
class Singleton {
private:
static Singleton* instance;
Singleton() {}
:
{
(instance == ) { instance = (); }
instance;
}
( Singleton&) = ;
Singleton& =( Singleton&) = ;
};
// 产品接口
class Product {
public:
virtual ~Product() {}
virtual void operation() = 0;
};
// 具体产品
class ConcreteProductA : public Product {
public:
void operation() override { cout << "Product A operation" << endl; }
};
// 工厂接口
class Creator {
public:
virtual ~Creator() {}
virtual Product* factoryMethod() = 0;
};
// 具体工厂
class ConcreteCreatorA : public Creator {
public:
Product* factoryMethod() override { return new ConcreteProductA(); }
};
// 抽象产品 A
class AbstractProductA {
public:
virtual ~AbstractProductA() {}
virtual void operationA() = 0;
};
// 抽象产品 B
class AbstractProductB {
public:
virtual ~AbstractProductB() {}
virtual void operationB() = 0;
};
// 抽象工厂
class AbstractFactory {
public:
virtual AbstractProductA* createProductA() = 0;
virtual AbstractProductB* createProductB() = 0;
};
// 具体工厂 1
class ConcreteFactory1 : public AbstractFactory {
public:
AbstractProductA* createProductA() override { return new ConcreteProductA1(); }
AbstractProductB* createProductB() override { return new ConcreteProductB1(); }
};
class Product {
private:
string partA;
string partB;
public:
void setPartA(const string& a) { partA = a; }
void setPartB(const string& b) { partB = b; }
};
class Builder {
public:
virtual ~Builder() {}
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual Product* getResult() = 0;
};
class Director {
private:
Builder* builder;
public:
Director(Builder* b) : builder(b) {}
void construct() { builder->buildPartA(); builder->buildPartB(); }
};
class Prototype {
public:
virtual ~Prototype() {}
virtual Prototype* clone() const = 0;
virtual void print() const = 0;
};
class ConcretePrototype : public Prototype {
private:
int data;
public:
ConcretePrototype(int d) : data(d) {}
Prototype* clone() const override { return new ConcretePrototype(*this); }
void print() const override { cout << "Data: " << data << endl; }
};
// 目标接口
class Target {
public:
virtual ~Target() {}
virtual void request() { cout << "Target request" << endl; }
};
// 需要适配的类
class Adaptee {
public:
void specificRequest() { cout << "Adaptee specific request" << endl; }
};
// 适配器
class Adapter : public Target {
private:
Adaptee* adaptee;
public:
Adapter(Adaptee* a) : adaptee(a) {}
void request() override { adaptee->specificRequest(); }
};
// 实现接口
class Implementor {
public:
virtual ~Implementor() {}
virtual void operationImpl() = 0;
};
// 抽象类
class Abstraction {
protected:
Implementor* impl;
public:
Abstraction(Implementor* i) : impl(i) {}
virtual ~Abstraction() {}
virtual void operation() { impl->operationImpl(); }
};
class Component {
public:
virtual ~Component() {}
virtual void operation() = 0;
virtual void add(Component*) {}
virtual void remove(Component*) {}
virtual Component* getChild(int) { return nullptr; }
};
class Leaf : public Component {
public:
void operation() override { cout << "Leaf operation" << endl; }
};
class Composite : public Component {
private:
vector<Component*> children;
public:
void operation() override {
cout << "Composite operation" << endl;
for (auto child : children) { child->operation(); }
}
void add(Component* c) override { children.push_back(c); }
};
class Component {
public:
virtual ~Component() {}
virtual void operation() = 0;
};
class ConcreteComponent : public Component {
public:
void operation() override { cout << "ConcreteComponent operation" << endl; }
};
class Decorator : public Component {
protected:
Component* component;
public:
Decorator(Component* c) : component(c) {}
void operation() override { component->operation(); }
};
class ConcreteDecorator : public Decorator {
public:
ConcreteDecorator(Component* c) : Decorator(c) {}
void operation() override {
Decorator::operation();
addedBehavior();
}
void addedBehavior() { cout << "Added behavior" << endl; }
};
class SubsystemA {
public:
void operationA() { cout << "Subsystem A operation" << endl; }
};
class SubsystemB {
public:
void operationB() { cout << "Subsystem B operation" << endl; }
};
class Facade {
private:
SubsystemA* a;
SubsystemB* b;
public:
Facade() : a(new SubsystemA()), b(new SubsystemB()) {}
void operation() { a->operationA(); b->operationB(); }
};
class Flyweight {
public:
virtual ~Flyweight() {}
virtual void operation(int extrinsicState) = 0;
};
class ConcreteFlyweight : public Flyweight {
private:
int intrinsicState;
public:
ConcreteFlyweight(int state) : intrinsicState(state) {}
void operation(int extrinsicState) override {
cout << "Intrinsic: " << intrinsicState << ", Extrinsic: " << extrinsicState << endl;
}
};
class FlyweightFactory {
private:
unordered_map<int, Flyweight*> flyweights;
public:
Flyweight* getFlyweight(int key) {
if (flyweights.find(key) == flyweights.end()) {
flyweights[key] = new ConcreteFlyweight(key);
}
return flyweights[key];
}
};
class Subject {
public:
virtual ~Subject() {}
virtual void request() = 0;
};
class RealSubject : public Subject {
public:
void request() override { cout << "RealSubject request" << endl; }
};
class Proxy : public Subject {
private:
RealSubject* realSubject;
public:
Proxy() : realSubject(nullptr) {}
void request() override {
if (realSubject == nullptr) { realSubject = new RealSubject(); }
realSubject->request();
}
};
class Handler {
protected:
Handler* successor;
public:
Handler() : successor(nullptr) {}
virtual ~Handler() {}
void setSuccessor(Handler* s) { successor = s; }
virtual void handleRequest(int request) = 0;
};
class ConcreteHandler1 : public Handler {
public:
void handleRequest(int request) override {
if (request < 10) {
cout << "Handler1 handled request " << request << endl;
} else if (successor != nullptr) {
successor->handleRequest(request);
}
}
};
class Receiver {
public:
void action() { cout << "Receiver action" << endl; }
};
class Command {
public:
virtual ~Command() {}
virtual void execute() = 0;
};
class ConcreteCommand : public Command {
private:
Receiver* receiver;
public:
ConcreteCommand(Receiver* r) : receiver(r) {}
void execute() override { receiver->action(); }
};
class Invoker {
private:
Command* command;
public:
void setCommand(Command* c) { command = c; }
void executeCommand() { command->execute(); }
};
class Context {
// 上下文信息
};
class Expression {
public:
virtual ~Expression() {}
virtual bool interpret(Context& context) = 0;
};
class TerminalExpression : public Expression {
public:
bool interpret(Context& context) override {
// 终结符解释逻辑
return true;
}
};
template<typename T>
class Iterator {
public:
virtual ~Iterator() {}
virtual T next() = 0;
virtual bool hasNext() = 0;
};
template<typename T>
class ConcreteIterator : public Iterator<T> {
private:
vector<T> collection;
size_t position;
public:
ConcreteIterator(const vector<T>& col) : collection(col), position(0) {}
T next() override { return collection[position++]; }
bool hasNext() override { return position < collection.size(); }
};
class Colleague;
class Mediator {
public:
virtual ~Mediator() {}
virtual void notify(Colleague* sender, string event) = 0;
};
class Colleague {
protected:
Mediator* mediator;
public:
Colleague(Mediator* m = nullptr) : mediator(m) {}
void setMediator(Mediator* m) { mediator = m; }
};
class ConcreteColleague1 : public Colleague {
public:
void doSomething() {
// ... 自己的逻辑
mediator->notify(this, "event1");
}
};
class Memento {
private:
string state;
public:
Memento(const string& s) : state(s) {}
string getState() const { return state; }
};
class Originator {
private:
string state;
public:
void setState(const string& s) { state = s; }
string getState() const { return state; }
Memento* createMemento() { return new Memento(state); }
void restoreMemento(Memento* m) { state = m->getState(); }
};
class Observer {
public:
virtual ~Observer() {}
virtual void update(float temperature) = 0;
};
class Subject {
private:
vector<Observer*> observers;
public:
void attach(Observer* o) { observers.push_back(o); }
void detach(Observer* o) { /* 移除观察者逻辑 */ }
void notify(float temperature) {
for (auto observer : observers) { observer->update(temperature); }
}
};
class ConcreteObserver : public Observer {
public:
void update(float temperature) override {
cout << "Temperature updated: " << temperature << endl;
}
};
class Context;
class State {
public:
virtual ~State() {}
virtual void handle(Context* context) = 0;
};
class Context {
private:
State* state;
public:
Context(State* s) : state(s) {}
void setState(State* s) { state = s; }
void request() { state->handle(this); }
};
class ConcreteStateA : public State {
public:
void handle(Context* context) override;
};
class Strategy {
public:
virtual ~Strategy() {}
virtual void algorithm() = 0;
};
class ConcreteStrategyA : public Strategy {
public:
void algorithm() override { cout << "Strategy A algorithm" << endl; }
};
class Context {
private:
Strategy* strategy;
public:
Context(Strategy* s) : strategy(s) {}
void setStrategy(Strategy* s) { strategy = s; }
void executeStrategy() { strategy->algorithm(); }
};
class AbstractClass {
public:
virtual ~AbstractClass() {}
void templateMethod() {
primitiveOperation1();
primitiveOperation2();
}
virtual void primitiveOperation1() = 0;
virtual void primitiveOperation2() = 0;
};
class ConcreteClass : public AbstractClass {
public:
void primitiveOperation1() override { cout << "Concrete operation 1" << endl; }
void primitiveOperation2() override { cout << "Concrete operation 2" << endl; }
};
class ConcreteElementA;
class ConcreteElementB;
class Visitor {
public:
virtual ~Visitor() {}
virtual void visit(ConcreteElementA* element) = 0;
virtual void visit(ConcreteElementB* element) = 0;
};
class Element {
public:
virtual ~Element() {}
virtual void accept(Visitor* visitor) = 0;
};
class ConcreteElementA : public Element {
public:
void accept(Visitor* visitor) override { visitor->visit(this); }
void operationA() { cout << "Operation A" << endl; }
};
这些模式提供了经过验证的解决方案，能帮助你构建更灵活、可维护的软件系统。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online