C++ 编程面试题全解析，助你通关

xiaoshi 05-30 12 抢沙发

默认

摘要： ...

C++编程面试题全解析：突破技术面试的关键技巧

为什么C++面试如此具有挑战性？

C++作为一门历史悠久且功能强大的编程语言，在系统开发、游戏引擎、高频交易等领域占据着不可替代的地位。正因为其复杂性和灵活性，C++面试往往成为技术求职者的"拦路虎"。面试官不仅会考察基础语法，更会深入内存管理、多线程、性能优化等高级话题。

一位资深技术面试官曾透露："C++面试中，90%的候选人会在指针和内存管理问题上栽跟头，而那些真正理解对象生命周期和资源管理的候选人往往能脱颖而出。"这充分说明了掌握C++核心概念的重要性。

基础语法与核心概念必考题

指针与引用的本质区别

指针和引用是C++中最容易混淆的概念之一。指针是一个存储内存地址的变量，而引用则是对象的别名。关键区别在于：

指针可以为nullptr，引用必须绑定到有效对象
指针可以重新指向其他对象，引用一旦初始化就不能改变
对指针使用sizeof得到指针本身大小，对引用得到引用对象大小

int a = 10;
int* p = &a;  // 指针
int& r = a;   // 引用

const关键字的多种用法

const在C++中有多种使用场景，理解这些细微差别至关重要：

const变量：值不可修改
const指针：指针本身或指向的内容不可修改
const成员函数：承诺不修改对象状态
const参数：函数内部不能修改参数

const int* p1;        // 指向常量的指针
int const* p2;        // 同上，语法不同
int* const p3 = &a;   // 常量指针
const int* const p4;  // 指向常量的常量指针

内存管理深度剖析

new/delete与malloc/free的差异

虽然new/delete和malloc/free都用于动态内存分配，但存在本质区别：

new调用构造函数，delete调用析构函数；malloc/free只分配释放内存
new返回具体类型指针，malloc返回void*
new可以重载，malloc不能
new失败抛出异常，malloc失败返回NULL

// C++方式
MyClass* obj = new MyClass();
delete obj;

// C方式
MyClass* obj = (MyClass*)malloc(sizeof(MyClass));
free(obj);

智能指针的现代实践

现代C++推荐使用智能指针管理资源，避免内存泄漏：

unique_ptr：独占所有权，不可复制
shared_ptr：共享所有权，引用计数
weak_ptr：不增加引用计数的观察者

std::unique_ptr<MyClass> uptr(new MyClass());
std::shared_ptr<MyClass> sptr = std::make_shared<MyClass>();
std::weak_ptr<MyClass> wptr(sptr);

面向对象编程精髓

虚函数与多态实现机制

虚函数是实现运行时多态的关键，其底层通过虚函数表(vtable)实现：

含有虚函数的类会自动生成vtable
每个对象包含指向vtable的指针(vptr)
调用虚函数时通过vptr查找vtable再跳转

class Base {
public:
    virtual void show() { cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { cout << "Derived\n"; }
};

Base* b = new Derived();
b->show();  // 输出"Derived"

移动语义与完美转发

C++11引入的移动语义大幅提升了性能：

std::move将左值转为右值引用
移动构造函数"窃取"资源而非复制
完美转发保持参数的值类别

class String {
public:
    // 移动构造函数
    String(String&& other) {
        data = other.data;
        size = other.size;
        other.data = nullptr;
    }
};

template<typename T>
void wrapper(T&& arg) {
    // 完美转发
    worker(std::forward<T>(arg));
}

模板与泛型编程高阶技巧

SFINAE与类型萃取

SFINAE(替换失败不是错误)是模板元编程的核心技术：

template<typename T>
auto test(T* p) -> decltype(p->size(), void()) {
    // 只有当T有size()成员时才匹配此重载
}

template<typename T>
void test(...) {
    // 备选重载
}

C++11类型萃取可以检查类型特性：

static_assert(std::is_integral<int>::value, "必须为整型");

可变参数模板应用

可变参数模板实现类型安全的printf：

void my_printf(const char* format) {
    std::cout << format;
}

template<typename T, typename... Args>
void my_printf(const char* format, T value, Args... args) {
    while (*format) {
        if (*format == '%') {
            std::cout << value;
            my_printf(format + 1, args...);
            return;
        }
        std::cout << *format++;
    }
}

并发编程关键考点

线程同步原语对比

C++提供了多种同步机制：

mutex：互斥锁，最基本同步
condition_variable：条件变量，线程间通信
atomic：原子操作，无锁编程
future/promise：异步结果传递

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    // 工作代码
}

void master() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_all();
}

内存模型与原子操作

理解内存顺序对编写正确并发代码至关重要：

memory_order_relaxed：仅保证原子性
memory_order_consume：依赖关系顺序
memory_order_acquire：读操作同步
memory_order_release：写操作同步
memory_order_acq_rel：读写都同步
memory_order_seq_cst：顺序一致性

std::atomic<bool> flag(false);
std::atomic<int> data(0);

void producer() {
    data.store(42, std::memory_order_relaxed);
    flag.store(true, std::memory_order_release);
}

void consumer() {
    while (!flag.load(std::memory_order_acquire));
    assert(data.load(std::memory_order_relaxed) == 42);
}

性能优化实战策略

缓存友好代码编写

现代CPU性能很大程度上取决于缓存利用率：

局部性原则：集中访问相邻内存
避免虚假共享：不相关的数据不要放在同一缓存行
预取友好：顺序访问优于随机访问

// 不好的例子：随机访问
for (int i = 0; i < N; ++i) {
    sum += data[random_index[i]];
}

// 好的例子：顺序访问
for (int i = 0; i < N; ++i) {
    sum += data[i];
}

内联与分支预测

帮助编译器生成高效代码的技巧：

小函数标记为inline
热路径代码保持直线型
避免虚函数调用在关键循环中
使用likely/unlikely提示分支预测

if (likely(condition)) {
    // 大概率执行的代码
} else {
    // 小概率执行的代码
}

实际编程问题解析

实现智能指针

面试常要求手写简化版智能指针：

template<typename T>
class SimpleUniquePtr {
    T* ptr;
public:
    explicit SimpleUniquePtr(T* p = nullptr) : ptr(p) {}
    ~SimpleUniquePtr() { delete ptr; }

    // 删除拷贝语义
    SimpleUniquePtr(const SimpleUniquePtr&) = delete;
    SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;

    // 允许移动语义
    SimpleUniquePtr(SimpleUniquePtr&& other) : ptr(other.ptr) {
        other.ptr = nullptr;
    }

    SimpleUniquePtr& operator=(SimpleUniquePtr&& other) {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }

    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
    T* get() const { return ptr; }
};

设计线程安全队列

展示并发编程能力的经典题目：

template<typename T>
class ThreadSafeQueue {
    std::queue<T> data;
    mutable std::mutex mtx;
    std::condition_variable cv;

public:
    void push(T value) {
        std::lock_guard<std::mutex> lock(mtx);
        data.push(std::move(value));
        cv.notify_one();
    }

    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mtx);
        if (data.empty()) return false;
        value = std::move(data.front());
        data.pop();
        return true;
    }

    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this]{ return !data.empty(); });
        value = std::move(data.front());
        data.pop();
    }
};