C++ STL 基础：迭代器、auto 与范围循环

2.4 迭代器的分类（初步了解）

不同的数据结构底层内存分布不同，因此它们提供的迭代器能力也不同，这是连接数据结构与算法的关键：

1. 随机访问迭代器：最强大的迭代器，支持像指针一样进行算术运算，比如 it + 5（直接跳到 5 个位置后）。 注：底层是连续内存的容器拥有它，比如 std::vector 和 std::deque，只有拥有这种迭代器的容器，才能使用 std::sort 进行快速排序。
2. 双向迭代器：支持向前 (++) 和向后 (--) 移动，但不能跨越式跳跃。比如基于链表实现的 std::list。
3. 单向迭代器：只能单步向前移动 (++)，比如单向链表 std::forward_list。

三、auto 关键字

在现代 C++11 以后，auto 绝对是提升开发效率和代码可读性的'神器'，它能帮你省去大量敲击键盘的时间，并有效避免类型拼写错误。

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

在使用 auto 声明的变量，它的类型不是在运行的时候决定的，而是在编译代码时，编译器根据你给变量赋予的初始值，自动推断出来的。

代码示例：使用 auto 关键字，进行推导变量的类型。

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

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

注意：

1. 正因为是根据初始值推导，所以使用 auto 声明变量时，必须同时进行初始化。
2. 写 auto x; 是无法通过编译的。

3.2 auto 的关键使用场景

拯救极其冗长、复杂的类型声明

在学习 STL 和算法时，你经常会遇到嵌套极深的数据结构。如果没有 auto，代码会写得非常痛苦且容易出错。

代码示例：简化数据类型的代码量

#include <iostream>
#include <string>
#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();
}

3.3 注意事项

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

使用 auto 时，最容易出错的地方在于它对引用和 const 限定符的推导规则：auto 默认会'剥离'顶层 const 和引用。

代码示例：

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

auto a = rx; // a 的类型是 int（引用属性被丢弃），属于值拷贝
auto b = cx; // b 的类型是 int（顶层 const 被丢弃）

解析：

1. 拆解 auto a = rx;：前情回顾 int x = 10; int& rx = x; 其中 rx 是 x 的引用。在 C++ 里，引用仅仅是个别名。当你使用 rx 的时候，你实际上就是在操作 x 本身，它的值是 10。发生推导时，编译器认为你想用 rx 的值（也就是 10）来初始化一个新的变量 a，既然你没写 &（比如 auto& a），说明你不想让 a 也变成别名，你只是想要那个数字 10 而已。结果：编译器把 a 推导为普通的 int。它在内存里挖了一块全新的空间，把 10 复制了进去。
2. 拆解 auto b = cx;：前情回顾 const int cx = 10;。cx 是一个被 const 锁住的整数。这里的 const 叫做顶层 const（Top-level const），意思是这个变量本身是不允许被修改的。发生推导时，编译器认为你想把 cx 里的值（10）掏出来，放进一个新变量 b 里，虽然 cx 本身是被锁住的（不能改），但这跟你新创建的 b 有什么关系呢？结果：编译器把 b 推导为普通的 int，把 10 复制了进去。b 是一个自由的、可以随意修改的普通变量。

代码示例：保留引用和 const 的写法

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

auto& c = rx;      // c 是 int&，修改 c 会改变 x
const auto d = cx; // d 是 const int，常用于只读访问

因此，C++ 规定：auto 默认只给你最纯粹的底层类型（如 int、double），给你最大的自由，如果你想要引用（&）或者只读（const），你必须自己动手明确地写出来。

B. 不能用于函数参数（C++20 之前）

在 C++20 之前，普通函数的参数不能用 auto，而需要使用模板。

代码示例：非法的写法

// 不能做参数
void func2(auto a) {}

C. auto 可以做函数返回值

核心机制：编译器会通过阅读你函数体内的 return 语句，来反向推导出这个函数到底该返回什么类型。

