常用的设计模式，以及c++代码简答示例

常用的设计模式及其 C++ 简短示例：

1. 单例模式（Singleton Pattern）

作用：确保一个类只有一个实例，并提供全局访问点。

示例代码：

class Singleton {
private:static Singleton* instance;Singleton() {} // 构造函数私有化public:static Singleton* getInstance() {if (instance == nullptr)instance = new Singleton();return instance;}
};// 初始化静态成员
Singleton* Singleton::instance = nullptr;

2. 工厂方法模式（Factory Method Pattern）

作用：定义一个创建对象的接口，但由子类决定要实例化的类。

示例代码：

class Product {
public:virtual void use() = 0;
};class ConcreteProductA : public Product {
public:void use() override { /* 实现 A */ }
};class ConcreteProductB : public Product {
public:void use() override { /* 实现 B */ }
};class Factory {
public:virtual Product* createProduct() = 0;
};class ConcreteFactoryA : public Factory {
public:Product* createProduct() override {return new ConcreteProductA();}
};class ConcreteFactoryB : public Factory {
public:Product* createProduct() override {return new ConcreteProductB();}
};

3. 抽象工厂模式（Abstract Factory Pattern）

作用：提供一个创建一系列相关或依赖对象的接口，而无需指定它们的具体类。

示例代码：

class AbstractProductA {
public:virtual void use() = 0;
};class AbstractProductB {
public:virtual void eat() = 0;
};class ConcreteProductA1 : public AbstractProductA {
public:void use() override { /* 实现 A1 */ }
};class ConcreteProductB1 : public AbstractProductB {
public:void eat() override { /* 实现 B1 */ }
};class AbstractFactory {
public:virtual AbstractProductA* createProductA() = 0;virtual AbstractProductB* createProductB() = 0;
};class ConcreteFactory1 : public AbstractFactory {
public:AbstractProductA* createProductA() override {return new ConcreteProductA1();}AbstractProductB* createProductB() override {return new ConcreteProductB1();}
};

4. 建造者模式（Builder Pattern）

作用：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

示例代码：

class Product {
public:void setPartA(int value) { /* 设置部件 A */ }void setPartB(int value) { /* 设置部件 B */ }
};class Builder {
public:virtual void buildPartA() = 0;virtual void buildPartB() = 0;virtual Product* getResult() = 0;
};class ConcreteBuilder : public Builder {
private:Product* product = new Product();public:void buildPartA() override {product->setPartA(1);}void buildPartB() override {product->setPartB(2);}Product* getResult() override {return product;}
};class Director {
public:void construct(Builder* builder) {builder->buildPartA();builder->buildPartB();}
};

5. 适配器模式（Adapter Pattern）

作用：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。

示例代码：

class Target {
public:virtual void request() = 0;
};class Adaptee {
public:void specificRequest() { /* 特定请求 */ }
};class Adapter : public Target {
private:Adaptee* adaptee;public:Adapter(Adaptee* a) : adaptee(a) {}void request() override {adaptee->specificRequest();}
};

6. 装饰者模式（Decorator Pattern）

作用：动态地给一个对象添加一些额外的职责。

示例代码：

class Component {
public:virtual void operation() = 0;
};class ConcreteComponent : public Component {
public:void operation() override { /* 基础操作 */ }
};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() { /* 添加的行为 */ }
};

7. 观察者模式（Observer Pattern）

作用：定义对象间的一对多依赖，当一个对象改变状态时，所有依赖它的对象都会收到通知并自动更新。

示例代码：

#include <vector>class Observer {
public:virtual void update() = 0;
};class Subject {
private:std::vector<Observer*> observers;public:void attach(Observer* o) { observers.push_back(o); }void notify() {for (Observer* o : observers)o->update();}
};class ConcreteObserver : public Observer {
public:void update() override { /* 更新逻辑 */ }
};

8. 策略模式（Strategy Pattern）

作用：定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。

示例代码：

class Strategy {
public:virtual void algorithmInterface() = 0;
};class ConcreteStrategyA : public Strategy {
public:void algorithmInterface() override { /* 算法 A */ }
};class ConcreteStrategyB : public Strategy {
public:void algorithmInterface() override { /* 算法 B */ }
};class Context {
private:Strategy* strategy;public:Context(Strategy* s) : strategy(s) {}void contextInterface() {strategy->algorithmInterface();}
};

9. 模板方法模式（Template Method Pattern）

作用：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。

示例代码：

class AbstractClass {
public:void templateMethod() {primitiveOperation1();primitiveOperation2();}virtual void primitiveOperation1() = 0;virtual void primitiveOperation2() = 0;
};class ConcreteClass : public AbstractClass {
public:void primitiveOperation1() override { /* 实现 1 */ }void primitiveOperation2() override { /* 实现 2 */ }
};

10. 命令模式（Command Pattern）

作用：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化。

示例代码：

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();}
};class Invoker {
private:Command* command;public:void setCommand(Command* c) { command = c; }void invoke() { command->execute(); }
};