#include <vector>
#include <iostream>

struct MACDResult {
    std::vector<double> dif;    // 快慢线差值 (DIF)
    std::vector<double> dea;    // 信号线 (DEA)
    std::vector<double> macd;   // 柱状图 (Histogram)
};

/**
 * 计算 MACD
 * @param prices 输入价格序列
 * @param short_period 快线周期 (10)
 * @param long_period 慢线周期 (30)
 * @param signal_period 信号线周期 (8)
 */
MACDResult calculateMACD(const std::vector<double>& prices, 
                        int short_period = 10, 
                        int long_period = 30, 
                        int signal_period = 8) {
    size_t n = prices.size();
    MACDResult res;
    
    if (n < (size_t)long_period) return res; // 数据不足

    res.dif.resize(n, 0.0);
    res.dea.resize(n, 0.0);
    res.macd.resize(n, 0.0);

    double ema_short = prices[0];
    double ema_long = prices[0];
    
    // 乘数因子
    double k_short = 2.0 / (short_period + 1);
    double k_long = 2.0 / (long_period + 1);
    double k_signal = 2.0 / (signal_period + 1);

    // 1. 计算 DIF (Short EMA - Long EMA)
    for (size_t i = 0; i < n; ++i) {
        ema_short = prices[i] * k_short + ema_short * (1.0 - k_short);
        ema_long = prices[i] * k_long + ema_long * (1.0 - k_long);
        res.dif[i] = ema_short - ema_long;
    }

    // 2. 计算 DEA (DIF 的 EMA)
    double ema_signal = res.dif[0];
    for (size_t i = 0; i < n; ++i) {
        ema_signal = res.dif[i] * k_signal + ema_signal * (1.0 - k_signal);
        res.dea[i] = ema_signal;
        
        // 3. 计算 MACD 柱状图 (DIF - DEA) * 2 (通常乘2)
        res.macd[i] = (res.dif[i] - res.dea[i]) * 2.0;
    }

    return res;
}

int main() {
    std::vector<double> my_prices = {100.5, 101.2, 102.3, 101.8, 103.5, ...}; // 你的价格数据
    
    MACDResult result = calculateMACD(my_prices, 10, 30, 8);

    if (!result.dif.empty()) {
        std::cout << "最新 DIF: " << result.dif.back() << std::endl;
        std::cout << "最新 DEA: " << result.dea.back() << std::endl;
        std::cout << "最新 柱状图: " << result.macd.back() << std::endl;
    }
    
    return 0;
}

#include <iostream>

struct MACDPoint {
    double dif;
    double dea;
    double macd;
};

class MACDCalculator {
private:
    // 状态变量
    double last_ema_short;
    double last_ema_long;
    double last_dea;
    
    // 权重因子
    double k_short;
    double k_long;
    double k_signal;

    bool is_initialized;

public:
    /**
     * 初始化计算器
     * @param short_p 快线周期 (默认10)
     * @param long_p 慢线周期 (默认30)
     * @param signal_p 信号线周期 (默认8)
     */
    MACDCalculator(int short_p = 10, int long_p = 30, int signal_p = 8) 
        : last_ema_short(0), last_ema_long(0), last_dea(0), is_initialized(false) {
        
        k_short = 2.0 / (short_p + 1);
        k_long = 2.0 / (long_p + 1);
        k_signal = 2.0 / (signal_p + 1);
    }

    /**
     * 输入一个新价格，返回当前的 MACD 各值
     */
    MACDPoint update(double price) {
        if (!is_initialized) {
            // 第一个点初始化：EMA等于当前价格，DIF和DEA设为0
            last_ema_short = price;
            last_ema_long = price;
            last_dea = 0; // 初始 DIF 为 0，故 DEA 也为 0
            is_initialized = true;
            return {0.0, 0.0, 0.0};
        }

        // 1. 更新快慢线 EMA
        last_ema_short = price * k_short + last_ema_short * (1.0 - k_short);
        last_ema_long = price * k_long + last_ema_long * (1.0 - k_long);

        // 2. 计算 DIF
        double current_dif = last_ema_short - last_ema_long;

        // 3. 更新信号线 DEA (DIF 的 EMA)
        last_dea = current_dif * k_signal + last_dea * (1.0 - k_signal);

        // 4. 计算柱状图
        double current_macd = (current_dif - last_dea) * 2.0;

        return {current_dif, last_dea, current_macd};
    }

