#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
// 觀察者抽象接口
class Observer {
public:
    // 純虛函數(shù)：接收通知并更新（參數(shù)：溫度、濕度）
    virtual void Update(float temperature, float humidity) = 0;
    // 虛析構函數(shù)：確保子類析構時正確釋放資源
    virtual ~Observer() {}
};

// 被觀察者抽象接口
class Subject {
public:
    // 注冊觀察者
    virtual void RegisterObserver(Observer* observer) = 0;
    // 解注冊觀察者
    virtual void RemoveObserver(Observer* observer) = 0;
    // 通知所有觀察者
    virtual void NotifyObservers() = 0;
    virtual ~Subject() {}
};

// 具體被觀察者：氣象站
class WeatherStation : public Subject {
private:
    vector<Observer*> observers;  // 存儲注冊的觀察者
    float temperature;            // 溫度
    float humidity;               // 濕度
    // 檢查觀察者是否已注冊（輔助函數(shù)）
    bool IsObserverRegistered(Observer* observer) const {
        return find(observers.begin(), observers.end(), observer) != observers.end();
    }
public:
    // 注冊觀察者：添加到列表（避免重復注冊）
    void RegisterObserver(Observer* observer) override {
        if (observer == nullptr) {
            throw invalid_argument("觀察者不能為空指針！");
        }
        if (!IsObserverRegistered(observer)) {
            observers.push_back(observer);
            cout << "觀察者注冊成功：" << typeid(*observer).name() << endl;
        } else {
            cout << "觀察者已注冊，無需重復添加：" << typeid(*observer).name() << endl;
        }
    }
    // 解注冊觀察者：從列表中移除
    void RemoveObserver(Observer* observer) override {
        auto iter = find(observers.begin(), observers.end(), observer);
        if (iter != observers.end()) {
            observers.erase(iter);
            cout << "觀察者解注冊成功：" << typeid(*observer).name() << endl;
        } else {
            cout << "觀察者未注冊，無法解注冊：" << typeid(*observer).name() << endl;
        }
    }
    // 通知所有觀察者：遍歷列表并調用 Update 方法
    void NotifyObservers() override {
        cout << "\n氣象站數(shù)據(jù)更新，開始通知所有觀察者..." << endl;
        for (Observer* observer : observers) {
            observer->Update(temperature, humidity);
        }
    }
    // 模擬氣象數(shù)據(jù)更新（外部調用，觸發(fā)通知）
    void SetWeatherData(float temp, float humi) {
        this->temperature = temp;
        this->humidity = humi;
        cout << "\n氣象站數(shù)據(jù)更新：溫度=" << temp << "℃，濕度=" << humi << "%" << endl;
        NotifyObservers();  // 數(shù)據(jù)更新后自動通知
    }
};

// 具體觀察者1：顯示屏（展示實時數(shù)據(jù)）
class DisplayScreen : public Observer {
private:
    string screenName;  // 顯示屏名稱（如"客廳顯示屏"）
public:
    DisplayScreen(const string& name) : screenName(name) {}
    void Update(float temperature, float humidity) override {
        cout << "[" << screenName << "] 實時數(shù)據(jù)展示：溫度=" << temperature << "℃，濕度=" << humidity << "%" << endl;
    }
};
// 具體觀察者2：手機 App（推送通知）
class MobileApp : public Observer {
private:
    string userName;  // 用戶名
public:
    MobileApp(const string& name) : userName(name) {}
    void Update(float temperature, float humidity) override {
        cout << "[" << userName << "的手機 App] 推送通知：當前溫度" << temperature << "℃，濕度" << humidity << "%" << endl;
    }
};
// 具體觀察者3：報警器（濕度超標時報警）
class Alarm : public Observer {
private:
    float humidityThreshold;  // 濕度閾值（超過則報警）
public:
    Alarm(float threshold) : humidityThreshold(threshold) {}
    void Update(float temperature, float humidity) override {
        if (humidity > humidityThreshold) {
            cout << "[報警器] 警告！濕度超標（當前" << humidity << "%，閾值" << humidityThreshold << "%），請及時通風！" << endl;
        } else {
            cout << "[報警器] 濕度正常（當前" << humidity << "%），無報警" << endl;
        }
    }
};

