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 ConcreteProductAauto productB = SimpleFactory::createProduct("B");productB->use(); // 输出: Using ConcreteProductBreturn 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 ConcreteProductAConcreteFactoryB factoryB;auto productB = factoryB.createProduct();productB->use(); // 输出: Using ConcreteProductBreturn 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 ConcreteProductA1productB1->use(); // 输出: Using ConcreteProductB1ConcreteFactory2 factory2;auto productA2 = factory2.createProductA();auto productB2 = factory2.createProductB();productA2->use(); // 输出: Using ConcreteProductA2productB2->use(); // 输出: Using ConcreteProductB2return 0;
}4. 观察者模式
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>// Observer接口
class Observer {
public:virtual ~Observer() = default;virtual void update(float temperature, float humidity, float pressure) = 0;
};// Subject接口
class Subject {
public:virtual ~Subject() = default;virtual void registerObserver(Observer* o) = 0;virtual void removeObserver(Observer* o) = 0;virtual void notifyObservers() = 0;
};// 具体的Subject类（天气站）
class WeatherStation : public Subject {
private:std::vector<Observer*> observers; // 观察者列表float temperature;float humidity;float pressure;public:void registerObserver(Observer* o) override {observers.push_back(o);}void removeObserver(Observer* o) override {observers.erase(std::remove(observers.begin(), observers.end(), o), observers.end());}void notifyObservers() override {for (Observer* observer : observers) {observer->update(temperature, humidity, pressure);}}// 模拟天气数据变化void setMeasurements(float temp, float hum, float pres) {temperature = temp;humidity = hum;pressure = pres;notifyObservers(); // 通知所有观察者}
};// 具体的Observer类（当前天气显示）
class CurrentConditionsDisplay : public Observer {
private:float temperature;float humidity;Subject* weatherStation;public:CurrentConditionsDisplay(Subject* weatherStation) {this->weatherStation = weatherStation;weatherStation->registerObserver(this); // 注册观察者}~CurrentConditionsDisplay() {weatherStation->removeObserver(this); // 注销观察者}void update(float temp, float hum, float pres) override {temperature = temp;humidity = hum;display();}void display() {std::cout << "Current Conditions: " << temperature << "C degrees and " << humidity << "% humidity" << std::endl;}
};// 具体的Observer类（统计显示）
class StatisticsDisplay : public Observer {
private:float maxTemp;float minTemp;float tempSum;int numReadings;Subject* weatherStation;public:StatisticsDisplay(Subject* weatherStation) {this->weatherStation = weatherStation;weatherStation->registerObserver(this); // 注册观察者resetStats();}~StatisticsDisplay() {weatherStation->removeObserver(this); // 注销观察者}void update(float temp, float hum, float pres) override {tempSum += temp;numReadings++;maxTemp = std::max(maxTemp, temp);minTemp = std::min(minTemp, temp);display();}void display() {std::cout << "Avg/Max/Min temperature = " << (tempSum / numReadings) << "/"<< maxTemp << "/" << minTemp << std::endl;}void resetStats() {maxTemp = -1000;minTemp = 1000;tempSum = 0;numReadings = 0;}
};// 测试代码
int main() {WeatherStation weatherStation;CurrentConditionsDisplay currentDisplay(&weatherStation);StatisticsDisplay statsDisplay(&weatherStation);// 模拟天气数据变化weatherStation.setMeasurements(25.0, 65.0, 1013.0);weatherStation.setMeasurements(26.5, 70.0, 1012.0);weatherStation.setMeasurements(24.0, 75.0, 1014.0);return 0;
}
