C++ 设计模式

1. 单例模式

1.1 懒汉模式(使用时才创建)

#include <mutex>
#include <iostream>

class singlelon
{
public:
    static singlelon* getInstance()
    {
        if (instance_ != nullptr)
        {
            std::lock_guard<std::mutex> lock(mtx_);
            if (instance_ != nullptr)
            {
                instance_ = new singlelon();
            }
        }

        return instance_;
    }

    static void destory()
    {
        std::lock_guard<std::mutex> lock(mtx_);
        if (instance_!= nullptr)
            delete instance_;
        instance_ = nullptr;
    }

private:
    singlelon();    
    ~singlelon();
    singlelon(const singlelon&) = delete;
    singlelon& operator=(const singlelon&) = delete;

    static singlelon* instance_;
    static std::mutex mtx_;
};

singlelon* singlelon::instance_ = nullptr;
std::mutex singlelon::mtx_;

1.2 饿汉模式(程序启动就创建实例)

2. 外观模式

        外观模式是一种结构型设计模式，用于为复杂的子系统提供一个简化的接口。它隐藏了子系统的复杂性，使得客户端可以使用一个简单的接口来访问子系统中的功能。

#include <iostream>
using namespace std;

// 子系统1：音频播放器
class AudioPlayer {
public:
    void play() {
        cout << "AudioPlayer: Playing audio..." << endl;
    }

    void stop() {
        cout << "AudioPlayer: Stopping audio..." << endl;
    }
};

// 子系统2：视频播放器
class VideoPlayer {
public:
    void play() {
        cout << "VideoPlayer: Playing video..." << endl;
    }

    void stop() {
        cout << "VideoPlayer: Stopping video..." << endl;
    }
};

// 子系统3：字幕处理器
class SubtitleProcessor {
public:
    void display() {
        cout << "SubtitleProcessor: Displaying subtitles..." << endl;
    }

    void hide() {
        cout << "SubtitleProcessor: Hiding subtitles..." << endl;
    }
};

// 外观类
class MediaPlayerFacade {
private:
    AudioPlayer audioPlayer;
    VideoPlayer videoPlayer;
    SubtitleProcessor subtitleProcessor;

public:
    void playMedia() {
        cout << "MediaPlayerFacade: Starting media playback..." << endl;
        audioPlayer.play();
        videoPlayer.play();
        subtitleProcessor.display();
    }

    void stopMedia() {
        cout << "MediaPlayerFacade: Stopping media playback..." << endl;
        subtitleProcessor.hide();
        videoPlayer.stop();
        audioPlayer.stop();
    }
};

// 客户端代码
int main() {
    MediaPlayerFacade mediaPlayer;

    cout << "Client: Starting media playback..." << endl;
    mediaPlayer.playMedia();

    cout << "Client: Stopping media playback..." << endl;
    mediaPlayer.stopMedia();

    return 0;
}

3. 工厂模式

3.1 简单工厂模式

        简单工厂模式 : 核心思想， 一个产品的基类，多个具体的产品继承这个基类，重写基类的方法，在建一个工厂类，使用一个静态方法，根据不同类型，创建不同的产品对象。

        但是他违反了开闭原则

#include <iostream>
#include <string>
#include <memory>

// 基类
class Product {
public:
    virtual ~Product() = default;
    virtual void use() const = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductA\n";
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductB\n";
    }
};

// 工厂类
class SimpleFactory {
public:
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") {
            return std::make_unique<ConcreteProductA>();
        } else if (type == "B") {
            return std::make_unique<ConcreteProductB>();
        } else {
            throw std::invalid_argument("Unknown product type");
        }
    }
};

int main() {
    auto productA = SimpleFactory::createProduct("A");
    productA->use();  // 输出: Using ConcreteProductA

    auto productB = SimpleFactory::createProduct("B");
    productB->use();  // 输出: Using ConcreteProductB

    return 0;
}

3.2 工厂方法模式

        工厂方法模式通过定义一个创建对象的接口（工厂方法），让子类决定实例化哪一个类。工厂方法模式将对象的创建逻辑封装到子类中.

        核心思想：与简单工厂不同的是，这个工厂也建立个基类，然后多个工厂继承他，重写他的创建产品的方法，每个工厂独立创建对应的产品。

#include <iostream>
#include <memory>

// 基类
class Product {
public:
    virtual ~Product() = default;
    virtual void use() const = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductA\n";
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductB\n";
    }
};

// 抽象工厂
class Factory {
public:
    virtual ~Factory() = default;
    virtual std::unique_ptr<Product> createProduct() const = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() const override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() const override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    ConcreteFactoryA factoryA;
    auto productA = factoryA.createProduct();
    productA->use();  // 输出: Using ConcreteProductA

    ConcreteFactoryB factoryB;
    auto productB = factoryB.createProduct();
    productB->use();  // 输出: Using ConcreteProductB

    return 0;
}

3.3 抽象工厂模式

        抽象工厂模式是一种更高级的工厂模式，用于创建一组相关或依赖的对象，而无需指定它们的具体类。它通过定义一个工厂接口，创建一组相关的产品。

        核心思想：创建一组相关的对象，A类产品基类，多个产品继承他，重写基类方法，还有个B类产品基类。也有多个产品继承他，重写他的方法。而工厂基类就会有多个继承他的子工厂，执行创建对象的功能，如工厂1 生产 A1 B1产品  ，而工厂2用来生产A2，B2产品。

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() = default;
    virtual void use() const = 0;
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() = default;
    virtual void use() const = 0;
};

// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void use() const override {
        std::cout << "Using ConcreteProductA1\n";
    }
};

// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void use() const override {
        std::cout << "Using ConcreteProductA2\n";
    }
};

// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void use() const override {
        std::cout << "Using ConcreteProductB1\n";
    }
};

// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void use() const override {
        std::cout << "Using ConcreteProductB2\n";
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() = default;
    virtual std::unique_ptr<AbstractProductA> createProductA() const = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() const = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() const override {
        return std::make_unique<ConcreteProductA1>();
    }

    std::unique_ptr<AbstractProductB> createProductB() const override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() const override {
        return std::make_unique<ConcreteProductA2>();
    }

    std::unique_ptr<AbstractProductB> createProductB() const override {
        return std::make_unique<ConcreteProductB2>();
    }
};

int main() {
    ConcreteFactory1 factory1;
    auto productA1 = factory1.createProductA();
    auto productB1 = factory1.createProductB();
    productA1->use();  // 输出: Using ConcreteProductA1
    productB1->use();  // 输出: Using ConcreteProductB1

    ConcreteFactory2 factory2;
    auto productA2 = factory2.createProductA();
    auto productB2 = factory2.createProductB();
    productA2->use();  // 输出: Using ConcreteProductA2
    productB2->use();  // 输出: Using ConcreteProductB2

    return 0;
}

4. 观察者模式