C++ 面试高频考点与核心技术解析

示例：Buffer 类的正确实现

class Buffer {
    size_t n_;
    int* data_;
public:
    Buffer(size_t n = 0) : n_(n), data_(n ? new int[n]() : nullptr) {}
    ~Buffer() { delete[] data_; }

    // Copy
    Buffer(const Buffer& o) : n_(o.n_), data_(o.n_ ? new int[o.n_] : nullptr) {
        std::copy(o.data_, o.data_ + n_, data_);
    }
    
    // Copy-and-Swap Assignment
    Buffer& operator=(Buffer o) {
        swap(*this, o);
        return *this;
    }

    // Move
    Buffer(Buffer&& o) noexcept : n_(o.n_), data_(o.data_) {
        o.n_ = 0; o.data_ = nullptr;
    }
    
    Buffer& operator=(Buffer&& o) noexcept {
        if (this != &o) {
            delete[] data_;
            n_ = o.n_; data_ = o.data_;
            o.n_ = 0; o.data_ = nullptr;
        }
        return *this;
    }

    friend void swap(Buffer& a, Buffer& b) noexcept {
        using std::swap;
        swap(a.n_, b.n_);
        swap(a.data_, b.data_);
    }
};

四、C++11 及新特性

1. 关键特性？ auto 类型推导、nullptr、lambda 表达式、智能指针、右值引用、move 语义。

2. 右值引用与 move 语义？ T&& 接收临时对象。std::move 将左值强制转为右值，触发移动构造，避免深拷贝提升性能。

3. 智能指针区别？

• unique_ptr：独占所有权，轻量级。
• shared_ptr：引用计数共享所有权。
• weak_ptr：弱引用，解决循环引用问题。

五、STL 深入

1. vector vs list？ vector 连续存储，随机访问快，插入删除慢；list 链表存储，插入删除快，随机访问慢。

2. map vs unordered_map？ map 基于红黑树，有序 O(log n)；unordered_map 基于哈希表，无序平均 O(1)。

3. 迭代器失效规则？ vector 扩容或中间插入/删除会导致迭代器失效；list 插入删除不影响其他迭代器。

4. push_back vs emplace_back？ emplace_back 直接在容器末尾构造对象，减少临时对象拷贝开销。

六、多线程与并发

1. 线程创建？ std::thread、std::async、std::packaged_task。

2. 锁机制？ 互斥锁阻塞等待适合长任务；自旋锁忙等待适合短任务。推荐使用 std::lock_guard 或 std::scoped_lock 进行 RAII 锁管理。

3. 条件变量？ 配合 unique_lock 使用，用于线程同步，如生产者 - 消费者模型。

4. 线程安全单例？ 利用 C++11 局部静态变量初始化保证线程安全。

MySingleton& instance() {
    static MySingleton inst;
    return inst;
}

七、算法与数据结构

1. LRU 缓存实现？ 结合哈希表与双向链表，实现 O(1) 的 get/put 操作。

class LRUCache {
    int cap;
    std::list<int> keys;
    std::unordered_map<int, std::pair<int, std::list<int>::iterator>> mp;
public:
    LRUCache(int capacity) : cap(capacity) {}
    
    int get(int k) {
        auto it = mp.find(k);
        if (it == mp.end()) return -1;
        keys.splice(keys.begin(), keys, it->second.second);
        return it->second.first;
    }
    
    void put(int k, int v) {
        auto it = mp.find(k);
        if (it != mp.end()) {
            it->second.first = v;
            keys.splice(keys.begin(), keys, it->second.second);
            return;
        }
        if ((int)mp.size() == cap) {
            int old = keys.back();
            keys.pop_back();
            mp.erase(old);
        }
        keys.push_front(k);
        mp[k] = {v, keys.begin()};
    }
};

2. 快速排序模板？

void quickSort(std::vector<int>& a, int l, int r) {
    if (l >= r) return;
    int i = l, j = r, pivot = a[l];
    while (i < j) {
        while (i < j && a[j] >= pivot) j--;
        while (i < j && a[i] <= pivot) i++;
        if (i < j) std::swap(a[i], a[j]);
    }
    std::swap(a[l], a[i]);
    quickSort(a, l, i - 1);
    quickSort(a, i + 1, r);
}

3. 二分查找模板？

int binarySearch(std::vector<int>& nums, int target) {
    int l = 0, r = nums.size() - 1;
    while (l <= r) {
        int mid = l + (r - l) / 2;
        if (nums[mid] == target) return mid;
        else if (nums[mid] < target) l = mid + 1;
        else r = mid - 1;
    }
    return -1;
}

八、调试与优化

1. 常用工具？ AddressSanitizer (ASan) 检测越界，ThreadSanitizer (TSan) 检测竞争，Valgrind 查泄漏，perf 分析性能。

2. 性能优化？ 关注 CPU 缓存友好性，减少内存分配，利用移动语义，避免不必要的拷贝。先 profiling 再优化。

九、综合问答要点

• 为什么析构函数要设为虚函数？ 确保通过基类指针删除派生类对象时能正确调用派生类析构。
• volatile 的作用？ 防止编译器优化，但不用于线程同步，应使用 atomic。
• 如何避免死锁？ 统一锁顺序，使用 scoped_lock，减少锁粒度。

十、面试建议

准备时不仅要写出能通过的代码，更要解释时间/空间复杂度、是否存在未定义行为 (UB)、异常安全级别及并发假设。常见 UB 包括有符号整数溢出、use-after-free 等，需格外注意。