STL 迭代器篇

迭代器介绍

迭代器是一种在编程中用于遍历容器或数据结构中的元素的工具，提供了统一的访问接口，允许程序员在不同类型的容器上执行相似的操作，无需了解容器的底层实现。迭代器允许元素的访问、插入、删除和修改，提供了灵活性和可重用性，是C++标准库（STL）的核心概念之一。

迭代器是一种用于访问容器或数据结构中元素的抽象概念，它提供了一种统一的方式来遍历和操作容器中的元素，而不必了解容器的底层实现。迭代器在C++标准库中是一个非常强大和通用的工具，具有以下功能和优点：

1. **统一接口**：迭代器提供了一个统一的、一致的接口，使得您可以在不同类型的容器上使用相同的代码来遍历元素，而不必关心容器的具体类型。这提高了代码的可重用性和可维护性。

2. **随机访问**：某些迭代器类型（例如，`RandomAccessIterator`）支持随机访问，允许您跳跃式地访问容器中的元素，例如通过索引访问。这提供了高效的元素访问方式。

3. **双向遍历**：双向迭代器（`BidirectionalIterator`）允许您向前和向后遍历容器，使得可以反转元素或在容器中进行逆序操作。

4. **插入和删除**：迭代器允许您在容器中插入和删除元素，而不破坏迭代过程。这对于对容器进行动态修改非常有用。

5. **标准算法**：STL提供了丰富的标准算法，这些算法可以在不同类型的容器上使用迭代器来执行各种操作，包括查找、排序、过滤、转换等等。

6. **安全性**：迭代器通常会提供范围检查，以确保不越界访问容器的元素，从而提高代码的安全性。

7. **适应性**：迭代器不仅适用于STL容器，还可以用于用户自定义的容器或数据结构，只要为这些容器定义了合适的迭代器接口。

8. **可扩展性**：您可以编写自定义迭代器，以满足特定需求，例如自定义容器或特殊数据结构。

总之，迭代器是C++标准库中的核心概念，它们为容器操作提供了通用的、一致的接口，使得编写灵活、可重用的代码成为可能。迭代器使C++的STL成为一个功能丰富而强大的库，适用于各种不同的应用领域。

迭代器类型

Input Iterator（输入迭代器）	单向单次遍历、只读
Output Iterator（输出迭代器）	单向单次遍历、只写
Forward Iterator（前向迭代器）	单向多次遍历、可读写
Reverse Iterator（逆向迭代器）	是一个包装其他迭代器的逆向版本，用于逆向遍历容器
Bidirectional Iterator（双向迭代器）	可前后遍历，可读写
Random Access Iterator（随机访问迭代器）	支持随机访问、跳跃式遍历容器

 输入迭代器

输入迭代器（Input Iterator）是一种迭代器，支持从容器中读取元素，但不支持修改或多次遍历容器。以下是一个使用输入迭代器的代码示例：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 获取输入迭代器，通常使用const_iterator来确保只读访问
    std::vector<int>::const_iterator it = vec.begin();

    // 遍历容器并输出元素
    while (it != vec.end()) {
        // 使用迭代器解引用操作符 * 获取元素的值
        int value = *it;

        // 输出元素的值
        std::cout << value << ' ';

        // 通过迭代器使用 ++ 操作符移动到容器中的下一个元素
        ++it;
    }

    std::cout << std::endl;

    return 0;
}

 输出迭代器

输出迭代器（Output Iterator）是一种迭代器，支持向容器中写入元素，但不支持读取或多次遍历容器。下面是一个使用输出迭代器的简单示例代码：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;

    // 获取输出迭代器
    std::back_insert_iterator<std::vector<int>> it = std::back_inserter(vec);

    // 使用输出迭代器向容器中插入元素
    for (int i = 1; i <= 5; ++i) {
        *it = i; // 使用迭代器写入元素到容器
    }

    // 遍历容器并输出元素
    for (int num : vec) {
        std::cout << num << ' ';
    }

    std::cout << std::endl;

    return 0;
}

