C++算法

C++ 核心面试题与底层原理详解

综述由AI生成C++ 面试涵盖基础语法、内存管理、STL、并发及设计模式等核心领域。本文梳理了值传递、虚函数表、智能指针、RAII 原则及异常安全等关键知识点，并提供了 LRU 缓存、快速排序等经典算法模板。重点解析了 C++11 新特性、多线程同步机制及性能优化实践，帮助开发者系统掌握底层原理与工程落地细节。

岁月神偷发布于 2026/2/18更新于 2026/6/721 浏览

基础知识

C++ 基础语法

C++ 和 C 的区别？
- C++ 支持面向对象（封装、继承、多态）。
- 引入了模板、STL 标准库以及异常处理机制。
值传递、指针传递、引用传递的区别？
- 值传递：拷贝一份副本，开销较大。
- 指针传递：传递地址，可修改原数据。
- 引用传递：别名，语法更简洁且安全。
const 的用法？
- 修饰变量：声明常量。
- 修饰指针：const int* p（指向常量），int* const p（常指针）。
- 修饰成员函数：void f() const; 表示函数内不能修改成员变量。
static 的作用？
- 局部静态变量：函数调用间保持值。
- 修饰全局变量/函数：只在文件内可见（内部链接）。
- 修饰类成员：属于类而非对象，所有实例共享。
inline 内联函数的原理？
- 编译器用函数体替换调用点，减少函数调用开销。
- 适用于小函数，频繁调用的场景。

面向对象

C++ 四大特性？
- 封装、继承、多态、抽象。
多态的实现方式？
- 静态多态：函数重载、模板特化。
- 动态多态：虚函数（通过虚函数表实现）。
虚函数、纯虚函数、抽象类区别？
- 虚函数：子类可选择重写。
- 纯虚函数：=0，子类必须实现。
- 抽象类：含有纯虚函数，不能直接实例化。
虚函数表 (vtable) 的工作原理？
- 类中有虚函数时，编译器生成 vtable，存储函数指针。
- 对象包含 vptr，指向 vtable，实现动态绑定。
构造函数和析构函数的调用顺序？
- 构造：先基类，再成员对象，最后派生类。
- 析构：先派生类，再成员对象，最后基类。

内存管理

C++ 内存分区？
- 栈：局部变量、函数参数。
- 堆：new/delete 分配的内存。
- 全局/静态区：全局变量、静态变量。
- 常量区：字符串常量。
- 代码区：存放可执行代码。
new/delete 与 malloc/free 的区别？
- new 调用构造函数，返回指定类型指针。
- malloc 只分配内存，不调用构造函数。
- delete 调用析构函数，释放内存。
- free 只释放内存。
内存泄漏如何检测？
- 工具：Valgrind、ASan。

class Singleton {
private:
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance; // C++11 保证线程安全
        return instance;
    }
};

void quickSort(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) swap(a[i], a[j]);
    }
    swap(a[l], a[i]);
    quickSort(a, l, i - 1);
    quickSort(a, i + 1, r);
}

int binarySearch(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;
}

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_);
    }
    Buffer& operator=(Buffer o) { // copy-and-swap 提供强异常安全
        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_);
    }
};

template<typename T>
void push_back_emplace(std::vector<T>& v, T&& val) {
    v.emplace_back(std::forward<T>(val)); // 保持传入值类别
}

int a = INT_MAX;
int b = a + 1; // 有符号溢出 —— UB（不要假设会 wrap-around）

MySingleton& instance() {
    static MySingleton inst; // C++11 保证线程安全的局部静态初始化
    return inst;
}

std::mutex mu;
std::condition_variable cv;
std::queue<int> q;

void producer() {
    {
        std::lock_guard lk(mu);
        q.push(42);
    }
    cv.notify_one();
}

void consumer() {
    std::unique_lock lk(mu);
    cv.wait(lk, []{ return !q.empty(); });
    int v = q.front();
    q.pop();
}

class LRUCache {
    int cap;
    list<int> keys;
    unordered_map<int, pair<int, 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()};
    }
};

class S {
public:
    static S& instance() {
        static std::once_flag f;
        static S* p = nullptr;
        std::call_once(f, []{ p = new S(); });
        return *p;
    }
private:
    S() = default;
};