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

迭代器的分类

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

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

auto 关键字

在现代 C++11 以后，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;
}

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

关键使用场景

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

在学习 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();
}

2. 引用和 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 被丢弃）

为什么会这样？

对于 auto a = rx;，前情回顾 int& rx = x;，其中 rx 是 x 的引用。在 C++ 里，引用仅仅是个别名。当你写下 auto a = rx; 时，编译器的内心戏是这样的：'你想用 rx 的值（也就是 10）来初始化一个新的变量 a，既然你没写 &（比如 auto& a），说明你不想让 a 也变成别名，你只是想要那个数字 10 而已。'结果就是编译器把 a 推导为普通的 int，它在内存里挖了一块全新的空间，把 10 复制了进去。

对于 auto b = cx;，cx 是一个被 const 锁住的整数。这里的 const 叫做顶层 const（Top-level const），意思是这个变量本身是不允许被修改的。发生推导时，编译器想的是：'你想把 cx 里的值（10）掏出来，放进一个新变量 b 里，虽然 cx 本身是被锁住的（不能改），但这跟你新创建的 b 有什么关系呢？'结果就是编译器把 b 推导为普通的 int，把 10 复制了进去，b 是一个自由的、可以随意修改的普通变量。

如果你想要保留引用或者只读属性，必须显式地写出来：

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），你必须自己动手明确地写出来。

3. 函数参数与返回值

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

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

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

基础用法：

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

避坑指南：

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

  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 作为返回值永远是'值拷贝'。

  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;
  auto& get_ref() {
      int& ref = global_var;
      return ref;
  }
  

范围 for 循环

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

基本语法

范围 for 的语法非常直观：

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

相关参数讲解：

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

三种最常用的遍历方式

A. 按值遍历

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

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

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;
}

结合 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;
}

范围 for 的本质

范围 for 并不是什么神奇的魔法，它本质上是编译器提供的一层'语法糖'。当编译器看到范围 for 时，会自动将其转化为使用迭代器（Iterator）的循环：

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

// 编译器实际转化为类似这样的代码：
auto _begin = container.begin();
auto _end = container.end();
for( ; _begin != _end ; ++_begin ) {
    auto& x = *_begin;
    /*...*/
}