c++ 特殊迭代器

特殊迭代器详解（如果用到可参考如下使用方式）

C++ 标准库提供了一些特殊的迭代器，用于处理特定的场景。以下是这些迭代器的详细讲解及代码示例。

---

1. 插入迭代器（Insert Iterators）

插入迭代器用于将元素插入到容器中，而不是覆盖现有元素。常见的插入迭代器包括：

• back_insert_iterator：将元素插入到容器的末尾（适用于 vector、deque、list 等支持 push_back 的容器）。
• front_insert_iterator：将元素插入到容器的开头（适用于 deque、list 等支持 push_front 的容器）。
• insert_iterator：将元素插入到容器的指定位置。

示例代码

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>

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

    // 使用 back_insert_iterator 将 src 的元素插入到 dst 的末尾
    std::copy(src.begin(), src.end(), std::back_inserter(dst));
    for (int i : dst) {
        std::cout << i << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;

    std::list<int> lst;
    // 使用 front_insert_iterator 将 src 的元素插入到 lst 的开头
    std::copy(src.begin(), src.end(), std::front_inserter(lst));
    for (int i : lst) {
        std::cout << i << " "; // 输出: 5 4 3 2 1
    }
    std::cout << std::endl;

    std::vector<int> vec = {10, 20, 30};
    // 使用 insert_iterator 在 vec 的第二个位置插入 src 的元素
    std::copy(src.begin(), src.end(), std::inserter(vec, vec.begin() + 1));
    for (int i : vec) {
        std::cout << i << " "; // 输出: 10 1 2 3 4 5 20 30
    }
    std::cout << std::endl;

    return 0;
}

---

2. 流迭代器（Stream Iterators）

流迭代器用于将流（如标准输入输出流）当作序列来处理。

• istream_iterator：从输入流中读取数据。
• ostream_iterator：向输出流中写入数据。

示例代码

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

int main() {
    // 使用 istream_iterator 从标准输入读取数据
    std::cout << "Enter some numbers (Ctrl+D to end): ";
    std::istream_iterator<int> input_it(std::cin), eof;
    std::vector<int> vec(input_it, eof);

    // 使用 ostream_iterator 将数据写入标准输出
    std::cout << "You entered: ";
    std::ostream_iterator<int> output_it(std::cout, " ");
    std::copy(vec.begin(), vec.end(), output_it);
    std::cout << std::endl;

    return 0;
}

---

3. 反向迭代器（Reverse Iterators）

反向迭代器允许从容器的末尾向开头遍历。

• rbegin()：返回指向容器最后一个元素的反向迭代器。
• rend()：返回指向容器第一个元素前一个位置的反向迭代器。

示例代码

#include <iostream>
#include <vector>

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

    // 使用反向迭代器遍历容器
    for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
        std::cout << *it << " "; // 输出: 5 4 3 2 1
    }
    std::cout << std::endl;

    return 0;
}

---

4. 移动迭代器（Move Iterators）

移动迭代器用于将元素从一个容器移动到另一个容器，而不是复制。

• make_move_iterator：将普通迭代器转换为移动迭代器。

示例代码

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

int main() {
    std::vector<std::string> src = {"Hello", "World"};
    std::vector<std::string> dst;

    // 使用移动迭代器将 src 的元素移动到 dst
    std::move(src.begin(), src.end(), std::back_inserter(dst));

    std::cout << "src size: " << src.size() << std::endl; // 输出: 0
    std::cout << "dst content: ";
    for (const auto& s : dst) {
        std::cout << s << " "; // 输出: Hello World
    }
    std::cout << std::endl;

    return 0;
}

---

迭代器与哨兵（Sentinel）

哨兵是一种特殊的标记，用于表示范围的结束。它可以与迭代器结合使用，简化某些算法的实现。

• 例如，C++20 引入了基于范围的 for 循环，其底层使用哨兵来检测范围的结束。

并发算法（C++17 / C++20）

C++17 和 C++20 引入了并行执行策略，允许算法在多线程环境下并行执行。常见的执行策略包括：

1. std::execution::seq：顺序执行（默认）。
2. std::execution::par：并行执行。
3. std::execution::par_unseq：并行执行，且允许向量化（SIMD）。
4. std::execution::unseq：向量化执行（C++20）。

示例代码

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

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

    // 使用并行策略对 vec 进行排序
    std::sort(std::execution::par, vec.begin(), vec.end());

    for (int i : vec) {
        std::cout << i << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;

    return 0;
}

---

总结

• 插入迭代器：用于将元素插入容器。
• 流迭代器：用于将流当作序列处理。
• 反向迭代器：用于从容器的末尾向开头遍历。
• 移动迭代器：用于将元素从一个容器移动到另一个容器。
• 并发算法：通过执行策略实现并行化，提升性能。