`std::back_inserter` 会创建一个输出迭代器，该迭代器在使用 `*it = i` 这种赋值操作时，会将新元素添加到容器的末尾，然后自动将迭代器指向新插入的元素的位置，而不需要手动执行自增操作。这是 `std::back_inserter` 的设计和作用。

这种方式非常方便，因为它隐藏了容器的具体操作细节，使代码更简洁和易读。实际上，`std::back_inserter` 是一个方便的工具，用于在不覆盖容器中的元素的情况下将新元素添加到容器的末尾。它允许您以更高层次的抽象来考虑问题，而不必担心容器内部的细节。

前向迭代器

前向迭代器（Forward Iterator）是一种迭代器，支持单向遍历容器，允许多次读取和写入，但不支持向后遍历容器。它在STL中被广泛使用，适用于许多容器类型，例如链表（std::list）

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 获取前向迭代器
    std::list<int>::iterator it = myList.begin();

    // 遍历容器并输出元素
    while (it != myList.end()) {
        // 使用迭代器解引用操作符 * 获取元素的值
        int value = *it;

        // 输出元素的值
        std::cout << value << ' ';

        // 通过迭代器使用 ++ 操作符移动到容器中的下一个元素
        ++it;
    }

    std::cout << std::endl;

    return 0;
}

逆向迭代器

用于逆向遍历容器的元素。它是标准C++库（STL）提供的一种迭代器类型，它的作用是反转正向迭代器的遍历方向，从容器的末尾开始向容器的开头遍历元素。逆向迭代器通常用于需要逆序访问容器的情况，例如，从容器的最后一个元素向前遍历到第一个元素。下面是一个使用逆向迭代器的示例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };

    // 获取逆向迭代器
    std::vector<int>::reverse_iterator it = vec.rbegin();

    // 遍历容器并逆向输出元素
    while (it != vec.rend()) {
        // 使用逆向迭代器解引用操作符 * 获取元素的值
        int value = *it;

        // 输出元素的值
        std::cout << value << ' ';

        // 通过逆向迭代器使用 ++ 操作符移动到容器中的下一个元素
        ++it;
    }

    std::cout << std::endl;

    return 0;
}

随机访问迭代器

随机访问迭代器（Random Access Iterator）是C++标准库中最灵活和功能最丰富的迭代器类型之一，它支持随机访问容器元素，允许跳跃式遍历容器，提供了高效的元素访问。随机访问迭代器具有比前向迭代器或双向迭代器更多的功能，包括支持加法和减法操作、比较操作以及随机访问元素的能力。 

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };

    // 获取随机访问迭代器
    std::vector<int>::iterator it = vec.begin();

    // 使用随机访问迭代器访问元素
    std::cout << "Element at index 2: " << it[2] << std::endl;

    // 使用迭代器的加法操作符跳跃式访问元素
    it += 2;
    std::cout << "Element at index 4: " << it[2] << std::endl;

    return 0;
}

 双向迭代器

双向迭代器（Bidirectional Iterator）是一种迭代器类型，它提供了在容器中进行双向遍历的能力，即可以向前和向后遍历容器元素，但不支持随机访问。双向迭代器比前向迭代器更灵活，因为它们允许逆向遍历容器。

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = { 1, 2, 3, 4, 5 };

    // 使用双向迭代器遍历列表
    std::list<int>::iterator it = myList.begin();

    // 使用++运算符前进
    std::cout << "Forward traversal:" << std::endl;
    while (it != myList.end()) {
        std::cout << *it << " ";
        ++it;
    }
    std::cout << std::endl;

    // 使用--运算符后退
    std::cout << "Reverse traversal:" << std::endl;
    it = myList.end();
    while (it != myList.begin()) {
        --it;
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}