C++类和对象刷题指南：从基础到高级实战

1. C++类和对象刷题指南：从入门到精通

作为一名有十年经验的C++开发者，我深知类和对象是C++面试和实际开发中最核心的知识点。这份刷题集是我根据多年面试官经验和项目实战总结出来的精华题目，覆盖了从基础到高级的所有关键考察点。

2. 为什么选择这些题目？

2.1 题目筛选标准

这些题目不是随意挑选的，而是基于三个核心标准：

1. 面试高频：90%的C++技术面试都会涉及这些知识点
2. 实际应用：每个题目都对应真实项目中的典型场景
3. 知识体系：题目之间形成递进关系，系统覆盖类和对象所有核心概念

2.2 难度分级逻辑

我将题目分为五个难度等级：

• ★：基础语法和概念
• ★★：常见设计模式和资源管理
• ★★★：高级特性和系统设计
• ★★★★：深入理解和性能优化
• ★★★★★：综合应用和底层实现

3. 核心题目详解

3.1 基础必刷题（1-5题）

3.1.1 实现复数类（题1）

这是最基础的类和对象练习，重点考察：

• 构造函数的重载
• 运算符重载（+,-,*,/）
• const成员函数的使用

关键实现技巧：

cpp复制class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r=0, double i=0) : real(r), imag(i) {}
    
    // 运算符重载示例
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    
    // 输出运算符重载
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
};

注意：运算符重载时，要考虑返回值和参数是否为const引用，这是面试常考点。

3.1.2 实现简版string类（题2）

这是考察深拷贝和资源管理的经典题目，必须掌握：

• 拷贝构造函数
• 拷贝赋值运算符
• 移动构造函数
• 移动赋值运算符

内存管理要点：

cpp复制class MyString {
    char* data;
    size_t length;
    
    void free() { delete[] data; }  // 统一的释放资源函数
    
public:
    // 拷贝构造函数
    MyString(const MyString& other) : 
        data(new char[other.length + 1]),
        length(other.length) 
    {
        std::copy(other.data, other.data + length + 1, data);
    }
    
    // 移动构造函数
    MyString(MyString&& other) noexcept : 
        data(other.data),
        length(other.length) 
    {
        other.data = nullptr;  // 必须置空，防止双重释放
        other.length = 0;
    }
    
    ~MyString() { free(); }
};

3.2 中级进阶题（6-10题）

3.2.1 单例模式实现（题3）

单例模式有多种实现方式，现代C++推荐Meyers' Singleton：

cpp复制class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;  // 线程安全(C++11起)
        return instance;
    }
    
    // 禁用拷贝和移动
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
private:
    Singleton() = default;
    ~Singleton() = default;
};

关键点：C++11保证了局部静态变量的线程安全，这是最简洁高效的实现方式。

3.2.2 智能指针实现（题4和题8）

unique_ptr和shared_ptr的实现展示了C++资源管理的核心思想：

shared_ptr核心实现：

cpp复制template<typename T>
class shared_ptr {
    T* ptr;
    long* ref_count;
    
public:
    explicit shared_ptr(T* p = nullptr) : ptr(p), ref_count(new long(1)) {}
    
    ~shared_ptr() {
        if (--*ref_count == 0) {
            delete ptr;
            delete ref_count;
        }
    }
    
    // 拷贝构造函数增加引用计数
    shared_ptr(const shared_ptr& other) : 
        ptr(other.ptr), ref_count(other.ref_count) 
    {
        ++*ref_count;
    }
};

3.3 高级挑战题（11-14题）

3.3.1 实现简易vector（题7）

vector是STL中最常用的容器，实现它需要掌握：

• 动态内存管理
• 扩容策略（通常2倍增长）
• 异常安全保证
• 迭代器设计

关键扩容逻辑：