int main() {
    try {
        // 1. 創(chuàng)建被觀察者：氣象站
        WeatherStation weatherStation;
        // 2. 創(chuàng)建觀察者
        Observer* livingRoomScreen = new DisplayScreen("客廳顯示屏");
        Observer* bedroomScreen = new DisplayScreen("臥室顯示屏");
        Observer* userApp = new MobileApp("張三");
        Observer* humidityAlarm = new Alarm(60.0f);  // 濕度閾值60%
        // 3. 注冊觀察者
        weatherStation.RegisterObserver(livingRoomScreen);
        weatherStation.RegisterObserver(bedroomScreen);
        weatherStation.RegisterObserver(userApp);
        weatherStation.RegisterObserver(humidityAlarm);
        // 4. 模擬數(shù)據(jù)更新（觸發(fā)第一次通知）
        weatherStation.SetWeatherData(25.5f, 55.0f);
        // 5. 解注冊臥室顯示屏（不再接收通知）
        weatherStation.RemoveObserver(bedroomScreen);
        cout << "\n--- 解注冊臥室顯示屏后 ---" << endl;
        // 6. 模擬數(shù)據(jù)更新（觸發(fā)第二次通知，臥室顯示屏不再接收）
        weatherStation.SetWeatherData(26.8f, 62.0f);  // 濕度超標，報警器會報警
        // 7. 釋放資源
        delete livingRoomScreen;
        delete bedroomScreen;
        delete userApp;
        delete humidityAlarm;
    } catch (const exception& e) {
        cout << "錯誤：" << e.what() << endl;
    }
    return 0;
}

#include <mutex>
// 線程安全的氣象站（繼承自原 WeatherStation，重寫核心方法）
class ThreadSafeWeatherStation : public Subject {
private:
    vector<Observer*> observers;
    float temperature;
    float humidity;
    mutex mtx;  // 互斥鎖，保護觀察者列表
public:
    void RegisterObserver(Observer* observer) override {
        if (observer == nullptr) {
            throw invalid_argument("觀察者不能為空指針！");
        }
        lock_guard<mutex> lock(mtx);  // 自動加鎖/解鎖
        auto iter = find(observers.begin(), observers.end(), observer);
        if (iter == observers.end()) {
            observers.push_back(observer);
            cout << "線程安全注冊：" << typeid(*observer).name() << endl;
        }
    }
    void RemoveObserver(Observer* observer) override {
        lock_guard<mutex> lock(mtx);
        auto iter = find(observers.begin(), observers.end(), observer);
        if (iter != observers.end()) {
            observers.erase(iter);
            cout << "線程安全解注冊：" << typeid(*observer).name() << endl;
        }
    }
    void NotifyObservers() override {
        lock_guard<mutex> lock(mtx);
        cout << "\n線程安全通知所有觀察者..." << endl;
        // 拷貝一份觀察者列表，避免遍歷過程中列表被修改（如解注冊）
        vector<Observer*> tempObservers = observers;
        lock.unlock();  // 提前解鎖，減少阻塞時間
        for (Observer* observer : tempObservers) {
            observer->Update(temperature, humidity);
        }
    }
    void SetWeatherData(float temp, float humi) {
        lock_guard<mutex> lock(mtx);
        this->temperature = temp;
        this->humidity = humi;
        cout << "\n線程安全氣象站數(shù)據(jù)：溫度=" << temp << "℃，濕度=" << humi << "%" << endl;
        lock.unlock();
        NotifyObservers();  // 通知操作在解鎖后執(zhí)行，避免阻塞寫操作
    }
};

