4、C++核心语法速通（下）：模板编程、STL容器、lambda表达式、多线程基础

好，咱们接着聊。上一节我们把C++的面向对象和内存管理捋了一遍，这一节要啃的，才是真正让C++在量化交易里脱颖而出的硬核东西。模板、STL容器、lambda、多线程——这四个东西，说白了就是高频交易系统的四根柱子。我当年刚入行时，觉得能写个类就挺牛了，直到第一次看到生产环境的代码，才发现自己连门都没摸到。

4.1 模板编程：不只是泛型

模板这东西，很多人觉得就是「写一个函数，支持多种类型」。嗯，对了一半。在高频交易里，模板的真正价值在于编译期计算和零成本抽象。你想想看，运行时多态（虚函数）有虚表开销，而模板在编译期就帮你把类型定死了，运行时没有任何额外负担。

我个人习惯把模板分为三类：函数模板、类模板、以及模板特化。咱们一个个说。

4.1.1 函数模板

最简单的例子，计算两个数的最大值：

template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 使用
int x = max(3, 5);        // T 推导为 int
double y = max(3.14, 2.71); // T 推导为 double

我在项目中遇到过一个问题：当传入的参数类型不一致时，模板推导会失败。比如 max(3, 3.14)，编译器会报错。解决办法是显式指定类型：max<double>(3, 3.14)。或者用C++20的auto参数，但咱们做高频交易，编译器版本往往比较保守，还是老老实实用typename吧。

4.1.2 类模板

类模板在量化系统里最常见的应用就是环形缓冲区（Ring Buffer）。行情数据进来，必须用无锁的环形缓冲区来缓存，否则延迟受不了。

template<typename T, size_t Capacity>
class RingBuffer {
    T data_[Capacity];
    std::atomic<size_t> head_{0};
    std::atomic<size_t> tail_{0};
public:
    bool push(const T& item) {
        size_t next = (head_.load() + 1) % Capacity;
        if (next == tail_.load()) return false; // 满了
        data_[head_] = item;
        head_.store(next);
        return true;
    }
    bool pop(T& item) {
        if (tail_.load() == head_.load()) return false; // 空
        item = data_[tail_];
        tail_.store((tail_.load() + 1) % Capacity);
        return true;
    }
};

注意看，Capacity是编译期常量，所以整个缓冲区的大小在编译时就确定了，没有动态内存分配。这对于高频交易来说至关重要——你绝对不希望行情爆发时，系统因为malloc而卡顿。

4.1.3 模板特化

有时候，通用模板不能满足特定类型的需求。比如，你想对 const char* 做特殊处理：

template<>
const char* max<const char*>(const char* a, const char* b) {
    return (strcmp(a, b) > 0) ? a : b;
}

我曾经踩过一个坑：特化版本和重载版本搞混了，导致链接错误。记住，特化是模板的「特殊情况」，重载是函数的「不同版本」，两者不是一回事。

4.2 STL容器：选对容器，事半功倍

STL容器是C++的宝藏，但用不好就是灾难。在高频交易场景下，容器的选择直接影响系统延迟。我见过有人用 std::list 存订单簿，结果每次遍历都卡成狗——因为list的节点在内存里是离散的，缓存命中率极低。

4.2.1 vector：连续内存的王者

std::vector 是我用得最多的容器。它的数据在内存中是连续存储的，遍历时CPU缓存友好。适合存储行情快照、历史数据等。

std::vector<double> prices;
prices.reserve(1000000); // 预分配，避免多次扩容
for (int i = 0; i < 1000000; ++i) {
    prices.push_back(/* 行情数据 */);
}

注意 reserve 这个函数。如果不预分配，vector会在容量不足时自动扩容——每次扩容都要重新分配内存、拷贝数据、释放旧内存。在高频场景下，这种操作绝对不能出现在关键路径上。

4.2.2 map vs unordered_map：有序 vs 无序

这两个容器经常被拿来比较。简单说：

容器	底层结构	查找复杂度	适用场景
std::map	红黑树	O(log n)	需要有序遍历（如按价格排序的订单簿）
std::unordered_map	哈希表	O(1) 平均	快速查找（如合约ID到信息的映射）

我个人习惯：能用unordered_map就用unordered_map。O(1)的查找速度在交易系统里太香了。但要注意，unordered_map的哈希冲突会导致性能退化，所以一定要提供好的哈希函数。

struct OrderKey {
    int exchange_id;
    int instrument_id;
    bool operator==(const OrderKey& other) const {
        return exchange_id == other.exchange_id && instrument_id == other.instrument_id;
    }
};