    // 重置计算器（用于切换交易对时）
    void reset() {
        is_initialized = false;
    }
};

int main() {
    MACDCalculator macd10_30_8(10, 30, 8);
    
    // 模拟实时收到的 K 线价格
    std::vector<double> live_ticks = {100.0, 101.0, 102.5, 101.8, 103.2};

    for (double p : live_ticks) {
        MACDPoint pt = macd10_30_8.update(p);
        
        std::cout << "价格: " << p 
                  << " | DIF: " << pt.dif 
                  << " | DEA: " << pt.dea 
                  << " | MACD柱: " << pt.macd << std::endl;
    }

    return 0;
}

#include <iostream>
#include <vector>

// 信号类型定义
enum class MACDSignal {
    NONE = 0,
    GOLDEN_CROSS = 1, // 金叉：DIF 上穿 DEA (看涨)
    DEATH_CROSS = -1  // 死叉：DIF 下穿 DEA (看跌)
};

struct MACDFullState {
    double dif;
    double dea;
    double macd;
    double strength;    // 趋势强度 (柱状图的绝对值)
    MACDSignal signal;  // 交叉信号
};

class MACDAdvancedCalculator {
private:
    double last_ema_short = 0;
    double last_ema_long = 0;
    double last_dif = 0;
    double last_dea = 0;
    
    double k_short, k_long, k_signal;
    bool is_initialized = false;
    int count = 0; // 记录喂入的数据量

public:
    MACDAdvancedCalculator(int short_p = 10, int long_p = 30, int signal_p = 8) {
        k_short = 2.0 / (short_p + 1);
        k_long = 2.0 / (long_p + 1);
        k_signal = 2.0 / (signal_p + 1);
    }

    MACDFullState update(double price) {
        if (!is_initialized) {
            last_ema_short = last_ema_long = price;
            is_initialized = true;
            count++;
            return {0, 0, 0, 0, MACDSignal::NONE};
        }

        // 1. 计算当前各量
        last_ema_short = price * k_short + last_ema_short * (1.0 - k_short);
        last_ema_long = price * k_long + last_ema_long * (1.0 - k_long);
        
        double current_dif = last_ema_short - last_ema_long;
        double current_dea = current_dif * k_signal + last_dea * (1.0 - k_signal);
        double current_macd = (current_dif - current_dea) * 2.0;

        // 2. 判定金叉/死叉逻辑
        MACDSignal signal = MACDSignal::NONE;
        // 确保至少有两个点的数据才能对比交叉
        if (count > 1) {
            if (last_dif <= last_dea && current_dif > current_dea) {
                signal = MACDSignal::GOLDEN_CROSS;
            } else if (last_dif >= last_dea && current_dif < current_dea) {
                signal = MACDSignal::DEATH_CROSS;
            }
        }

        // 3. 计算趋势强度
        // 强度通常定义为柱状图的变化斜率或绝对值，这里采用绝对值
        double strength = std::abs(current_macd);

        // 4. 更新历史状态
        last_dif = current_dif;
        last_dea = current_dea;
        count++;

        return {current_dif, current_dea, current_macd, strength, signal};
    }
};