#include <thread>
#include <queue>
#include <condition_variable>
// 簡單線程池（用于異步執(zhí)行任務）
class ThreadPool {
private:
    vector<thread> workers;       // 工作線程
    queue<function<void()>> tasks;// 任務隊列
    mutex mtx;                    // 保護任務隊列
    condition_variable cv;        // 條件變量，喚醒線程
    bool stop;                    // 線程池停止標志
public:
    // 構造函數(shù)：創(chuàng)建n個工作線程
    ThreadPool(size_t n) : stop(false) {
        for (size_t i = 0; i < n; ++i) {
            workers.emplace_back([this]() {
                while (true) {
                    function<void()> task;
                    {
                        unique_lock<mutex> lock(this->mtx);
                        // 等待任務或停止信號
                        this->cv.wait(lock, [this]() {
                            return this->stop || !this->tasks.empty();
                        });
                        // 線程池停止且任務隊列為空，退出線程
                        if (this->stop && this->tasks.empty()) {
                            return;
                        }
                        // 取出任務
                        task = move(this->tasks.front());
                        this->tasks.pop();
                    }
                    // 執(zhí)行任務
                    task();
                }
            });
        }
    }
    // 析構函數(shù)：停止線程池
    ~ThreadPool() {
        {
            unique_lock<mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();  // 喚醒所有工作線程
        for (thread& worker : workers) {
            worker.join();  // 等待所有線程完成
        }
    }
    // 添加任務到線程池
    template<typename F>
    void Enqueue(F&& f) {
        {
            unique_lock<mutex> lock(mtx);
            if (stop) {
                throw runtime_error("線程池已停止，無法添加任務！");
            }
            tasks.emplace(forward<F>(f));
        }
        cv.notify_one();  // 喚醒一個工作線程
    }
};
// 異步通知的氣象站
class AsyncWeatherStation : public Subject {
private:
    vector<Observer*> observers;
    float temperature;
    float humidity;
    mutex mtx;
    ThreadPool pool;  // 線程池（2個工作線程）
public:
    AsyncWeatherStation() : pool(2) {}
    void RegisterObserver(Observer* observer) override {
        lock_guard<mutex> lock(mtx);
        if (observer && find(observers.begin(), observers.end(), observer) == observers.end()) {
            observers.push_back(observer);
        }
    }
    void RemoveObserver(Observer* observer) override {
        lock_guard<mutex> lock(mtx);
        auto iter = find(observers.begin(), observers.end(), observer);
        if (iter != observers.end()) {
            observers.erase(iter);
        }
    }
    void NotifyObservers() override {
        lock_guard<mutex> lock(mtx);
        vector<Observer*> tempObservers = observers;
        float temp = temperature;
        float humi = humidity;
        // 異步執(zhí)行每個觀察者的 Update 方法
        for (Observer* observer : tempObservers) {
            pool.Enqueue([observer, temp, humi]() {
                observer->Update(temp, humi);
            });
        }
    }
    void SetWeatherData(float temp, float humi) {
        lock_guard<mutex> lock(mtx);
        this->temperature = temp;
        this->humidity = humi;
        cout << "\n異步氣象站數(shù)據(jù)更新：溫度=" << temp << "℃，濕度=" << humi << "%" << endl;
        lock.unlock();
        NotifyObservers();
    }
};

// 模擬耗時的觀察者（如網(wǎng)絡請求）
class SlowObserver : public Observer {
public:
    void Update(float temperature, float humidity) override {
        cout << "[耗時觀察者] 開始處理數(shù)據(jù)（模擬網(wǎng)絡請求）..." << endl;
        this_thread::sleep_for(chrono::seconds(2));  // 模擬2秒耗時
        cout << "[耗時觀察者] 數(shù)據(jù)處理完成：溫度=" << temperature << "℃" << endl;
    }
};
int main() {
    AsyncWeatherStation weatherStation;
    Observer* fastObserver = new DisplayScreen("快速顯示屏");
    Observer* slowObserver = new SlowObserver();
    weatherStation.RegisterObserver(fastObserver);
    weatherStation.RegisterObserver(slowObserver);
    weatherStation.SetWeatherData(24.0f, 58.0f);
    cout << "主線程繼續(xù)執(zhí)行其他任務..." << endl;
    // 等待異步任務完成（實際項目中無需手動等待，線程池會后臺處理）
    this_thread::sleep_for(chrono::seconds(3));
    delete fastObserver;
    delete slowObserver;
    return 0;
}

#include <iostream>
#include <string>
#include <memory>
using namespace std;
// 策略抽象：折扣策略
class DiscountStrategy {
public:
    // 純虛函數(shù)：計算折扣后的價格（參數(shù)：原價）
    virtual float CalculateDiscount(float originalPrice) const = 0;
    // 獲取策略名稱（用于日志輸出）
    virtual string GetStrategyName() const = 0;
    virtual ~DiscountStrategy() {}
};

// 具體策略1：普通用戶策略（無折扣）
class NormalUserStrategy : public DiscountStrategy {
public:
    float CalculateDiscount(float originalPrice) const override {
        return originalPrice;  // 無折扣，原價返回
    }
    string GetStrategyName() const override {
        return "普通用戶無折扣";
    }
};
// 具體策略2：VIP用戶策略（9折）
class VIPUserStrategy : public DiscountStrategy {
public:
    float CalculateDiscount(float originalPrice) const override {
        return originalPrice * 0.9f;  // 9折
    }
    string GetStrategyName() const override {
        return "VIP用戶9折";
    }
};
// 具體策略3：超級VIP用戶策略（8折+滿1000減200）
class SuperVIPUserStrategy : public DiscountStrategy {
public:
    float CalculateDiscount(float originalPrice) const override {
        float discountPrice = originalPrice * 0.8f;  // 先打8折
        if (discountPrice >= 1000) {
            discountPrice -= 200;  // 滿1000減200
        }
        return discountPrice;
    }
    string GetStrategyName() const override {
        return "超級VIP用戶8折+滿1000減200";
    }
};
// 具體策略4：節(jié)日折扣策略（7折，限節(jié)日使用）
class FestivalDiscountStrategy : public DiscountStrategy {
public:
    float CalculateDiscount(float originalPrice) const override {
        return originalPrice * 0.7f;  // 7折
    }
    string GetStrategyName() const override {
        return "節(jié)日折扣7折";
    }
};

// 上下文：訂單結算系統(tǒng)
class OrderSettlement {
private:
    // 持有策略對象（使用智能指針，自動管理內存）
    shared_ptr<DiscountStrategy> strategy;
public:
    // 構造函數(shù)：初始化策略（默認普通用戶策略）
    OrderSettlement() : strategy(make_shared<NormalUserStrategy>()) {}
    // 動態(tài)切換策略（核心方法：支持運行時更換策略）
    void SetDiscountStrategy(shared_ptr<DiscountStrategy> newStrategy) {
        if (newStrategy == nullptr) {
            throw invalid_argument("策略不能為空！");
        }
        strategy = newStrategy;
        cout << "折扣策略切換為：" << strategy->GetStrategyName() << endl;
    }
    // 結算：調用當前策略計算最終價格
    float Settle(float originalPrice) const {
        if (originalPrice < 0) {
            throw invalid_argument("商品原價不能為負數(shù)！");
        }
        float finalPrice = strategy->CalculateDiscount(originalPrice);
        cout << "當前策略：" << strategy->GetStrategyName() << endl;
        cout << "商品原價：" << originalPrice << "元，最終價格：" << finalPrice << "元" << endl;
        return finalPrice;
    }
};

int main() {
    try {
        // 1. 創(chuàng)建上下文：訂單結算系統(tǒng)
        OrderSettlement settlement;
        // 2. 普通用戶結算（默認策略）
        cout << "=== 普通用戶購買商品（原價500元）===" << endl;
        settlement.Settle(500.0f);
        // 3. 切換為VIP用戶策略
        cout << "\n=== VIP用戶購買商品（原價800元）===" << endl;
        settlement.SetDiscountStrategy(make_shared<VIPUserStrategy>());
        settlement.Settle(800.0f);
        // 4. 切換為超級VIP用戶策略
        cout << "\n=== 超級VIP用戶購買商品（原價1500元）===" << endl;
        settlement.SetDiscountStrategy(make_shared<SuperVIPUserStrategy>());
        settlement.Settle(1500.0f);
        // 5. 切換為節(jié)日折扣策略
        cout << "\n=== 節(jié)日期間購買商品（原價2000元）===" << endl;
        settlement.SetDiscountStrategy(make_shared<FestivalDiscountStrategy>());
        settlement.Settle(2000.0f);
        // 6. 新增策略：無需修改結算系統(tǒng)代碼，直接使用
        cout << "\n=== 新增優(yōu)惠券策略（假設已實現(xiàn)）===" << endl;
        // 假設新增 CouponDiscountStrategy，直接通過 SetDiscountStrategy 切換
        // settlement.SetDiscountStrategy(make_shared<CouponDiscountStrategy>());
        // settlement.Settle(1000.0f);
    } catch (const exception& e) {
        cout << "結算失?。? << e.what() << endl;
    }
    return 0;
}

// 結合簡單工廠的上下文
class FactoryStrategySettlement {
private:
    shared_ptr<DiscountStrategy> strategy;
    // 簡單工廠：根據(jù)用戶類型創(chuàng)建策略
    shared_ptr<DiscountStrategy> CreateStrategy(const string& userType) {
        if (userType == "normal") {
            return make_shared<NormalUserStrategy>();
        } else if (userType == "vip") {
            return make_shared<VIPUserStrategy>();
        } else if (userType == "super_vip") {
            return make_shared<SuperVIPUserStrategy>();
        } else {
            throw invalid_argument("不支持的用戶類型：" + userType);
        }
    }
public:
    // 根據(jù)用戶類型自動選擇策略
    FactoryStrategySettlement(const string& userType) {
        strategy = CreateStrategy(userType);
    }
    float Settle(float originalPrice) const {
        float finalPrice = strategy->CalculateDiscount(originalPrice);
        cout << "用戶類型對應策略：" << strategy->GetStrategyName() << endl;
        cout << "原價：" << originalPrice << "元，最終價：" << finalPrice << "元" << endl;
        return finalPrice;
    }
};
// 客戶端使用
int main() {
    FactoryStrategySettlement vipSettlement("vip");
    vipSettlement.Settle(1000.0f);  // 自動使用VIP策略
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <mutex>
#include <memory>
#include <thread>
using namespace std;
// -------------------------- 部分1：觀察者模式（訂單狀態(tài)通知） --------------------------
// 觀察者抽象：接收訂單狀態(tài)通知
class OrderStatusObserver {
public:
    virtual void OnStatusChanged(const string& orderId, const string& status) = 0;
    virtual string GetObserverName() const = 0;
    virtual ~OrderStatusObserver() {}
};
// 具體觀察者1：客戶 App
class CustomerAppObserver : public OrderStatusObserver {
public:
    void OnStatusChanged(const string& orderId, const string& status) override {
        cout << "[客戶 App] 訂單" << orderId << "狀態(tài)更新為：" << status << "，已推送通知給客戶" << endl;
    }
    string GetObserverName() const override {
        return "客戶 App";
    }
};
// 具體觀察者2：商家后臺
class MerchantBackendObserver : public OrderStatusObserver {
public:
    void OnStatusChanged(const string& orderId, const string& status) override {
        cout << "[商家后臺] 訂單" << orderId << "狀態(tài)更新為：" << status << "，已同步至商家管理系統(tǒng)" << endl;
    }
    string GetObserverName() const override {
        return "商家后臺";
    }
};
// 具體觀察者3：物流系統(tǒng)
class LogisticsSystemObserver : public OrderStatusObserver {
public:
    void OnStatusChanged(const string& orderId, const string& status) override {
        cout << "[物流系統(tǒng)] 訂單" << orderId << "狀態(tài)更新為：" << status << "，已觸發(fā)物流調度" << endl;
    }
    string GetObserverName() const override {
        return "物流系統(tǒng)";
    }
};
// 被觀察者：訂單
class Order : public Subject {
private:
    string orderId;
    string status;  // 訂單狀態(tài)："unpaid"（未支付）、"paid"（已支付）、"shipped"（已發(fā)貨）、"received"（已簽收）
    vector<OrderStatusObserver*> observers;
    mutex mtx;
public:
    Order(const string& id) : orderId(id), status("unpaid") {}
    // 注冊觀察者（重寫 Subject 接口）
    void RegisterObserver(Observer* observer) override {
        if (observer == nullptr) return;
        OrderStatusObserver* statusObserver = dynamic_cast<OrderStatusObserver*>(observer);
        if (statusObserver == nullptr) {
            throw invalid_argument("觀察者類型不匹配！");
        }
        lock_guard<mutex> lock(mtx);
        auto iter = find(observers.begin(), observers.end(), statusObserver);
        if (iter == observers.end()) {
            observers.push_back(statusObserver);
            cout << "訂單" << orderId << "注冊觀察者：" << statusObserver->GetObserverName() << endl;
        }
    }
    // 解注冊觀察者（重寫 Subject 接口）
    void RemoveObserver(Observer* observer) override {
        OrderStatusObserver* statusObserver = dynamic_cast<OrderStatusObserver*>(observer);
        if (statusObserver == nullptr) return;
        lock_guard<mutex> lock(mtx);
        auto iter = find(observers.begin(), observers.end(), statusObserver);
        if (iter != observers.end()) {
            observers.erase(iter);
            cout << "訂單" << orderId << "解注冊觀察者：" << statusObserver->GetObserverName() << endl;
        }
    }
    // 通知觀察者（重寫 Subject 接口）
    void NotifyObservers() override {
        lock_guard<mutex> lock(mtx);
        vector<OrderStatusObserver*> tempObservers = observers;
        string tempOrderId = orderId;
        string tempStatus = status;
        // 異步通知（避免阻塞訂單狀態(tài)更新）
        thread([tempObservers, tempOrderId, tempStatus]() {
            for (OrderStatusObserver* observer : tempObservers) {
                observer->OnStatusChanged(tempOrderId, tempStatus);
            }
        }).detach();
    }
    // 更新訂單狀態(tài)（觸發(fā)通知）
    void UpdateStatus(const string& newStatus) {
        if (newStatus != "unpaid" && newStatus != "paid" && newStatus != "shipped" && newStatus != "received") {
            throw invalid_argument("無效的訂單狀態(tài)：" + newStatus);
        }
        lock_guard<mutex> lock(mtx);
        if (this->status == newStatus) {
            cout << "訂單" << orderId << "狀態(tài)未變化（當前：" << newStatus << "）" << endl;
            return;
        }
        this->status = newStatus;
        cout << "\n訂單" << orderId << "狀態(tài)更新為：" << newStatus << endl;
        NotifyObservers();
    }
    // 獲取訂單狀態(tài)
    string GetStatus() const {
        lock_guard<mutex> lock(mtx);
        return status;
    }
    // 獲取訂單ID
    string GetOrderId() const {
        return orderId;
    }
};
// -------------------------- 部分2：策略模式（物流調度算法） --------------------------
// 策略抽象：調度策略
class DispatchStrategy {
public:
    virtual string Dispatch(const string& orderId, const string& orderType) const = 0;
    virtual string GetStrategyName() const = 0;
    virtual ~DispatchStrategy() {}
};
// 具體策略1：普通調度（適用于普通訂單）
class NormalDispatchStrategy : public DispatchStrategy {
public:
    string Dispatch(const string& orderId, const string& orderType) const override {
        string result = "訂單" + orderId + "（" + orderType + "）使用普通調度：分配常規(guī)物流車輛，預計3-5天送達";
        cout << result << endl;
        return result;
    }
    string GetStrategyName() const override {
        return "普通調度策略";
    }
};
// 具體策略2：優(yōu)先調度（適用于加急訂單）
class PriorityDispatchStrategy : public DispatchStrategy {
public:
    string Dispatch(const string& orderId, const string& orderType) const override {
        string result = "訂單" + orderId + "（" + orderType + "）使用優(yōu)先調度：分配加急物流車輛，預計1-2天送達";
        cout << result << endl;
        return result;
    }
    string GetStrategyName() const override {
        return "優(yōu)先調度策略";
    }
};
// 具體策略3：大件調度（適用于大件訂單）
class LargeItemDispatchStrategy : public DispatchStrategy {
public:
    string Dispatch(const string& orderId, const string& orderType) const override {
        string result = "訂單" + orderId + "（" + orderType + "）使用大件調度：分配專用大件物流車輛，預計2-4天送達";
        cout << result << endl;
        return result;
    }
    string GetStrategyName() const override {
        return "大件調度策略";
    }
};
// 上下文：物流調度系統(tǒng)
class LogisticsDispatchSystem {
private:
    mutex mtx;
    // 策略映射：訂單類型 -> 策略（支持動態(tài)配置）
    map<string, shared_ptr<DispatchStrategy>> strategyMap;
public:
    // 初始化默認策略
    LogisticsDispatchSystem() {
        strategyMap["normal"] = make_shared<NormalDispatchStrategy>();       // 普通訂單
        strategyMap["express"] = make_shared<PriorityDispatchStrategy>();    // 加急訂單
        strategyMap["large"] = make_shared<LargeItemDispatchStrategy>();     // 大件訂單
    }
    // 注冊新策略（支持動態(tài)新增）
    void RegisterStrategy(const string& orderType, shared_ptr<DispatchStrategy> strategy) {
        if (orderType.empty() || strategy == nullptr) {
            throw invalid_argument("訂單類型或策略不能為空！");
        }
        lock_guard<mutex> lock(mtx);
        strategyMap[orderType] = strategy;
        cout << "注冊新調度策略：訂單類型=" << orderType << "，策略=" << strategy->GetStrategyName() << endl;
    }
    // 執(zhí)行調度（根據(jù)訂單類型選擇策略）
    string DispatchOrder(const string& orderId, const string& orderType) {
        lock_guard<mutex> lock(mtx);
        auto iter = strategyMap.find(orderType);
        if (iter == strategyMap.end()) {
            throw invalid_argument("不支持的訂單類型：" + orderType);
        }
        return iter->second->Dispatch(orderId, orderType);
    }
};
// -------------------------- 部分3：系統(tǒng)整合與客戶端測試 --------------------------
// 系統(tǒng)整合：訂單狀態(tài)更新后觸發(fā)調度
void OnOrderStatusUpdated(const shared_ptr<Order>& order, const shared_ptr<LogisticsDispatchSystem>& dispatchSystem, const string& orderType) {
    string status = order->GetStatus();
    if (status == "paid") {  // 訂單已支付，觸發(fā)調度
        cout << "\n--- 訂單" << order->GetOrderId() << "已支付，開始物流調度 ---" << endl;
        dispatchSystem->DispatchOrder(order->GetOrderId(), orderType);
    }
}
int main() {
    try {
        // 1. 創(chuàng)建物流調度系統(tǒng)
        auto dispatchSystem = make_shared<LogisticsDispatchSystem>();
        // 2. 創(chuàng)建觀察者
        auto customerApp = make_shared<CustomerAppObserver>();
        auto merchantBackend = make_shared<MerchantBackendObserver>();
        auto logisticsSystem = make_shared<LogisticsSystemObserver>();
        // 3. 創(chuàng)建訂單（普通訂單、加急訂單）
        auto normalOrder = make_shared<Order>("ORD20240501001");  // 普通訂單
        auto expressOrder = make_shared<Order>("ORD20240501002"); // 加急訂單
        // 4. 為訂單注冊觀察者
        normalOrder->RegisterObserver(customerApp.get());
        normalOrder->RegisterObserver(merchantBackend.get());
        normalOrder->RegisterObserver(logisticsSystem.get());
        expressOrder->RegisterObserver(customerApp.get());
        expressOrder->RegisterObserver(merchantBackend.get());
        expressOrder->RegisterObserver(logisticsSystem.get());
        // 5. 模擬普通訂單流程：未支付 -> 已支付（觸發(fā)調度）-> 已發(fā)貨 -> 已簽收
        cout << "=== 普通訂單流程 ===" << endl;
        normalOrder->UpdateStatus("paid");  // 已支付，觸發(fā)調度
        this_thread::sleep_for(chrono::seconds(1));  // 等待異步通知完成
        OnOrderStatusUpdated(normalOrder, dispatchSystem, "normal");
        normalOrder->UpdateStatus("shipped");  // 已發(fā)貨
        this_thread::sleep_for(chrono::seconds(1));
        normalOrder->UpdateStatus("received");  // 已簽收
        this_thread::sleep_for(chrono::seconds(1));
        // 6. 模擬加急訂單流程
        cout << "\n=== 加急訂單流程 ===" << endl;
        expressOrder->UpdateStatus("paid");  // 已支付，觸發(fā)調度
        this_thread::sleep_for(chrono::seconds(1));
        OnOrderStatusUpdated(expressOrder, dispatchSystem, "express");
        // 7. 新增冷鏈物流策略（擴展功能）
        class ColdChainDispatchStrategy : public DispatchStrategy {
        public:
            string Dispatch(const string& orderId, const string& orderType) const override {
                return "訂單" + orderId + "（" + orderType + "）使用冷鏈調度：分配冷藏物流車輛，預計1-2天送達";
            }
            string GetStrategyName() const override { return "冷鏈調度策略"; }
        };
        dispatchSystem->RegisterStrategy("cold_chain", make_shared<ColdChainDispatchStrategy>());
        // 8. 測試新增的冷鏈訂單
        auto coldChainOrder = make_shared<Order>("ORD20240501003");
        coldChainOrder->RegisterObserver(customerApp.get());
        cout << "\n=== 冷鏈訂單流程 ===" << endl;
        coldChainOrder->UpdateStatus("paid");
        this_thread::sleep_for(chrono::seconds(1));
        OnOrderStatusUpdated(coldChainOrder, dispatchSystem, "cold_chain");
    } catch (const exception& e) {
        cout << "系統(tǒng)錯誤：" << e.what() << endl;
    }
    return 0;
}