// 自定义哈希
struct OrderKeyHash {
    std::size_t operator()(const OrderKey& key) const {
        return std::hash<int>()(key.exchange_id) ^ (std::hash<int>()(key.instrument_id) << 1);
    }
};

std::unordered_map<OrderKey, OrderInfo, OrderKeyHash> order_map;

4.2.3 其他容器速览

• deque：双端队列，适合做滑动窗口。比如计算过去N笔成交的均价。
• priority_queue：优先队列，适合做事件调度。比如按时间排序的定时任务。
• array：固定大小数组，比原生数组更安全，适合存储固定数量的参数。

4.3 lambda表达式：写代码如行云流水

Lambda表达式是C++11引入的语法糖，说白了就是匿名函数对象。在高频交易里，lambda最常见的用途是作为回调函数和排序规则。

4.3.1 基本语法

[捕获列表](参数列表) -> 返回类型 {
    函数体
};

捕获列表是重点：

• []：不捕获任何外部变量
• [=]：按值捕获所有外部变量
• [&]：按引用捕获所有外部变量
• [this]：捕获当前类的this指针
• [x, &y]：混合捕获，x按值，y按引用

4.3.2 实战：排序订单簿

假设你有一个订单列表，需要按价格从高到低排序：

struct Order {
    double price;
    int quantity;
    int order_id;
};

std::vector<Order> orders;
// ... 填充数据 ...

// 按价格降序排列
std::sort(orders.begin(), orders.end(), 
    [](const Order& a, const Order& b) {
        return a.price > b.price;
    }
);

你看，一行lambda就搞定了。如果不用lambda，你得单独写一个比较函数或者仿函数，代码会分散到好几个地方。

4.3.3 捕获的陷阱

我曾经犯过一个错误：在lambda里按引用捕获了一个局部变量，但lambda被异步执行时，那个局部变量已经销毁了。结果就是野指针访问，程序崩溃。

4.4 多线程基础：std::thread

高频交易系统，说白了就是「多线程+无锁编程」的艺术。std::thread是C++11提供的跨平台线程库，虽然底层还是pthread或Windows Thread，但接口统一了很多。

4.4.1 创建线程

#include <thread>

void market_data_handler() {
    // 处理行情数据
    while (true) {
        // 接收行情、更新订单簿
    }
}

int main() {
    std::thread t1(market_data_handler);
    std::thread t2([]() {
        // 用lambda创建线程
        // 执行策略计算
    });

    // 等待线程结束
    t1.join();
    t2.join();
    return 0;
}

注意 join() 和 detach() 的区别：

• join()：主线程等待子线程结束，然后继续执行。
• detach()：子线程与主线程分离，独立运行。主线程结束不会影响子线程。

我个人建议：能用join就别用detach。detach的线程一旦失控，调试起来非常痛苦。你根本不知道它什么时候结束，甚至不知道它有没有结束。

4.4.2 线程安全与互斥锁

多线程最头疼的问题就是数据竞争。std::mutex是最基本的同步工具：

#include <mutex>

std::mutex mtx;
std::map<int, double> order_book;

void update_order_book(int id, double price) {
    std::lock_guard<std::mutex> lock(mtx); // RAII，自动加锁解锁
    order_book[id] = price;
    // lock 离开作用域时自动解锁
}

用 std::lock_guard 而不是手动 lock()/unlock()，可以避免忘记解锁导致的死锁。这是C++的RAII思想——资源获取即初始化。

4.4.3 原子操作

在高频交易里，锁的开销太大了。很多时候，我们可以用 std::atomic 来替代锁：

#include <atomic>

std::atomic<int> order_count{0};

void on_new_order() {
    order_count.fetch_add(1, std::memory_order_relaxed);
    // 无锁的原子递增
}

原子操作比锁快一个数量级。但要注意内存序（memory order）的选择：

• memory_order_relaxed：最宽松，只保证原子性，不保证顺序。
• memory_order_acquire/release：保证读写顺序，适合生产者-消费者模式。
• memory_order_seq_cst：最严格，全局顺序一致，但性能最差。

4.4.4 线程池的必要性

在高频交易系统里，频繁创建和销毁线程是不可接受的。正确的做法是使用线程池：

class ThreadPool {
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
public:
    ThreadPool(size_t threads) : stop(false) {
        for(size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while(true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock, [this] {
                            return this->stop || !this->tasks.empty();
                        });
                        if(this->stop && this->tasks.empty()) return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }
    // ... 提交任务、销毁等接口
};

线程池的核心思想：复用线程，避免创建销毁的开销。在交易系统里，通常创建CPU核心数-1个线程（留一个给主线程），然后所有任务都提交到线程池执行。

---