编辑“︁C++ 随机访问迭代器”︁

{{Note|本条目是C++标准模板库(STL)迭代器系列的一部分，重点讲解随机访问迭代器的特性和用法。建议读者先掌握[[前向迭代器]]和[[双向迭代器]]的基础概念。}}

== 简介 ==
'''随机访问迭代器(Random Access Iterator)'''是C++ STL中最强大的迭代器类别，它结合了双向迭代器的所有功能，并添加了直接访问任意元素的能力。这种迭代器支持像指针一样的算术运算，可以常数时间内跳转到容器中的任何位置。

随机访问迭代器满足以下所有要求：
* 可递增/递减（继承自双向迭代器）
* 可比较（继承自前向迭代器）
* 支持算术运算（<code>+</code>, <code>-</code>, <code>+=</code>, <code>-=</code>）
* 支持关系运算符（<code><</code>, <code>></code>, <code><=</code>, <code>>=</code>）
* 支持下标操作（<code>[]</code>）

== 支持随机访问迭代器的容器 ==
以下STL容器提供随机访问迭代器：
* <code>std::vector</code>
* <code>std::deque</code>
* <code>std::array</code>
* 原始数组（指针可作为随机访问迭代器）

{{Warning|<code>std::list</code>, <code>std::set</code>, <code>std::map</code>等容器'''不'''提供随机访问迭代器}}

== 核心操作 ==
=== 算术运算 ===
随机访问迭代器支持指针风格的算术运算：

<syntaxhighlight lang="cpp">
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    auto it = vec.begin();  // 获取起始迭代器
    
    it = it + 3;  // 前进3个位置
    std::cout << *it << "\n";  // 输出: 40
    
    it -= 2;      // 后退2个位置
    std::cout << *it << "\n";  // 输出: 20
    
    auto it2 = vec.end() - 1;  // 直接获取最后一个元素
    std::cout << *it2 << "\n"; // 输出: 50
    
    return 0;
}
</syntaxhighlight>

=== 关系比较 ===
可以比较两个迭代器的位置关系：

<syntaxhighlight lang="cpp">
std::vector<int> vec = {1, 2, 3, 4, 5};
auto first = vec.begin();
auto last = vec.end();

if (first < last) {  // 比较位置
    std::cout << "first comes before last\n";
}

if (first + 5 == last) {
    std::cout << "begin + size equals end\n";
}
</syntaxhighlight>

=== 下标访问 ===
随机访问迭代器支持类似数组的下标操作：

<syntaxhighlight lang="cpp">
std::vector<char> letters = {'a', 'b', 'c', 'd', 'e'};
auto it = letters.begin();

std::cout << it[2] << "\n";  // 输出: 'c' (等价于 *(it + 2))
</syntaxhighlight>

== 性能特点 ==
随机访问迭代器保证以下操作都是常数时间O(1)复杂度：
* 递增/递减
* 算术运算（+n, -n）
* 关系比较
* 解引用
* 下标访问

<mermaid>
graph LR
    A[迭代器位置i] -->|+n| B[迭代器位置i+n]
    B -->|-n| A
    A --> C[直接访问元素]
    B --> D[直接访问元素]
</mermaid>

== 实际应用案例 ==
=== 二分查找实现 ===
随机访问迭代器的高效跳转能力使其成为实现算法如二分查找的理想选择：

<syntaxhighlight lang="cpp">
#include <vector>
#include <algorithm>
#include <iostream>

bool binary_search(std::vector<int>::iterator first, 
                  std::vector<int>::iterator last, int value) {
    auto count = last - first;
    while (count > 0) {
        auto it = first;
        auto step = count / 2;
        it += step;
        
        if (*it < value) {
            first = ++it;
            count -= step + 1;
        } else if (*it > value) {
            count = step;
        } else {
            return true;
        }
    }
    return false;
}

int main() {
    std::vector<int> data = {1, 3, 5, 7, 9, 11};
    std::cout << std::boolalpha;
    std::cout << "Found 5: " << binary_search(data.begin(), data.end(), 5) << "\n";
    std::cout << "Found 6: " << binary_search(data.begin(), data.end(), 6) << "\n";
    return 0;
}
</syntaxhighlight>

输出：
<pre>
Found 5: true
Found 6: false
</pre>

=== 矩阵访问优化 ===
在处理多维数据结构时，随机访问迭代器可以显著提高性能：

<syntaxhighlight lang="cpp">
#include <vector>
#include <iostream>

void process_matrix(std::vector<std::vector<int>>& matrix) {
    const int rows = matrix.size();
    if (rows == 0) return;
    const int cols = matrix[0].size();
    
    // 展平矩阵处理
    std::vector<int> flat;
    flat.reserve(rows * cols);
    
    for (const auto& row : matrix) {
        flat.insert(flat.end(), row.begin(), row.end());
    }
    
    // 使用随机访问高效处理
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            flat[i * cols + j] *= 2;  // 随机访问
        }
    }
    
    // 输出结果
    auto it = flat.begin();
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << *it++ << " ";
        }
        std::cout << "\n";
    }
}

int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    process_matrix(matrix);
    return 0;
}
</syntaxhighlight>

输出：
<pre>
2 4 6 
8 10 12 
14 16 18 
</pre>

== 数学表达 ==
随机访问迭代器的位置计算可以用数学公式表示为：

<math>
\text{iterator}_{new} = \text{iterator}_{current} \pm n
</math>

其中n为整数偏移量，时间复杂度为：

<math>
O(1)
</math>

== 与指针的关系 ==
随机访问迭代器的设计模仿了原始指针的行为，实际上，对于连续内存容器（如<code>std::vector</code>），其迭代器通常就是指针的简单包装。

重要区别：
{| class="wikitable"
|-
! 特性 !! 指针 !! 随机访问迭代器
|-
| 算术运算 | 支持 | 支持
|-
| 解引用 | 支持 | 支持
|-
| 空值 | <code>nullptr</code> | 容器特定的"尾后"迭代器
|-
| 类型安全 | 弱 | 强（模板实现）
|}

== 最佳实践 ==
1. '''优先使用算法''：许多STL算法（如<code>std::sort</code>, <code>std::nth_element</code>）要求随机访问迭代器
2. '''避免无效迭代器'''：容器修改可能导致迭代器失效
3. '''性能敏感代码'''：随机访问特性使得它成为性能关键代码的首选
4. '''通用编程'''：编写模板代码时，考虑使用最弱的迭代器类别满足需求

== 常见错误 ==
{{Warning|以下代码展示了随机访问迭代器的典型误用}}

=== 越界访问 ===
<syntaxhighlight lang="cpp">
std::vector<int> v = {1, 2, 3};
auto it = v.begin() + 5;  // 未定义行为！
</syntaxhighlight>

=== 混合容器迭代器 ===
<syntaxhighlight lang="cpp">
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
if (v1.begin() < v2.end()) {  // 未定义行为！
    // ...
}
</syntaxhighlight>

=== 失效迭代器 ===
<syntaxhighlight lang="cpp">
std::vector<int> v = {1, 2, 3};
auto it = v.begin() + 1;
v.insert(v.begin(), 0);  // 可能导致迭代器失效
std::cout << *it;        // 未定义行为！
</syntaxhighlight>

== 总结 ==
随机访问迭代器是C++中最强大的迭代器类别，提供了类似指针的操作能力。理解其特性和正确用法对于编写高效、正确的C++代码至关重要。它使得开发者能够以最高效的方式访问和操作序列容器中的元素，是实现复杂算法的基础构建块。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++stl 迭代器]]