C++面试

1.1 auto与类型推导：不止是简化语法

许多候选人误以为auto仅用于减少重复类型声明，实则其核心价值在于：

• 安全：避免隐式类型转换导致的截断（如long long赋值给int）；
• 泛型编程基础：模板推导依赖auto机制；
• 可维护性：当容器类型变更时（如vector→list），代码无需修改。

int main() {
    long long a = 1LL << 40;
    int b = a;  // 无警告！b值被截断为0（因40位超出int范围）
}

int main() {
    auto a = 1LL << 40;  // a类型为long long
    auto b = a;          // b自动推导为long long
    // 若强行转换：auto b = static_cast(a); // 显式转换，编译器可追踪
}

延伸考点：C++14允许auto用于函数返回值（需尾置返回类型或推导），C++17支持auto模板参数。

1.2 const与constexpr：编译期与运行期的边界

面试高频问题：const和constexpr有何本质区别？

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n-1); // C++11需单return；C++14支持多语句
}
int arr[factorial(5)]; // ✅ 编译通过：factorial(5)=120为常量表达式

陷阱：constexpr函数内部可含非constexpr操作（如循环），但调用时传入非常量参数则退化为运行期计算。

1.3 移动语义与完美转发：性能优化核心武器

为何需要移动构造？看经典案例：

std::vector v;
v.push_back(std::string("Hello")); // C++11前：复制；C++11后：移动

原理：

• 右值引用（&&）绑定临时对象；
• 移动构造窃取资源所有权（如指针），避免深拷贝；
• std::move是类型转换工具（将左值转为右值），不执行移动操作！

完美转发（std::forward）解决模板参数转发时的值类别丢失问题，是实现泛型接口的关键。

1.4 虚函数与多态：虚表指针与内存布局

经典问题：含虚函数的类对象大小如何计算？

class Base {
    virtual void foo() {}
    int x;
};
class Derived : public Base {
    int y;
};

答案：

• Base对象：1个虚表指针（8字节）+ int x（4字节）→ 共16字节（因对齐）；
• Derived对象：Base子对象（16字节）+ int y（4字节）→ 共24字节。

延伸：多重继承下虚表指针数量取决于基类虚函数数量，菱形继承需用virtual继承避免数据冗余。

2.1 new/delete vs malloc/free：语义差异

最佳实践：永远用new配对delete，new[]配对delete[]，否则未定义行为！

2.2 智能指针三剑客：适用场景与陷阱

auto ptr = std::make_unique<Widget>(); // C++14推荐
std::unique_ptr<Widget> p2 = std::move(ptr); // 移动所有权

