C/C++ 核心能力

📅 4周详细学习计划

1. 指针与内存管理

1.1 指针基础

• 指针本质：存储内存地址的变量，大小固定（64位系统为8字节）
• 指针与数组：数组名退化为指针，但sizeof行为不同
• 指针运算：指针+1移动sizeof(type)个字节，用于遍历数组
• 函数指针：存储函数地址，实现回调和策略模式

// 指针与数组的关系
int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;  // 数组名退化为指针
sizeof(arr);    // 20 (5 * 4 bytes)
sizeof(p);      // 8 (指针大小)

// 指针运算
*(p + 2);  // 等价于 arr[2]，值为3
p++;       // p现在指向arr[1]

1.2 引用 vs 指针

• 引用：必须初始化，不可重绑定，更安全
• 指针：可延迟初始化，可重指向，更灵活
• 使用场景：函数参数优先用const引用，需要nullptr检查用指针

1.3 内存模型

• 栈内存：自动分配/释放，速度快，大小有限（通常1-8MB）
• 堆内存：手动new/delete，速度慢，空间大
• 全局/静态区：程序启动时分配，结束时释放

// 栈 vs 堆
void stack_vs_heap() {
    int stack_var = 10;           // 栈上，函数返回自动释放
    int* heap_var = new int(10);  // 堆上，需要delete
    
    // 栈溢出示例
    int huge_array[1000000];  // ❌ 可能栈溢出
    
    // 堆分配
    int* safe_array = new int[1000000];  // ✅ 堆上分配
    delete[] safe_array;
}

2. 模板编程

2.1 函数模板

• 模板推导：编译器根据实参自动推导类型
• 显式指定：template<int>max(3, 5) 指定模板参数
• 非类型参数：template<size_t N> 接受编译期常量
• 重载解析：非模板函数优先于模板函数

// 函数模板进阶
// 1. 类型推导
template<typename T>
T max_val(T a, T b) { return (a > b) ? a : b; }

// 2. 非类型参数
template<int N>
void fill_array(int (&arr)[N]) {
    for(int i=0; i// 3. 模板特化
template<>
const char* max_val<const char*>(const char* a, const char* b) {
    return strcmp(a, b) > 0 ? a : b;
}

2.2 类模板

• 模板成员函数：定义在类外需template<>前缀
• 友元函数：模板友元的声明语法
• 模板静态成员：每个实例化有自己的静态成员

2.3 变参模板

• 参数包展开：... 语法展开参数包
• 递归展开：传统的递归处理方式
• 折叠表达式：C++17更简洁的展开方式

// 变参模板示例
// 递归展开
template<typename T>
T sum(T v) { return v; }

template<typename T, typename... Args>
T sum(T first, Args... rest) {
    return first + sum(rest...);
}

// C++17 折叠表达式
template<typename... Args>
auto sum_fold(Args... args) {
    return (args + ...);  // 一元右折叠
}

3. RAII与智能指针

3.1 RAII原则

• 核心思想：资源获取即初始化，构造函数获取资源，析构函数释放
• 优势：异常安全，自动资源管理
• 典型应用：lock_guard, unique_ptr, fstream

3.2 智能指针详解

• unique_ptr：独占所有权，零开销（与裸指针相同）
• shared_ptr：引用计数共享所有权，线程安全（计数操作原子）
• weak_ptr：不拥有对象，解决循环引用
• make_shared：一次内存分配（对象+控制块），更高效

// 智能指针最佳实践
// 1. 优先使用make_unique/make_shared
auto p1 = std::make_unique<Widget>();
auto p2 = std::make_shared<Widget>();

// 2. 传递unique_ptr（转移所有权）
void process(std::unique_ptr<Widget> w);

// 3. 传递shared_ptr（共享所有权）
void process(std::shared_ptr<Widget> w);

// 4. 不需要所有权时用裸指针或引用
void observe(const Widget& w);

// 5. 循环引用示例
struct Node {
    std::shared_ptr<Node> next;  // 应该用weak_ptr
};

4. STL容器与算法

4.1 容器选择指南

• vector：连续内存，随机访问O(1)，尾部增删O(1)，中间插入O(n)
• list：双向链表，任意位置增删O(1)，不支持随机访问
• deque：双端队列，两端增删O(1)，支持随机访问
• unordered_map：哈希表，查找O(1)平均，无序
• map：红黑树，查找O(log n)，有序

4.2 迭代器失效

• vector：插入/删除可能使所有迭代器失效（重新分配时）
• list：只有被删除元素的迭代器失效
• deque：两端操作不会使中间迭代器失效

4.3 Lambda表达式

• 语法：[捕获](参数) -> 返回类型 { 函数体 }
• 捕获方式：值捕获、引用捕获、隐式捕获
• 用途：算法参数、回调函数、局部闭包

// Lambda实战
std::vector<int> v = {3, 1, 4, 1, 5, 9};

// 排序
std::sort(v.begin(), v.end(), [](int a, int b) {
    return a > b;  // 降序
});

// for_each
std::for_each(v.begin(), v.end(), [](int x) {
    std::cout << x << " ";
});

// lambda捕获
int threshold = 5;
auto it = std::find_if(v.begin(), v.end(),
    [threshold](int x) { return x > threshold; });

5. 现代C++特性

5.1 Move语义

• 右值引用：T&& 绑定到临时对象
• std::move：将左值转换为右值，触发移动构造
• 移动后状态：对象处于"合法但未定义"状态

5.2 Perfect Forwarding

• 万能引用：T&& 在模板中转发任意值类别
• std::forward：保持参数的值类别
• 应用场景：工厂函数、emplace系列函数

5.3 其他现代特性

• constexpr：编译期求值，提升性能
• Structured Bindings：auto [a, b] = pair; 解构返回值
• std::optional：表示可选值，避免nullptr
• std::variant：类型安全的联合体
• if constexpr：编译期条件分支

// 现代C++特性
// 1. constexpr编译期计算
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n-1);
}
constexpr int f10 = factorial(10);  // 编译期计算

// 2. Structured Bindings
auto [key, value] = *map.begin();  // C++17

// 3. std::optional
std::optional<int> find(const std::vector<int>& v, int target) {
    for(auto x : v) if(x == target) return x;
    return std::nullopt;
}