C++小程序中的设计模式有哪些？

C++小程序中的设计模式是软件工程中非常重要的概念，它可以帮助开发者编写出更加模块化、可重用和易于维护的代码。设计模式是经过时间考验的、普遍适用的解决方案，可以帮助解决特定类型的软件设计问题。以下是一些在C++小程序中常用的设计模式：

单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。在C++中，单例模式通常通过静态成员变量和静态成员函数实现。

class Singleton {

private:

    static Singleton* instance;

    Singleton() {}

    Singleton(const Singleton&) = delete;

    Singleton& operator=(const Singleton&) = delete;



public:

    static Singleton* getInstance() {

        if (instance == nullptr) {

            instance = new Singleton();

        }

        return instance;

    }

    void doSomething() {

        // ...

    }

};



Singleton* Singleton::instance = nullptr;

工厂模式（Factory）
工厂模式定义了一个接口，用于创建对象，但让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

class ProductA {

public:

    void doSomething() {

        // ...

    }

};



class ProductB {

public:

    void doSomething() {

        // ...

    }

};



class Factory {

public:

    virtual ~Factory() {}

    virtual ProductA* createProductA() = 0;

    virtual ProductB* createProductB() = 0;

};



class ConcreteFactoryA : public Factory {

public:

    ProductA* createProductA() override {

        return new ProductA();

    }

    ProductB* createProductB() override {

        return nullptr;

    }

};



class ConcreteFactoryB : public Factory {

public:

    ProductA* createProductA() override {

        return nullptr;

    }

    ProductB* createProductB() override {

        return new ProductB();

    }

};

抽象工厂模式（Abstract Factory）
抽象工厂模式是一个工厂方法的组合，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

class AbstractProductA {

public:

    virtual void doSomething() = 0;

    virtual ~AbstractProductA() {}

};



class ConcreteProductA1 : public AbstractProductA {

public:

    void doSomething() override {

        // ...

    }

};



class AbstractProductB {

public:

    virtual void doSomething() = 0;

    virtual ~AbstractProductB() {}

};



class ConcreteProductB1 : public AbstractProductB {

public:

    void doSomething() override {

        // ...

    }

};



class AbstractFactory {

public:

    virtual ~AbstractFactory() {}

    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();

    }

};

命令模式（Command）
命令模式将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，以及支持可撤销的操作。

class Command {

public:

    virtual void execute() = 0;

    virtual ~Command() {}

};



class ConcreteCommandA : public Command {

public:

    void execute() override {

        // ...

    }

};



class ConcreteCommandB : public Command {

public:

    void execute() override {

        // ...

    }

};



class Invoker {

private:

    Command* commandA;

    Command* commandB;



public:

    Invoker(Command* commandA, Command* commandB) : commandA(commandA), commandB(commandB) {}

    void invoke() {

        commandA->execute();

        commandB->execute();

    }

};

装饰者模式（Decorator）
装饰者模式动态地给一个对象添加一些额外的职责，而不改变其接口。它通过创建一个装饰者类，将装饰者与被装饰者对象连接起来。

class Component {

public:

    virtual void operate() = 0;

    virtual ~Component() {}

};



class ConcreteComponent : public Component {

public:

    void operate() override {

        // ...

    }

};



class Decorator : public Component {

protected:

    Component* component;

public:

    Decorator(Component* component) : component(component) {}

    void operate() override {

        component->operate();

    }

};



class ConcreteDecoratorA : public Decorator {

public:

    ConcreteDecoratorA(Component* component) : Decorator(component) {}

    void operate() override {

        // ...

        Decorator::operate();

        // ...

    }

};

适配器模式（Adapter）
适配器模式允许将一个类的接口转换成客户期望的另一个接口。它使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

class Target {

public:

    virtual void request() = 0;

    virtual ~Target() {}

};



class Adaptee {

public:

    void specificRequest() {

        // ...

    }

};



class Adapter : public Target {

private:

    Adaptee* adaptee;

public:

    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}

    void request() override {

        adaptee->specificRequest();

    }

};

观察者模式（Observer）
观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。

class Observer {

public:

    virtual void update() = 0;

    virtual ~Observer() {}

};



class ConcreteObserverA : public Observer {

public:

    void update() override {

        // ...

    }

};



class ConcreteObserverB : public Observer {

public:

    void update() override {

        // ...

    }

};



class Subject {

private:

    std::vector 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 (Observer* observer : observers) {

            observer->update();

        }

    }

};

这些设计模式在C++小程序中非常实用，可以帮助开发者编写出更加清晰、可维护和可扩展的代码。当然，选择合适的设计模式需要根据具体的项目需求和场景来决定。