C++迭代器（iterator）

C++迭代器（iterator）

1、迭代器的介绍

迭代器是一个对象，提供遍历容器内元素的方法，可以访问、修改容器中的元素。

虽然迭代器可以被认为是一个指向容器元素的指针，但迭代器更加灵活，比如迭代器可以访问分段储存的容器

int main()
{
    std::vector<int> vtr;
    for (int i = 0; i < 10; i++) {
        int rm = rand() % 100;
        vtr.push_back(rm);
    }
    for (std::vector<int>::iterator i = vtr.begin(); i != vtr.end(); i++) {
        std::cout << *i << " ";
    }
}

vector是连续存储的容器

2、类别

2.1 输入迭代器（Input iterator）

输入迭代器是指一类只能进行输入功能且只能单次读取的迭代器，例如istream_iterator就是一个标准的输入迭代器。

istream_iterator 只能用于读取输入流

int main()
{
	std::istream_iterator<int> int_iter(std::cin);//从cin读取int
	std::istream_iterator<int> eof;//istream尾后迭代器
	std::vector<int> vec;
	while (int_iter != eof)//当有数据可供读取时
	{
		//后置递增运算符，返回迭代器的旧值
		//解引用迭代器，获得从流读取的前一个值
		vec.push_back(*int_iter++);
	}
}

istrem_iterator 具有懒惰求值的特性，只有解引用的时候才会在输入流中读入数据

int main() {
    std::cout << "开始创建 std::istream_iterator..." << std::endl;
    // 创建一个从 std::cin 读取整数的输入流迭代器
    std::istream_iterator<int> int_iter(std::cin);
    std::istream_iterator<int> eof;
    std::cout << "std::istream_iterator 创建完成，尚未进行解引用操作。" << std::endl;

    std::vector<int> vec;
    int count = 0;
    while (int_iter != eof) {
        std::cout << "即将解引用迭代器，准备读取第 " << count + 1 << " 个值..." << std::endl;
        // 解引用 int_iter 获取当前读取的值
        int value = *int_iter;
        std::cout << "成功读取第 " << count + 1 << " 个值: " << value << std::endl;
        // 将读取的值添加到 vec 中
        vec.push_back(value);

        std::cout << "即将递增迭代器，准备读取下一个值..." << std::endl;
        // 递增 int_iter，准备读取下一个值
        ++int_iter;
        std::cout << "迭代器已递增。" << std::endl;

        count++;
    }

    // 输出读取到的所有整数
    std::cout << "读取到的所有整数为: ";
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

2.2 输出迭代器（Output iterator）

与输入迭代器类似，是一类只能进行单次写入操作的迭代器，例如ostream_iterator就是一个标准的输出迭代器。

ostream_iterator 也是一个流迭代器

int main() {
    std::vector<int> vec = { 10, 20, 30, 40, 50 };
    std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}

2.3 正向迭代器（Forward iterator)

正向|前向迭代器支持读取和写入操作，支持且仅支持自增运算（向前移动），STL库中的大多数容器vector、list等大多提供正向迭代器。

int main() {
    std::forward_list<int> flst = { 1, 2, 3, 4, 5 };
    for (std::forward_list<int>::iterator it = flst.begin(); it != flst.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return 0;
}

2.4 双向迭代器（Bidirectional Iterator）

双向迭代器支持正向迭代器的全部功能和自减运算，STL库中的容器vector、list等至少提供双向迭代器。

reverse等泛型算法都需要使用到双向迭代器

#include <iostream>
#include <list>

int main() {
    std::list<int> last = { 1, 2, 3, 4, 5 };
    // 使用反向迭代器进行反向遍历
    for (std::list<int>::reverse_iterator it = last.rbegin(); it != last.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return 0;
}

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

随机访问迭代器额外支持随机访问（例如通过下标访问）

vector 就是一个随机访问迭代器

2.6 迭代器的关系

迭代器们之间形成了独特的层次结构，后一种的迭代器都继承了前一个迭代器的功能。它们大体上的关系可以用式2.6.1表示

式2.6.1

输入|输出迭代器<正向迭代器<双向迭代器<随机访问迭代器

3、构造迭代器

#ifndef MY_ITERATOR_H
#define MY_ITERATOR_H

#include <iostream>
#include <iterator>

// 自定义迭代器类
template <typename T>
class MyIterator {
public:
    // 定义迭代器的特征
    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using reference = T&;

    // 构造函数
    MyIterator(pointer ptr) : m_ptr(ptr) {}

    // 解引用操作符
    reference operator*() const { return *m_ptr; }

    // 递增操作符（前置）
    MyIterator& operator++() {
        ++m_ptr;
        return *this;
    }

    // 递增操作符（后置）
    MyIterator operator++(int) {
        MyIterator temp = *this;
        ++(*this);
        return temp;
    }

    // 相等比较操作符
    bool operator==(const MyIterator& other) const {
        return m_ptr == other.m_ptr;
    }

    // 不相等比较操作符
    bool operator!=(const MyIterator& other) const {
        return !(*this == other);
    }

private:
    pointer m_ptr;
};

// 自定义容器类
template <typename T, size_t N>
class MyContainer {
public:
    T data[N];

    // 开始迭代器
    MyIterator<T> begin() { return MyIterator<T>(data); }

    // 结束迭代器
    MyIterator<T> end() { return MyIterator<T>(data + N); }
};

#endif // MY_ITERATOR_H