【C++】深入理解C++迭代器：概念、分类与自定义实现

前言

1. 迭代器的概念

在 C++ 中，迭代器（iterator ）可以看作是一种指向容器元素的对象，它提供了类似指针的接口来访问容器中的元素。

通过迭代器，程序员能够在不关心容器内部实现的情况下，安全地遍历容器中的所有元素。 与传统的数组指针不同，迭代器不仅提供指向元素的功能，还支持各种容器特性，如顺序访问、随机访问等。

迭代器的核心任务是遍历容器。 它是容器和算法之间的纽带，通过迭代器，标准库算法能够作用于不同类型的容器，而不需要为每种容器编写特定的代码。

---

2. 迭代器的作用

迭代器在 C++ 中发挥着非常重要的作用，主要体现在以下几个方面：

• 统一访问接口：无论是数组、链表、向量还是其他容器，迭代器都提供了统一的访问接口。通过相同的方式，程序员可以访问不同容器的数据。

• 容器与算法的解耦：C++ 标准库中的算法通过迭代器来访问容器的元素，这样容器与算法的实现可以解耦。算法不关心容器内部的实现细节，只通过迭代器提供的接口操作容器中的数据。

• 遍历容器：迭代器是遍历容器的核心工具，它提供了类似指针的操作，例如解引用（*）和移动（++，--）等。

• 提供灵活的数据操作：除了基本的遍历操作，迭代器还允许直接修改容器中的数据，或者支持更复杂的操作，如随机访问、反向迭代等。

---

3. 迭代器的分类

迭代器根据其功能和对容器数据的操作权限可分为多种类型。常见的分类方式有两种：按功能分类和按能否修改数据分类。

3.1 按功能分类

• 输入迭代器（Input Iterator）：

  • 只支持单向访问容器中的元素。
  • 适用于只读取数据的场景。
  • 不支持修改元素。
  • 常见场景：读取流数据。

• 输出迭代器（Output Iterator）：

  • 只支持单向访问并能向容器中插入数据。
  • 不能读取数据。
  • 适用于将数据输出或写入容器的场景。
  • 常见场景：生成容器数据。

• 双向迭代器（Bidirectional Iterator）：

  • 支持双向访问容器中的元素，即可以向前或向后遍历。
  • 可读可写。
  • 常见场景：如双向链表。

• 随机访问迭代器（Random Access Iterator）：

  • 支持任意位置的直接访问，可以像数组一样通过下标进行元素访问。
  • 支持前进、后退、加减等操作。
  • 可读可写。
  • 常见场景：如 std::vector 和 std::deque。

• 常量迭代器（Const Iterator）：

  • 只支持读取数据，不能修改容器中的元素。
  • 通常用于只读取容器内容的场景，确保容器数据不被修改。

3.2 按能否修改数据分类

• 普通迭代器（Mutable Iterator）：

  • 支持读取和修改容器中的元素。
  • 常用于在遍历过程中修改容器中的数据。

• 常量迭代器（Const Iterator）：

  • 只允许读取容器中的数据，不允许修改容器中的数据。
  • 常用于遍历容器并确保容器数据不被修改的场景。

---

4. 迭代器的本质

从实现角度来看，迭代器本质上是容器的一个封装类对象，通常通过重载指针操作符（如 * 和 ++）来模拟指针的行为。迭代器通常具有以下特点：

• 封装：迭代器封装了指向容器元素的指针或其他指针类型，它抽象了容器的内部结构，使得程序员可以统一操作。

• 与容器紧密关联：每个容器类型都有其相应的迭代器类型。不同类型的容器可以有不同的迭代器实现。例如，std::vector 使用随机访问迭代器，而 std::list 使用双向迭代器。

• 支持迭代操作：迭代器支持基本的迭代操作，如解引用（*）、前进（++）、后退（--）等，这些操作使得迭代器成为访问容器元素的主要工具。

迭代器的内部实现

迭代器内部通常包含指向容器元素的指针，且可能定义了不同的操作符来实现移动、解引用等功能。对于不同的容器类型，迭代器可能实现为原始指针（如数组）、链表节点指针（如 std::list）或其他类型的指针。

template<typename T>
class MyIterator {
public:
    MyIterator(T* ptr) : m_ptr(ptr) {}
    
    T& operator*() { return *m_ptr; }  // 解引用操作
    MyIterator& operator++() { ++m_ptr; return *this; }  // 前进操作
    bool operator!=(const MyIterator& other) { return m_ptr != other.m_ptr; }

private:
    T* m_ptr;
};

---

5. 如何为自定义容器编写迭代器

当我们需要为自定义容器提供迭代器时，首先需要为容器定义一个迭代器类。自定义迭代器需要提供迭代器所需的基本操作，如解引用（*）、前进（++）、比较（!=）等。此外，还需要处理容器内部数据的访问与迭代。

5.1 定义迭代器

下面是一个为自定义容器编写简单迭代器的示例。假设我们有一个自定义的数组容器 MyArray。

template<typename T>
class MyArray {
public:
    MyArray(size_t size) : m_size(size), m_data(new T[size]) {}
    ~MyArray() { delete[] m_data; }

    // 定义迭代器类型
    class Iterator {
    public:
        Iterator(T* ptr) : m_ptr(ptr) {}

        T& operator*() { return *m_ptr; }
        Iterator& operator++() { ++m_ptr; return *this; }
        bool operator!=(const Iterator& other) { return m_ptr != other.m_ptr; }

    private:
        T* m_ptr;
    };

    Iterator begin() { return Iterator(m_data); }
    Iterator end() { return Iterator(m_data + m_size); }

private:
    size_t m_size;
    T* m_data;
};

5.2 使用自定义迭代器

我们可以使用定义好的迭代器来遍历自定义容器的数据：

int main() {
    MyArray<int> arr(5);
    
    // 初始化数据
    for (int i = 0; i < 5; ++i) {
        arr.begin() + i = i + 1;
    }

    // 使用自定义迭代器遍历容器
    for (auto it = arr.begin(); it != arr.end(); ++it) {
        std::cout << *it << " ";  // 输出：1 2 3 4 5
    }

    return 0;
}

---