C++ STL 核心概念：迭代器、auto 与范围循环

2.4 迭代器的分类

不同数据结构提供的迭代器能力不同，这是连接数据结构与算法的关键：

1. 随机访问迭代器：最强大，支持算术运算（如 it + 5）。底层为连续内存的容器拥有它，如 std::vector 和 std::deque，只有这类容器才能使用 std::sort 快速排序。
2. 双向迭代器：支持向前和向后移动，但不能跳跃。如基于链表实现的 std::list。
3. 单向迭代器：只能单步向前移动。如单向链表 std::forward_list。

三、auto 关键字

C++11 引入的 auto 是提升效率和可读性的神器，能省去大量类型书写时间并避免拼写错误。

3.1 核心概念：编译期类型推导

auto 变量的类型是在编译期根据初始值自动推断的，而非运行时。

#include <iostream>
using namespace std;

int main() {
    auto a = 10;       // 推导为 int
    auto b = 3.14;     // 推导为 double
    auto c = "Hello";  // 推导为 const char*
    return 0;
}

注意：使用 auto 必须同时初始化，否则无法推导类型。

3.2 关键使用场景

简化复杂类型声明

在 STL 中常遇到嵌套极深的类型，auto 能极大简化代码。

#include <iostream>
#include <map>
using namespace std;

int main() {
    map<string, string> dict = {
        {"apple", "苹果"},
        {"orange", "橙子"},
        {"pear", "梨"}
    };
    
    // 传统写法过于冗余
    // map<string, string>::iterator it = dict.begin();
    
    // 使用 auto 简化
    auto it = dict.begin();
    return 0;
}

引用和 const 限定符的推导规则

auto 默认会剥离顶层 const 和引用属性。如果你想要保留这些特性，必须显式指定。

int x = 10;
int& rx = x;
const int cx = 10;

auto a = rx;      // a 是 int，发生值拷贝
auto b = cx;      // b 是 int，顶层 const 被丢弃

// 正确写法：保留引用和 const
auto& c = rx;     // c 是 int&，修改 c 会改变 x
const auto d = cx;// d 是 const int，只读访问

函数返回值推导

编译器会根据 return 语句反向推导返回类型。但需注意：

1. 多个 return 语句的类型必须完全一致，编译器不会隐式转换。
2. auto 作为返回值默认丢弃引用，若需返回引用应写成 auto&。

// 错误示例：类型不一致
auto check_number(int x) {
    if (x > 0) return 1;   // int
    else return 1.5;        // double -> 编译报错
}

// 正确示例：返回引用
int global_var = 100;
auto& get_ref() {
    int& ref = global_var;
    return ref;
}

四、范围 for 循环

范围 for 循环是 C++11 引入的重要特性，简化了数组和容器的遍历，减少越界风险。

4.1 基本语法

for (元素类型 元素变量名 : 遍历对象) {
    // 循环体
}

4.2 三种常用遍历方式

A. 按值遍历

每次循环拷贝元素，修改变量不影响原数据。适用于基础类型且不需修改的场景。

vector<int> nums = {1, 2, 3};
for (int x : nums) {
    cout << x << " ";
}

B. 按引用遍历

加上 & 符号，直接引用容器内元素，修改变量即修改原数据。

vector<int> nums = {1, 2, 3};
for (int& x : nums) {
    x *= 2; // 原数组变为 {2, 4, 6}
}

C. 按常量引用遍历

加上 const 和 &，既无拷贝开销又保证数据不被意外修改。遍历复杂对象（如 string、结构体）时的推荐写法。

vector<string> words = {"Hello", "World"};
for (const string& word : words) {
    cout << word << endl;
}

4.3 结合 auto 关键字

实际开发中通常配合 auto 使用，让编译器推导类型：

• for (auto x : container)：按值拷贝
• for (auto& x : container)：按引用，可修改
• for (const auto& x : container)：按常量引用，只读且高效

vector<string> words = {"Hello", "World"};
for (const auto &word : words) {
    cout << word << endl;
}

4.4 范围 for 的本质

范围 for 并非魔法，而是编译器提供的语法糖。它本质上会被转化为基于迭代器的循环：

// 你的代码
for (auto& x : container) { /*...*/ }

// 编译器实际转化逻辑
auto _begin = container.begin();
auto _end = container.end();
for (; _begin != _end; ++_begin) {
    auto& x = *_begin;
    /*...*/
}

理解这一机制有助于在调试时更好地把握程序执行流程。