cpp复制void reserve(size_t new_capacity) {
    if (new_capacity <= capacity) return;
    
    T* new_data = static_cast<T*>(operator new(new_capacity * sizeof(T)));
    size_t i = 0;
    try {
        for (; i < size; ++i) {
            new (&new_data[i]) T(std::move(data[i]));  // 移动构造
        }
    } catch (...) {
        for (size_t j = 0; j < i; ++j) {
            new_data[j].~T();  // 已构造对象的析构
        }
        operator delete(new_data);
        throw;
    }
    
    for (size_t i = 0; i < size; ++i) {
        data[i].~T();  // 原对象的析构
    }
    operator delete(data);
    data = new_data;
    capacity = new_capacity;
}

3.3.2 实现带迭代器的容器（题13）

迭代器是STL设计的核心，实现要点：

• 定义iterator和const_iterator类型
• 实现begin()和end()方法
• 支持常用的迭代器操作（++, *, ->等）

示例框架：

cpp复制template<typename T>
class Vector {
    T* data;
    size_t size;
    size_t capacity;
    
public:
    class iterator {
        T* ptr;
    public:
        explicit iterator(T* p) : ptr(p) {}
        // 实现各种迭代器操作...
    };
    
    iterator begin() { return iterator(data); }
    iterator end() { return iterator(data + size); }
    
    // const迭代器版本...
};

4. 刷题策略建议

4.1 不同目标的刷题路径

根据你的目标，我推荐不同的刷题顺序：

校招/初级岗位（1-3周）

1. 复数类（掌握基础语法）
2. 字符串类（理解深拷贝）
3. 单例模式（常用设计模式）
4. 链式调用（理解this指针）
5. 对象计数（理解生命周期）
6. 禁用拷贝（理解特殊成员函数）
7. 智能指针（资源管理）
8. 移动语义（现代C++核心）

中高级岗位（1-3个月）

1. 字符串类（夯实基础）
2. 对象计数（深入理解对象生命周期）
3. 单例模式（多种实现对比）
4. 智能指针（unique_ptr和shared_ptr）
5. 移动语义（String实现）
6. Vector实现（动态数组）
7. Shared_ptr（引用计数）
8. 迭代器实现（STL设计思想）
9. CRTP（高级模板技巧）
10. 对象池（性能优化）

4.2 刷题方法论

1. 先理解后实现：先彻底理解题目考察点，再动手编码
2. 测试驱动：为每个类编写全面的测试用例
3. 多种实现：尝试不同的实现方式（如单例的多种实现）
4. 性能分析：比较不同实现的性能差异
5. 异常安全：考虑代码的异常安全性

5. 常见问题与解决方案

5.1 内存管理问题

5.2 多线程安全问题

1. 单例模式的线程安全：C++11后局部静态变量初始化是线程安全的
2. 计数器的线程安全：使用std::mutex保护共享数据
3. 智能指针的线程安全：引用计数的原子操作

线程安全计数器示例：

cpp复制class ThreadSafeCounter {
    mutable std::mutex mtx;
    int count = 0;
    
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx);
        ++count;
    }
    
    int get() const {
        std::lock_guard<std::mutex> lock(mtx);
        return count;
    }
};

5.3 现代C++特性应用

1. 移动语义：通过实现移动构造函数和移动赋值运算符提升性能
2. =delete：显式禁用不需要的函数（如拷贝构造）
3. noexcept：标记不会抛出异常的函数
4. constexpr：编译期计算优化

6. 实战经验分享

在实际项目中，类和对象的设计有几个关键原则：

1. 单一职责原则：每个类只做一件事
2. RAII原则：资源获取即初始化
3. 接口最小化：只暴露必要的public接口
4. const正确性：尽可能使用const修饰

我在实现字符串类时踩过的坑：

• 忘记处理自赋值情况（a = a）
• 移动操作后未置空原指针
• 未考虑异常安全导致内存泄漏
• 扩容时没有优化小字符串（SSO）

一个实用的调试技巧：在析构函数和关键操作中添加日志输出，可以清晰跟踪对象的生命周期和资源管理情况。