struct Node {
    std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // ❌ 循环引用：引用计数永不为0 → 内存泄漏

std::weak_ptr<Widget> wp = sp; // sp为shared_ptr
if (auto p = wp.lock()) {
    // 安全使用p
}

2.3 自定义删除器：资源管理的灵活性

智能指针的删除器决定资源释放方式，常用于非内存资源（文件句柄、网络连接）：

// 关闭文件句柄
auto fileDeleter = [](FILE* fp) { if(fp) fclose(fp); };
std::unique_ptr<FILE, decltype(fileDeleter)> fp(fopen("data.txt", "r"), fileDeleter);

注意：删除器类型影响智能指针类型（unique_ptr的删除器是类型的一部分），但shared_ptr的删除器通过类型擦除存储。

3.1 vector vs list：选择依据

经验法则：除非需频繁在中间插入/删除且数据量巨大，否则优先选择vector。

3.2 unordered_map vs map：哈希与红黑树之争

unordered_map（哈希表）：平均O(1)查找，最坏O(n)，内存占用略高；map（红黑树）：O(log n)查找，有序存储。

// 自定义哈希函数（面试高频！）
struct HashPair {
    size_t operator()(const std::pair<int,int>& p) const {
        return std::hash<int>{}(p.first) ^ (std::hash<int>{}(p.second) << 1);
    }
};
std::unordered_map<std::pair<int,int>, int, HashPair> mp;

陷阱：C++11前pair无标准哈希特化，需自定义；C++20起支持std::pair的哈希。

3.3 迭代器失效：高频雷区

面试常问：哪些STL操作会导致迭代器失效？

• vector：插入/删除元素时，若引发重新分配，则所有迭代器/指针/引用失效；否则仅删除点后迭代器失效。
• list：仅删除点迭代器失效，插入不影响其他迭代器。
• string：类似vector，但某些实现中修改后所有迭代器失效。

3.4 allocator：STL内存定制的隐藏接口

allocator是STL的内存分配策略，支持自定义内存池（如游戏引擎中预分配对象内存）：

template<class T>
struct PoolAllocator {
    using value_type = T;
    T* allocate(std::size_t n) {
        return static_cast<T*>(pool_.allocate(n * sizeof(T)));
    }
    void deallocate(T* p, std::size_t) noexcept {
        pool_.deallocate(p);
    }
    Pool& pool_;
};

注意：C++20起allocator_traits简化了自定义allocator的实现。

4.1 std::thread生命周期管理

经典错误：线程未join或detach导致程序崩溃：

std::thread t([]{ std::cout << "Hello"; });
// 错误：未处理线程状态 → 析构时terminate
t.join(); // ✅ 等待线程结束
// 或 t.detach(); // 分离线程（需确保对象生命周期）

建议：用RAII封装线程（如std::jthread，C++20），自动join。

4.2 原子操作与内存模型

内存顺序（memory_order）决定同步强度：

// 双检查锁（DCLP）的正确实现
std::atomic<Singleton*> instance;
std::mutex mtx;
Singleton* getInstance() {
    Singleton* tmp = instance.load(std::memory_order_acquire);
    if (!tmp) {
        std::lock_guard<std::mutex> lock(mtx);
        tmp = instance.load(std::memory_order_relaxed);
        if (!tmp) {
            tmp = new Singleton();
            instance.store(tmp, std::memory_order_release);
        }
    }
    return tmp;
}

4.3 条件变量与虚假唤醒

为何条件变量需用while循环检查谓词？

std::mutex mtx;
std::condition_variable cv;
bool ready = false;
// 线程A
{
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // ✅ 推荐：自动循环检查
}
// 错误写法（可能被虚假唤醒）
cv.wait(lock);
if (ready) { ... } // ❌ ready可能未变但线程被唤醒

原理：POSIX规范允许条件变量在无signal时唤醒（硬件中断、系统信号等），故需谓词保护。

5.1 单例模式：C++11后的线程安全实现

C++11起局部静态变量初始化线程安全，简化单例实现：

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

延伸：Meyers' Singleton（如上）是C++11后推荐方案，避免静态初始化顺序问题。

5.2 策略模式：模板与多态的对比

策略模式常用于算法切换，C++中可用模板或虚函数实现：

// 模板策略（编译期绑定，零开销）
template<class Strategy>
class Context {
    void execute() { strategy_.operate(); }
    Strategy strategy_;
};
// 虚函数策略（运行期绑定，支持多态）
class Context {
    void execute() { strategy_->operate(); }
    std::unique_ptr<StrategyBase> strategy_;
};

选择依据：策略类型固定用模板；策略需运行期动态切换用虚函数。

5.3 系统设计高频题：高并发日志系统

需求：每秒百万级日志写入，零拷贝、低延迟、支持分级过滤。

设计要点：

• 异步写入：生产者-消费者模型，环形缓冲队列（如boost::lockfree::queue）；
• 零拷贝：用mmap写入文件，避免用户态与内核态拷贝；
• 分级过滤：预编译日志级别宏（如DEBUG→#define LOG_LEVEL 1）；
• 缓冲合并：批量刷盘（如每10ms或满1MB刷一次）。

6.1 模块（Modules）：终结头文件时代

传统头文件问题：文本包含→重复解析、宏污染、编译依赖链长。

// math.ixx（模块接口文件）
export module math;
export int add(int a, int b) { return a + b; }
// main.cpp
import math;
int main() { return add(2, 3); }

优势：编译速度提升10倍+，无宏污染，显式导出接口。

6.2 协程（Coroutines）：轻量级异步编程

协程避免回调地狱，支持co_await/co_yield：

task<int> fetchData() {
    auto data = co_await socket.async_read();
    co_return process(data);
}

应用场景：网络服务器、游戏逻辑、状态机。

6.3 概念（Concepts）：泛型编程的编译期检查

用概念约束模板参数，提升错误提示清晰度：

template<typename T>
concept Integral = std::is_integral_v<T>;
template<Integral T>
T add(T a, T b) { return a + b; }
// 错误：add(1.0, 2.0) → 编译器提示：'double'不满足'Integral'概念

6.4 其他重要特性

• std::span：安全数组视图，替代指针+长度参数；
• 范围库（Ranges）：支持管道式操作（如view::filter | view::transform）；
• 三向比较运算符（<=> ）：自动生成比较操作符。

7.1 高频考点TOP 5

1. 智能指针循环引用：如何检测与避免？
2. 虚函数表内存布局：多重继承下指针偏移计算
3. 内存模型与可见性：volatile与atomic区别
4. RAII设计：自定义资源管理类（如文件锁）
5. 系统设计：高并发计数器（原子操作/锁选择）

7.2 真实问题解析

7.3 面试避坑指南

• 勿过度解释：面试官问“什么是虚函数”，答定义+内存布局+使用场景即可，勿展开汇编实现；
• 承认未知：遇到不会的问题，可说“我了解基础原理，但未深入研究，能否给点提示？”
• 追问细节：当答出方案后，主动问“您希望我从哪方面展开？”（展现沟通能力）

8.1 行业需求分布

8.2 技术成长路径

8.3 学习资源推荐

• 书籍：《Effective C++》《More Effective C++》《C++ Concurrency in Action》《深度探索C++对象模型》
• 开源项目：Boost.Asio、Folly、abseil-cpp、fmt
• 社区：Stack Overflow、Reddit r/cpp、C++ Core Guidelines

Q：C++23已发布，是否需要立即学习？

A：C++23标准在2023年正式通过，但主流编译器支持度仍在完善中。建议优先掌握C++17，再逐步学习C++20/23特性。企业落地通常滞后标准2-3年。

Q：转行学C++是否太晚？

A：C++工程师平均年龄32岁，经验积累价值高。若具备编程基础（如Python/Java），3-6个月可掌握核心技能进入初级岗位。

Q：如何准备C++面试中的手写代码题？

A：重点练习：智能指针实现、单例模式、线程安全队列、内存池。建议用白板手写，强调边界条件与异常安全。