常用的设计模式，以及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(); }
};

这些设计模式在软件开发中具有广泛的应用，能够提高代码的可维护性、可扩展性和重用性。根据具体需求选择合适的设计模式，可以使程序设计更加优雅和高效。