C++量化面试题解析：从基础到实战的避坑指南

1次阅读

共计 2615 个字符，预计需要花费 7 分钟才能阅读完成。

量化开发对 C ++ 的要求集中在三个方面：
– 极致性能 ：需处理高频交易中的微秒级延迟
– 内存安全 ：避免内存泄漏导致的系统崩溃
– 并发可靠 ：保证多线程环境下的数据一致性

以下通过四大核心模块解析面试高频考点：

“ 实现一个线程安全的对象池，要求支持延迟初始化 ”

// 危险示例：双重检查锁定漏洞
class ObjectPool {
    static ObjectPool* instance;
    static mutex mtx;

public:
    static ObjectPool* getInstance() {if(!instance) {  // 非原子读取
            lock_guard<mutex> lk(mtx);
            if(!instance) {instance = new ObjectPool();
            }
        }
        return instance;
    }
};

// 正确实现：C++11 后的内存模型保障
class ObjectPool {
    static shared_ptr<ObjectPool> instance;
    static once_flag initFlag;

    vector<unique_ptr<Resource>> pool;

public:
    static shared_ptr<ObjectPool> getInstance() {call_once(initFlag, []{instance = make_shared<ObjectPool>(); 
        });
        return instance;
    }

    Resource* acquire() {unique_lock<mutex> lk(mtx);
        if(pool.empty()) {return new Resource();
        }
        auto res = pool.back().release();
        pool.pop_back();
        return res;
    }
};

方案	吞吐量 (ops/ms)	内存泄漏风险
原始指针	1520	高
shared_ptr	980	无
对象池 +unique_ptr	1340	无

“ 实现无锁的环形缓冲区，支持多生产者单消费者 ”

// 错误示例：存在 ABA 问题
class RingBuffer {
    atomic<size_t> head, tail;

public:
    bool push(int val) {size_t old_tail = tail.load();
        if((old_tail + 1) % size == head.load()) {return false;}
        buffer[old_tail] = val;
        tail.store((old_tail + 1) % size);
        return true;
    }
};

// 正确实现：使用内存序控制
class RingBuffer {atomic<size_t> head{0}, tail{0};
    array<int, 1024> buffer;

public:
    bool push(int val) {size_t curr_tail = tail.load(memory_order_acquire);
        size_t next_tail = (curr_tail + 1) % buffer.size();

        if(next_tail == head.load(memory_order_relaxed)) {return false;}

        buffer[curr_tail] = val;
        tail.store(next_tail, memory_order_release);
        return true;
    }
};

同步方式	吞吐量 (万次 / 秒)	延迟 (ns)
mutex	12.5	210
atomic	86.7	45
无锁环形队列	124.3	22

“ 比较两个浮点数是否相等的安全方法 ”

// 危险示例：直接比较
bool isEqual(double a, double b) {return a == b;  // IEEE754 精度问题}

// 正确实现：相对误差比较
bool isNearlyEqual(double a, double b, double epsilon = 1e-8) {double absDiff = fabs(a - b);
    double maxVal = max(fabs(a), fabs(b));

    // 处理极小值情况
    if(absDiff < numeric_limits<double>::min()) {return true;}

    // 相对误差比较
    return (absDiff / maxVal) < epsilon;
}

比较方法	1.0-0.9	1e20-1e20+1	1e-20-1e-21
直接比较	错误	错误	正确
绝对误差	正确	错误	错误
相对误差	正确	正确	正确

“ 实时行情数据应当选择哪种 STL 容器？”

容器	插入效率	查询效率	内存连续性
vector	O(1) 摊还	O(1)	是
deque	O(1)	O(1)	部分
list	O(1)	O(n)	否
unordered_map	O(1)	O(1)	否

// 行情数据存储方案
class MarketData {
    deque<tuple<timestamp, price, volume>> ticks;
    unordered_map<symbol, vector<price>> history;

public:
    void onTick(const Tick& tick) {
        // 最新行情用 deque 保存
        ticks.emplace_back(tick.time, tick.price, tick.vol);

        // 历史数据用 vector 存储
        history[tick.symbol].push_back(tick.price);

        // 超过 1000 条时触发压缩
        if(ticks.size() > 1000) {compressTicks();
        }
    }
};