C++中的模式

在C++编程中，设计模式是一种被广泛使用的概念，因为它们可以极大地提高应用程序的内部结构，并使代码更易于维护和扩展。设计模式是在软件工程中被定义的一组解决方案，用于处理重复发生的问题。在本文中，我们将介绍一些在C++中常用的设计模式及其用法。

单例模式

单例模式是一种创建型设计模式，其中只允许创建一个类的实例。这可确保在应用程序中只有一个实例可以全局访问，并提供了开发人员更为严格的控制，避免创建多个类实例造成的资源浪费。实现单例模式的方法通常使用静态成员和静态方法。

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

    void showMessage() {
        std::cout << "Hello, World!" << std::endl;
    }

private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

在这个例子中，我们使用了一个静态方法 getInstance() 来获取单例实例。在内部，我们使用了 static 对象来保证只有一个实例被创建。当然，此处使用的是懒汉式单例模式，也可以使用饿汉式单例模式。

工厂模式

工厂模式是一种创建型设计模式，用于在不暴露对象创建逻辑的情况下创建对象。工厂模式通常用于处理类之间的依赖关系而不需要直接进行对象初始化。工厂模式可以分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。

#include <memory>

class Product {
public:
    virtual ~Product() {}

    virtual std::string getName() const = 0;
};

class Product1 : public Product {
public:
    std::string getName() const override {
        return "Product 1";
    }
};

class Product2 : public Product {
public:
    std::string getName() const override {
        return "Product 2";
    }
};

class Factory {
public:
    virtual ~Factory() {}

    virtual std::unique_ptr<Product> createProduct() = 0;
};

class Factory1 : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<Product1>();
    }
};

class Factory2 : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<Product2>();
    }
};

在这个例子中，我们创建了一个 Product 基类和两个派生类 Product1 和 Product2。然后我们创建了一个 Factory 基类和两个派生类 Factory1 和 Factory2。每个工厂都有一个创建产品的方法 createProduct()，并返回特定类型的产品。

观察者模式

观察者模式是一种行为设计模式，用于在多个对象之间协作。在此模式中，当一个对象更改其状态时，所有依赖于它的对象都会收到通知并相应地更新自己。观察者模式的实现涉及到两个主要角色：发布者和订阅者。

#include <vector>
#include <algorithm>
#include <iostream>

class Subscriber {
public:
    virtual ~Subscriber() {}
    virtual void update() = 0;
};

class Publisher {
public:
    void attach(std::shared_ptr<Subscriber> s) {
        subscribers.push_back(std::move(s));
    }

    void detach(std::shared_ptr<Subscriber> s) {
        auto pos = std::find(subscribers.begin(), subscribers.end(), s);
        if (pos != subscribers.end()) {
            subscribers.erase(pos);
        }
    }

    void notify() {
        for (auto s : subscribers) {
            s->update();
        }
    }

private:
    std::vector<std::shared_ptr<Subscriber>> subscribers;
};

class ConcreteSubscriber : public Subscriber {
public:
    ConcreteSubscriber(const std::string& n) : name(n) {}
    void update() override {
        std::cout << name << " received a notification!" << std::endl;
    }

private:
    std::string name;
};

int main() {
    auto publisher = std::make_shared<Publisher>();

    auto sub1 = std::make_shared<ConcreteSubscriber>("Subscriber 1");
    publisher->attach(sub1);

    auto sub2 = std::make_shared<ConcreteSubscriber>("Subscriber 2");
    publisher->attach(sub2);

    publisher->notify();

    publisher->detach(sub1);

    publisher->notify();
}

在这个例子中，我们使用 Subscriber 和 Publisher 类来实现观察者模式。 Publisher 类持有一个订阅者列表，并允许订阅者附加和分离。当发布者发生更改时，调用 notify() 函数通知每个订阅者更新。在 ConcreteSubscriber 类中，我们重写了 update() 函数以实现接收通知后的表现。在 main() 函数中，我们创建了两个订阅者并订阅发布者，之后取消了其中一个订阅，最终发布者发布通知并通知其订阅者。