int main() {
    MACDAdvancedCalculator engine(10, 30, 8);
    std::vector<double> prices = {100, 102, 104, 103, 101, 99, 98, 100, 103};

    for (double p : prices) {
        MACDFullState state = engine.update(p);
        
        std::cout << "价格: " << p << " | MACD: " << state.macd;
        
        if (state.signal == MACDSignal::GOLDEN_CROSS) 
            std::cout << " [信号: ★金叉买入]";
        else if (state.signal == MACDSignal::DEATH_CROSS)
            std::cout << " [信号: ⚡死叉卖出]";
            
        std::cout << " | 强度: " << state.strength << std::endl;
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>

enum class DivergenceType { NONE = 0, BULLISH = 1, BEARISH = -1 };

class MACDCompleteCalculator {
private:
    // MACD 基础状态
    double last_ema_short = 0, last_ema_long = 0, last_dea = 0, last_dif = 0;
    double k_short, k_long, k_signal;
    bool is_initialized = false;

    // 背离检测状态
    double last_peak_price = 0;   // 上一个 MACD 波峰时的价格
    double last_peak_macd = 0;    // 上一个 MACD 波峰的高度
    double last_trough_price = 0; // 上一个 MACD 波谷时的价格
    double last_trough_macd = 0;  // 上一个 MACD 波谷的深度
    
    double prev_macd = 0;         // 上一个周期的 MACD 柱值
    double prev_price = 0;

public:
    MACDCompleteCalculator(int s = 10, int l = 30, int sig = 8) {
        k_short = 2.0 / (s + 1);
        k_long = 2.0 / (l + 1);
        k_signal = 2.0 / (sig + 1);
    }

    DivergenceType checkDivergence(double curr_price, double curr_macd) {
        DivergenceType div = DivergenceType::NONE;

        // 判定波峰 (MACD 柱由升转降)
        if (prev_macd > 0 && curr_macd < prev_macd && prev_macd > last_peak_macd) {
            // 顶背离：当前价格高于上次波峰价格，但 MACD 峰值低于上次
            if (last_peak_price > 0 && prev_price > last_peak_price && prev_macd < last_peak_macd) {
                div = DivergenceType::BEARISH;
            }
            last_peak_price = prev_price;
            last_peak_macd = prev_macd;
        }
        
        // 判定波谷 (MACD 柱由降转升)
        if (prev_macd < 0 && curr_macd > prev_macd && prev_macd < last_trough_macd) {
            // 底背离：当前价格低于上次波谷价格，但 MACD 谷值高于上次
            if (last_trough_price > 0 && prev_price < last_trough_price && prev_macd > last_trough_macd) {
                div = DivergenceType::BULLISH;
            }
            last_trough_price = prev_price;
            last_trough_macd = prev_macd;
        }

        prev_macd = curr_macd;
        prev_price = curr_price;
        return div;
    }

    void update(double price) {
        if (!is_initialized) {
            last_ema_short = last_ema_long = prev_price = price;
            is_initialized = true; return;
        }

        last_ema_short = price * k_short + last_ema_short * (1.0 - k_short);
        last_ema_long = price * k_long + last_ema_long * (1.0 - k_long);
        double dif = last_ema_short - last_ema_long;
        last_dea = dif * k_signal + last_dea * (1.0 - k_signal);
        double macd = (dif - last_dea) * 2.0;

        // 执行背离检测
        DivergenceType div = checkDivergence(price, macd);
        
        if (div == DivergenceType::BEARISH) std::cout << "⚠️ [警告] 发现顶背离：价格创新高但动能不足！\n";
        if (div == DivergenceType::BULLISH) std::cout << "🚀 [机会] 发现底背离：价格创新低但杀跌减弱！\n";

        last_dif = dif;
    }
};

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

class TradingEngine {
private:
    // MACD 状态
    double last_ema_s = 0, last_ema_l = 0, last_dea = 0;
    double k_s, k_l, k_sig;

    // RSI 状态 (Wilder's Smoothing)
    double avg_gain = 0, avg_loss = 0;
    double last_price = 0;
    int rsi_period = 14;
    int count = 0;

    // 背离记录
    double last_peak_p = 0, last_peak_m = 0;
    double prev_macd = 0;

public:
    TradingEngine(int s=10, int l=30, int sig=8) {
        k_s = 2.0/(s+1); k_l = 2.0/(l+1); k_sig = 2.0/(sig+1);
    }

    void update(double price) {
        count++;
        if (count == 1) {
            last_ema_s = last_ema_l = last_price = price;
            return;
        }

        // 1. 计算 MACD
        last_ema_s = price * k_s + last_ema_s * (1.0 - k_s);
        last_ema_l = price * k_l + last_ema_l * (1.0 - k_l);
        double dif = last_ema_s - last_ema_l;
        last_dea = dif * k_sig + last_dea * (1.0 - k_sig);
        double macd = (dif - last_dea) * 2.0;

        // 2. 计算 RSI
        double change = price - last_price;
        double gain = std::max(0.0, change);
        double loss = std::max(0.0, -change);
        
        if (count <= rsi_period + 1) {
            avg_gain += gain / rsi_period;
            avg_loss += loss / rsi_period;
        } else {
            avg_gain = (avg_gain * (rsi_period - 1) + gain) / rsi_period;
            avg_loss = (avg_loss * (rsi_period - 1) + loss) / rsi_period;
        }
        
        double rs = (avg_loss == 0) ? 100 : avg_gain / avg_loss;
        double rsi = 100.0 - (100.0 / (1.0 + rs));

        // 3. 策略融合判断
        checkStrategy(price, macd, rsi);

        last_price = price;
        prev_macd = macd;
    }

    void checkStrategy(double p, double m, double rsi) {
        // 以顶背离为例：
        if (prev_macd > 0 && m < prev_macd) { // 发现 MACD 波峰
            if (p > last_peak_p && prev_macd < last_peak_m) {
                // 背离发生，检查 RSI 过滤器
                if (rsi > 70) {
                    std::cout << "🚨 [高胜率卖出信号] 顶背离 + RSI 超买 (" << rsi << ")\n";
                } else {
                    std::cout << "⚠️ [弱背离] 发现背离但 RSI 尚未过热，建议观察。\n";
                }
            }
            last_peak_p = p; last_peak_m = prev_macd;
        }
    }
};

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>

// 引用之前定义的 TradingEngine 类
// 为了简洁，这里假设 TradingEngine 已经包含了 MACD 和 RSI 的逻辑

class MultiContractManager {
private:
    // 合约 ID 到计算引擎的映射
    std::unordered_map<std::string, std::unique_ptr<TradingEngine>> engines;
    
    // 任务队列：包含合约 ID 和最新的价格
    struct TickData {
        std::string symbol;
        double price;
    };
    std::queue<TickData> task_queue;
    
    std::mutex queue_mutex;
    std::condition_variable cv;
    bool stop = false;
    std::vector<std::thread> workers;

public:
    MultiContractManager(size_t thread_count = 4) {
        // 初始化工作线程
        for (size_t i = 0; i < thread_count; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    TickData task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->cv.wait(lock, [this] { 
                            return this->stop || !this->task_queue.empty(); 
                        });
                        
                        if (this->stop && this->task_queue.empty()) return;
                        
                        task = std::move(this->task_queue.front());
                        this->task_queue.pop();
                    }
                    
                    // 执行计算：定位合约引擎并更新
                    this->process_tick(task.symbol, task.price);
                }
            });
        }
    }

    // 注册新合约
    void register_contract(const std::string& symbol) {
        engines[symbol] = std::make_unique<TradingEngine>(10, 30, 8);
        std::cout << "已成功监控合约: " << symbol << std::endl;
    }

    // 接收实时行情推送到队列
    void on_tick(const std::string& symbol, double price) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push({symbol, price});
        }
        cv.notify_one();
    }

    ~MultiContractManager() {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            stop = true;
        }
        cv.notify_all();
        for (auto& worker : workers) worker.join();
    }