1. 基础用法：让编译器替你算类型

auto multiply(int a, double b) {
    return a * b; // 编译器知道 int * double 的结果是 double，所以自动推导返回类型为 double
}

2. 避坑指南

坑点一：多个 return 语句的类型必须'完全一致'

如果你的函数里有 if-else 分支，并且包含多个 return，那么所有 return 后面的表达式类型必须一模一样。编译器不会帮你做隐式类型转换。

代码示例：if-else 返回的类型不同

auto check_number(int x) {
    if (x > 0) {
        return 1;       // 类型是 int
    } else {
        return 1.5;     // 编译报错！类型是 double，与上面的 int 冲突
    }
}

解决办法：强制统一类型，比如把 return 1; 改成 return 1.0;。

坑点二：auto 依然会丢弃引用（&）和 const

这跟我们之前讨论的变量推导规则是一模一样的，默认情况下，auto 作为返回值永远是'值拷贝'。

代码示例：返回引用 和 const 类型的值

int global_var = 100;
// 你本意是想返回 global_var 的引用
auto get_ref() {
    int& ref = global_var;
    return ref;
}
// 实际结果：get_ref() 返回的是一个普通的 int（发生了值拷贝），引用属性被丢弃了！

解决办法：如果你确实想返回引用，必须显式地写成 auto& 或者 const auto&

int global_var = 100;
// 你本意是想返回 global_var 的引用
auto& get_ref() {
    int& ref = global_var;
    return ref;
}

四、范围 for 循环

范围 for 循环是 C++11 引入的一项极其重要且实用的特性，它极大地简化了遍历数组和容器（如 std::vector, std::string, std::map 等）的代码，使其更具可读性，同时也减少了数组越界等常见错误。

4.1 基本语法

范围 for 的语法非常直观：

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

相关参数讲解：

1. 元素类型：遍历对象中元素的类型（通常搭配 auto 关键字使用）。
2. 元素变量名：每次循环时，用来接收当前元素的变量。
3. 遍历对象：必须是一个可以确定范围的集合（如定长数组、标准库容器等）。

4.2 三种最常用的遍历方式

A. 按值遍历

核心特征：每次循环都会将容器中的元素拷贝给变量，修改变量不会影响容器内原本的数据。 适用场景：遍历基础数据类型（如 int, char, float），且不需要修改原数据。

代码示例：遍历基础类型 int

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

B. 按引用遍历

核心特征：加上 & 符号，变量直接引用容器内的元素，修改变量就等于修改了容器内的原数据。 适用场景：需要修改容器内元素的内容时。

代码示例：遍历基础类型 int，并修改其内容

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

C. 按常量引用遍历

核心特征：加上 const 和 &，既不会发生拷贝（节省内存和时间），又保证了数据不被意外修改（只读）。 适用场景：遍历复杂对象（例如：string, 结构体，自定义类）且只需读取时，这是最推荐的写法。

代码示例：遍历复杂对象 string 类

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

4.3 结合 auto 关键字

在实际开发中，我们通常不需要手动写出繁琐的类型名，直接让编译器用 auto 推导即可：

1. for (auto x : container) （按值拷贝）
2. for (auto& x : container) （按引用，可修改）
3. for (const auto& x : container) （按常量引用，只读且高效）

代码示例：通过使用关键字 auto 遍历容器

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

4.4 范围 for 的本质

范围 for 并不是什么神奇的魔法，它本质上是编译器提供的一层'语法糖'。

当编译器看到范围 for 时，会自动将其转化为使用迭代器 (Iterator) 的循环：

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

// 编译器实际转化为类似这样的代码：
// _begin 指向头部元素的迭代器
auto _begin = container.begin();
// _end 指向尾部元素下一个位置的迭代器
auto _end = container.end();
for (; _begin != _end; ++_begin) {
    // 遍历迭代器，将容器的值赋值给 x
    auto& x = *_begin;
    /*...*/
}