CC++ 八股

一. C++ 基础

1.1 C++ 三大待性

1.1.1 访问权限

C++ 通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。

1.1.2 封装

1.1.3 继承

1.1.4 多态

多态实现原理

1.1.5 递归如何避免爆栈

1.2数据类型

1.3 指针和引用

1.4 关键字

1.4.1 const

1.4.2 define 和 typedef 的区别

1.4.3 define 和 inline 的区别

1.4.4 override 和 overload

1.4.5 new 和 malloc

1.4.6 constexpr 和 const

1.4.7 volatile

1.4.8 extern

1.4.9 static

1.4.10 前置++ 与 后置++

1.4.11 std::atomic

1.5 C++ 强制类型转换

1.5.1 static_cast

1.5.2 dynamic_cast

1.5.3 reinterpret_cast

1.5.4 const_cast

1.6 运算符重载

1.7 C++ 内存模型

1.7.1 字符串操作函数

1.7.2 内存泄漏

1.7.3 测试题目

1.8 计算机中的乱序执行

1.8.1 副作用

1.8.2 信号量

1.8.3 future 库

二. C++ STL

2.1 STL实现原理及其实现

2.1.1 容器

2.1.2 算法

2.1.3 迭代器

2.1.4 仿函数

2.1.5 适配器

2.1.5 空间配置器

2.1.6 STL 的优点

2.2 pair 容器

2.3 vector 容器实现与扩充

2.3.1 底层实现

2.3.2 扩容过程

2.3.3 vector 源码

2.4 list

2.4.1 list 设计

2.4.2 vector 和 list 的区别

2.5 deque

2.6 stack && queue

源码

2.7 heap && priority_queue

2.8 map && set

2.9 map && unordered_map

2.10 sort 为什么可以避免爆栈

三. C++泛型编程

C++ 模板全特化和偏特化

四. C++ 新特性

4.1 智能指针

4.1.1 shared_ptr

4.1.2 unique_ptr

4.1.3 weak_ptr

4.2 类型推导

4.3 右值引用

4.4 nullptr

4.5 范围 for 循环

4.6 列表初始化

4.7 lambda 表达式

4.8 并发

4.8.1 std::thread

4.8.2 lock_guard

4.8.3 unique_lock

4.8.4 线程安全的有界缓冲区

用模板类实现线程安全的有界缓冲区，实现 push、pop、size 函数。缓冲区线程安全，支持多个生产者、消费者同时操作，使用 C++11 或者更高的线程同步机制。

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <unistd.h>

template<typename T>
class BoundedBuffer {
public:
    explicit BoundedBuffer(size_t max_size) : size_(max_size) {}

    // 防止意外的对象拷贝导致的数据竞争问题, 删除拷贝构造函数
    BoundedBuffer(const BoundedBuffer &) = delete;

    // 防止意外的对象拷贝导致的数据竞争问题, 删除拷贝赋值运算符
    BoundedBuffer &operator=(const BoundedBuffer &) = delete;

    void push(T value) {
        std::unique_lock<std::mutex> lock(mutex_);

        // 等待直到队列有空间
        not_full_.wait(lock, [this]() {
            return buffer_.size() < size_;
        });

        buffer_.push(std::move(value));

        lock.unlock();

        // 通知消费者有新数据
        not_empty_.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mutex_);

        // 等待直到队列不为空
        not_empty_.wait(lock, [this]() {
            return !buffer_.empty();
        });

        T value = std::move(buffer_.front());
        buffer_.pop();

        lock.unlock();

        // 通知生产者有新空间
        not_full_.notify_one();

        return value;
    }

    size_t size() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return buffer_.size();
    }

private:
    std::queue<T> buffer_;              // 存储数据的缓冲区
    const size_t size_;                 // 缓冲区的容量
    mutable std::mutex mutex_;          // 互斥量
    std::condition_variable not_full_;  // 缓冲区不满条件变量
    std::condition_variable not_empty_; // 缓冲区非空条件变量
};

void test() {
    BoundedBuffer<int> buffer(5); // 创建容量为 5 的缓冲区

    auto producer = [&buffer]() {
        for (int i = 0; i < 10; ++i) {
            buffer.push(i);
            std::cout << std::this_thread::get_id() << " - " << "生产了: " << i << "\n";
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    };

    auto consumer = [&buffer]() {
        for (int i = 0; i < 10; ++i) {
            int value = buffer.pop();
            std::cout << std::this_thread::get_id() << " - " << "消费了: " << value << "\n";
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
        }
    };

    // 创建 3 个生产者和 2 个消费者
    std::vector<std::thread> threads;

    // 生产者线程
    threads.emplace_back(producer);
    threads.emplace_back(producer);
    threads.emplace_back(producer);

    // 消费者线程
    threads.emplace_back(consumer);
    threads.emplace_back(consumer);

    // 等待所有线程完成
    for (auto &thread: threads) {
        thread.join();
    }
}

int main() {

    test();

    return 0;
}

五. Effective STL

六. Effective C++