c++常用设计模式

1、单例模式(Singleton)：保证一个类只有一个实例，提供一个全局访问点；

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}
 
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
 
Singleton* Singleton::instance = nullptr;

单例模式：懒汉模式和饿汉模式
懒汉模式是指在第一次使用时才创建实例，而饿汉模式是在程序启动时就立即创建实例。
1.1 懒汉模式

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // 在首次调用时创建实例
        return instance;
    }

    // 禁止复制和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {} // 私有构造函数，确保无法通过外部代码创建实例
};

1.2 饿汉模式

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // 在程序启动时就创建实例
        return instance;
    }

    // 禁止复制和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {} // 私有构造函数，确保无法通过外部代码创建实例
};

注意：
示例中，getInstance() 函数返回对单例对象的引用，并且使用 static 变量确保只有一个实例被创建。需要注意的是，在多线程环境下，懒汉模式需要考虑线程安全性，可以使用加锁等方式来保证线程安全。而饿汉模式则不需要担心线程安全问题。

2、工厂模式(Factory)：用于创建对象的一个接口，让子类决定实例化哪个类

class Product {
public:
    virtual void show() = 0;
};
 
class ConcreteProduct : public Product {
public:
    void show() override {
        std::cout << "ConcreteProduct Show" << std::endl;
    }
};
 
class Factory {
public:
    virtual Product* createProduct() = 0;
};
 
class ConcreteFactory : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProduct();
    }
};

3、观察者模式(Obeserver)：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象

#include <iostream>
#include <list>
#include <string>
 
class Observer {
public:
    virtual void update(std::string message) = 0;
};
 
class ConcreteObserver : public Observer {
public:
    void update(std::string message) override {
        std::cout << "Received message: " << message << std::endl;
    }
};
 
class Subject {
private:
    std::list<Observer*> observers;
    std::string message;
 
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
 
    void notify() {
        for (auto observer : observers) {
            observer->update(message);
        }
    }
 
    void setMessage(std::string msg) {
        message = msg;
    }
};
 
int main() {
    Subject subject;
    Observer* observer = new ConcreteObserver();
    subject.attach(observer);
    subject.setMessage("Hello, World!");
    subject.notify();
    delete observer;
    return 0;
}