private:
    void process_tick(const std::string& symbol, double price) {
        if (engines.find(symbol) != engines.end()) {
            // 这里调用之前实现的 TradingEngine::update 方法
            engines[symbol]->update(price);
        }
    }
};

int main() {
    // 启动框架，开启 8 个计算线程
    MultiContractManager manager(8);

    // 模拟注册 100 个合约 (BTCUSDT, ETHUSDT, ...)
    for (int i = 0; i < 100; ++i) {
        manager.register_contract("CONTRACT_" + std::to_string(i));
    }

    // 模拟高频行情输入
    std::cout << "开始实时监控..." << std::endl;
    for (int tick = 0; tick < 1000; ++tick) {
        std::string symbol = "CONTRACT_" + std::to_string(tick % 100);
        double mock_price = 100.0 + (rand() % 100) / 10.0;
        
        manager.on_tick(symbol, mock_price);
        
        // 模拟真实行情频率
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

#include <iomanip>
#include <chrono>

// 订单方向
enum class Side { BUY, SELL };

// 订单详情
struct OrderRequest {
    std::string symbol;
    Side side;
    double price;
    double quantity;
    std::string strategy_name;
};

// 模拟执行引擎
class ExecutionEngine {
private:
    std::mutex cout_mutex; // 仅用于保证控制台输出不乱序

public:
    // 核心下单接口
    void send_order(const OrderRequest& order) {
        // 在真实环境中，这里会调用交易所的 REST API 或 FIX/WebSocket 接口
        // 或者是发往中间件（如 CCXT, QuickFIX）
        
        std::lock_guard<std::mutex> lock(cout_mutex);
        auto now = std::chrono::system_clock::now();
        auto in_time_t = std::chrono::system_clock::to_time_t(now);

        std::cout << "\n" << std::put_time(std::localtime(&in_time_t), "%X") 
                  << " [EXECUTION] >>> 发送订单: " 
                  << (order.side == Side::BUY ? "买入 " : "卖出 ")
                  << order.symbol << " | 价格: " << order.price 
                  << " | 数量: " << order.quantity 
                  << " | 策略: " << order.strategy_name << std::endl;
    }
};

class MultiContractManager {
private:
    // ... 原有的 engines, task_queue 等 ...
    std::shared_ptr<ExecutionEngine> exec_ptr;
    
    // 简单的持仓管理（模拟）
    std::unordered_map<std::string, double> positions; 
    std::mutex pos_mutex;

public:
    MultiContractManager(std::shared_ptr<ExecutionEngine> ee, size_t thread_count = 4) 
        : exec_ptr(ee) {
        // ... 原有的 worker 初始化 ...
    }

    void process_tick(const std::string& symbol, double price) {
        if (engines.find(symbol) == engines.end()) return;

        // 1. 更新指标并获取状态
        // 假设我们修改了 TradingEngine::update 使其返回 FullState
        auto state = engines[symbol]->update(price);

        // 2. 根据信号下单
        if (state.signal != MACDSignal::NONE) {
            OrderRequest req;
            req.symbol = symbol;
            req.price = price;
            req.quantity = 1.0; // 简化处理，实战中需根据资金管理计算
            req.strategy_name = "MACD_RSI_Divergence";

            if (state.signal == MACDSignal::GOLDEN_CROSS) {
                req.side = Side::BUY;
                exec_ptr->send_order(req);
            } 
            else if (state.signal == MACDSignal::DEATH_CROSS) {
                // 简单的风控：检查是否有仓位可平
                if (positions[symbol] > 0) {
                    req.side = Side::SELL;
                    exec_ptr->send_order(req);
                }
            }
        }
    }
};

#include <sqlite3.h>
#include <string>

class TradeLogger {
private:
    sqlite3* db;
    std::mutex db_mutex;

public:
    TradeLogger(const std::string& db_name = "trades_log.db") {
        if (sqlite3_open(db_name.c_str(), &db) == SQLITE_OK) {
            const char* sql = "CREATE TABLE IF NOT EXISTS trades ("
                              "id INTEGER PRIMARY KEY AUTOINCREMENT,"
                              "timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,"
                              "symbol TEXT, side TEXT, price REAL, qty REAL, strategy TEXT);";
            sqlite3_exec(db, sql, 0, 0, 0);
        }
    }

    void log_trade(const OrderRequest& order) {
        std::lock_guard<std::mutex> lock(db_mutex);
        std::string sql = "INSERT INTO trades (symbol, side, price, qty, strategy) VALUES ('" +
                          order.symbol + "', '" + 
                          (order.side == Side::BUY ? "BUY" : "SELL") + "', " +
                          std::to_string(order.price) + ", " + 
                          std::to_string(order.quantity) + ", '" + 
                          order.strategy_name + "');";
        sqlite3_exec(db, sql.c_str(), 0, 0, 0);
    }

    ~TradeLogger() { sqlite3_close(db); }
};

#include <atomic>
#include <chrono>

class ConnectivityManager {
private:
    std::atomic<long long> last_heartbeat_time;
    std::atomic<bool> is_connected{false};
    const int TIMEOUT_MS = 5000; // 5秒无响应视为断线

public:
    // 由网络接收线程调用
    void feed_heartbeat() {
        last_heartbeat_time = std::chrono::steady_clock::now().time_since_epoch().count();
        is_connected = true;
    }

    // 监控线程：检查是否断线
    void start_watchdog() {
        std::thread([this]() {
            while (true) {
                auto now = std::chrono::steady_clock::now().time_since_epoch().count();
                if (is_connected && (now - last_heartbeat_time > TIMEOUT_MS * 1000000LL)) {
                    is_connected = false;
                    handle_reconnect();
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
        }).detach();
    }

    void handle_reconnect() {
        std::cout << "⚠️ [网络中断] 正在尝试重新连接交易所 API..." << std::endl;
        // 这里放入具体的 WebSocket 拨号或 API 初始化逻辑
        // 成功后调用 is_connected = true;
    }

    bool status() const { return is_connected; }
};

class ExecutionEngine {
private:
    TradeLogger logger;
    ConnectivityManager conn;

public:
    ExecutionEngine() { conn.start_watchdog(); }

    void send_order(const OrderRequest& order) {
        // 1. 状态检查：如果网络断开，拒绝下单
        if (!conn.status()) {
            std::cerr << "❌ [拒绝下单] 网络连接异常！" << std::endl;
            return;
        }

        // 2. 模拟发送订单到交易所
        bool success = true; // 假设网络请求成功

        if (success) {
            // 3. 持久化记录：即使程序崩溃，数据库里也有据可查
            logger.log_trade(order);
            std::cout << "✅ [订单确认] " << order.symbol << " 记录已存入数据库。" << std::endl;
        }
    }

    // 提供给网络层调用
    void on_network_msg_received() { conn.feed_heartbeat(); }
};

#include <fstream>
#include <sstream>
#include <vector>

struct BacktestResult {
    double total_profit = 0;
    int trade_count = 0;
    int win_count = 0;
};

class Backtester {
private:
    std::shared_ptr<TradingEngine> engine;
    double balance = 100000.0; // 初始资金
    double position = 0;       // 当前持仓数量
    double last_entry_price = 0;

public:
    Backtester() {
        engine = std::make_shared<TradingEngine>(10, 30, 8);
    }

    // 从CSV文件读取数据进行回测：格式为 Date,Open,High,Low,Close,Volume
    void run(const std::string& csv_path) {
        std::ifstream file(csv_path);
        std::string line;
        
        // 跳过表头
        std::getline(file, line);

        while (std::getline(file, line)) {
            std::stringstream ss(line);
            std::string date, temp;
            double open, high, low, close;

            std::getline(ss, date, ',');
            std::getline(ss, temp, ','); open = std::stod(temp);
            std::getline(ss, temp, ','); high = std::stod(temp);
            std::getline(ss, temp, ','); low = std::stod(temp);
            std::getline(ss, temp, ','); close = std::stod(temp);

            // 核心：模拟流式行情喂入
            auto state = engine->update(close);

            // 模拟逻辑：发现金叉买入，死叉卖出
            if (state.signal == MACDSignal::GOLDEN_CROSS && position == 0) {
                position = balance / close; // 全仓买入
                last_entry_price = close;
                std::cout << "BUY  at " << close << " on " << date << std::endl;
            } 
            else if (state.signal == MACDSignal::DEATH_CROSS && position > 0) {
                balance = position * close;
                double pnl = (close - last_entry_price) / last_entry_price * 100;
                std::cout << "SELL at " << close << " PnL: " << pnl << "%" << std::endl;
                position = 0;
            }
        }
        std::cout << "Final Balance: " << balance << std::endl;
    }
};

#include "ThostFtdcMdApi.h"

// 继承 SPI 类
class MyMdHandler : public CThostFtdcMdSpi {
private:
    CThostFtdcMdApi* api;
    std::shared_ptr<MultiContractManager> manager;

public:
    MyMdHandler(CThostFtdcMdApi* a, std::shared_ptr<MultiContractManager> m) 
        : api(a), manager(m) {}

    // 关键回调：行情推送
    virtual void OnRtnDepthMarketData(CThostFtdcDepthMarketDataField *pData) {
        if (pData) {
            // 将 CTP 的行情数据喂给我们的计算框架
            manager->on_tick(pData->InstrumentID, pData->LastPrice);
        }
    }
};