C++_10_37_iterator

简介

标准库

C++ 是什么

在C++中，<iterator> 是一个标准库头文件，提供了与迭代器相关的功能和模板类。该头文件定义了许多与迭代器操作和适配器相关的模板类和函数，使得对各种容器和序列的操作更加方便和统一。

以下是 <iterator> 头文件中一些常见的内容：

1. 迭代器标签

std::input_iterator_tag：输入迭代器标签。
std::output_iterator_tag：输出迭代器标签。
std::forward_iterator_tag：前向迭代器标签。
std::bidirectional_iterator_tag：双向迭代器标签。
std::random_access_iterator_tag：随机访问迭代器标签。

这些标签用于指定迭代器的类型，以便在泛型编程中选择适当的算法。

2. 迭代器类别

std::iterator_traits：模板类，提供有关迭代器类型的信息。

3. 迭代器操作

std::advance：将迭代器前进指定的步数。
std::distance：计算两个迭代器之间的距离。

4. 插入迭代器

std::back_inserter：用于在容器尾部插入元素的迭代器适配器。
std::front_inserter：用于在容器头部插入元素的迭代器适配器。
std::inserter：用于在指定位置插入元素的迭代器适配器。

5. 流迭代器

std::istream_iterator：输入流迭代器。
std::ostream_iterator：输出流迭代器。

这些迭代器适配器使得可以将输入流和输出流与迭代器接口一致地结合使用。

6. 其他

还有其他一些辅助功能和模板类，用于处理迭代器和序列的各种操作。

通过使用 <iterator> 头文件中提供的这些功能，开发者可以更方便地进行迭代器的操作、适配和处理，从而提高代码的灵活性和可维护性。

C++ 详解

<iterator> 是C++标准库中的头文件，提供了许多与迭代器相关的工具、类和函数。这个头文件包含了一系列功能，用于支持通用的迭代器操作和适配器。以下是 <iterator> 头文件的主要内容：

1. 迭代器标签

std::input_iterator_tag：输入迭代器标签。
std::output_iterator_tag：输出迭代器标签。
std::forward_iterator_tag：前向迭代器标签。
std::bidirectional_iterator_tag：双向迭代器标签。
std::random_access_iterator_tag：随机访问迭代器标签。

这些标签用于表示迭代器的不同特性，以便在泛型算法中根据迭代器的类型选择适当的算法。

2. 迭代器类别

std::iterator_traits：模板类，提供有关迭代器类型的信息，如迭代器的标签、值类型、指针类型等。

3. 迭代器操作

std::advance：用于将迭代器前进指定的步数。
std::distance：用于计算两个迭代器之间的距离。

4. 插入迭代器

std::back_inserter：迭代器适配器，用于在容器尾部插入元素。
std::front_inserter：迭代器适配器，用于在容器头部插入元素。
std::inserter：迭代器适配器，用于在指定位置插入元素。

这些插入迭代器适配器允许将算法应用于容器而无需关心具体插入的位置。

5. 流迭代器

std::istream_iterator：输入流迭代器，用于从输入流中读取数据。
std::ostream_iterator：输出流迭代器，用于向输出流中写入数据。

这些迭代器适配器允许将输入流和输出流与迭代器接口一致地结合使用。

6. `std::begin` 和 `std::end`

std::begin：用于获取容器的起始迭代器。
std::end：用于获取容器的结束迭代器。

这两个函数允许以通用的方式获得容器的起始和结束迭代器。

示例

以下是一个简单的示例，展示了 <iterator> 头文件中的一些功能：

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

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

    // 使用迭代器适配器将元素复制到输出流
    std::copy(std::begin(numbers), std::end(numbers), std::ostream_iterator<int>(std::cout, " "));

    return 0;
}

这个例子使用了 std::begin 和 std::end 获取容器的起始和结束迭代器，并使用 std::copy 将容器中的元素复制到输出流中。还使用了 std::ostream_iterator 来实现输出流迭代器。

C++ std::prev()函数详解

std::prev() 是 C++ 标准库中 <iterator> 头文件中定义的函数之一。它的作用是返回一个迭代器，指向指定迭代器之前的位置。

这个函数的声明如下：

template< class BidirIt >
constexpr BidirIt prev( BidirIt it, typename std::iterator_traits<BidirIt>::difference_type n = 1 );

BidirIt 是双向迭代器的类型。
it 是要移动的迭代器。
n 是要向前移动的步数，默认为1。

std::prev() 函数返回一个新的迭代器，该迭代器指向传入迭代器的前面。如果没有指定步数 n，默认向前移动一个位置。如果指定了步数 n，则向前移动 n 个位置。

以下是一个简单的例子，演示了 std::prev() 的使用：

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

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

    // 获取迭代器指向第四个元素
    auto it = numbers.begin() + 3;

    // 使用 std::prev() 向前移动两个位置
    auto prevIt = std::prev(it, 2);

    // 输出结果
    std::cout << "Current iterator position: " << *it << std::endl;
    std::cout << "Iterator position after std::prev(): " << *prevIt << std::endl;

    return 0;
}

在这个例子中，it 指向第四个元素，然后使用 std::prev() 向前移动两个位置，得到的 prevIt 指向第二个元素。

C++ std::advance()函数详解

std::advance() 是 C++ 标准库中 <iterator> 头文件中定义的函数之一。它的作用是将迭代器前移（或后移）指定的步数。

这个函数的声明如下：

template< class InputIt, class Distance >
constexpr void advance( InputIt& it, Distance n );

InputIt 是输入迭代器的类型。
it 是要移动的迭代器（传入的是引用）。
n 是要移动的步数。

std::advance() 函数将迭代器 it 前移 n 步。如果 n 为正数，则迭代器向前移动；如果 n 为负数，则迭代器向后移动。

以下是一个简单的例子，演示了 std::advance() 的使用：

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

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

    // 获取迭代器指向第二个元素
    auto it = numbers.begin() + 1;

    // 使用 std::advance() 向前移动两个位置
    std::advance(it, 2);

    // 输出结果
    std::cout << "Iterator position after std::advance(): " << *it << std::endl;

    return 0;
}

在这个例子中，it 指向第二个元素，然后使用 std::advance() 向前移动两个位置，最终 it 指向第四个元素。

C++ std::distance()函数详解

std::distance() 是 C++ 标准库中 <iterator> 头文件中定义的函数之一。它的作用是计算两个迭代器之间的距离（元素个数）。

这个函数的声明如下：

template< class InputIt >
constexpr typename std::iterator_traits<InputIt>::difference_type distance( InputIt first, InputIt last );

InputIt 是输入迭代器的类型。
first 是第一个迭代器。
last 是第二个迭代器。

std::distance() 函数返回两个迭代器之间的距离，即 last - first。结果的类型是由迭代器的 difference_type 决定的。

以下是一个简单的例子，演示了 std::distance() 的使用：

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

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

    // 获取两个迭代器分别指向第二个和第四个元素
    auto first = numbers.begin() + 1;
    auto last = numbers.begin() + 3;

    // 使用 std::distance() 计算它们之间的距离
    std::ptrdiff_t distance = std::distance(first, last);

    // 输出结果
    std::cout << "Distance between iterators: " << distance << std::endl;

    return 0;
}

在这个例子中，first 和 last 分别指向第二个和第四个元素，然后使用 std::distance() 计算它们之间的距离，最终输出结果为 2。

C++ std::back_inserter 详解

std::back_inserter 是 C++ 标准库中 <iterator> 头文件中定义的一个函数模板，它创建一个用于在容器尾部插入元素的插入迭代器。

这个函数模板的声明如下：

template< class Container >
std::back_insert_iterator<Container> back_inserter( Container& c );

Container 是容器的类型。

std::back_inserter 返回一个 std::back_insert_iterator 对象，它是一个迭代器，允许通过 operator++ 和 operator* 在容器的尾部插入元素。

以下是一个简单的例子，演示了 std::back_inserter 的使用：

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

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

    // 使用 std::back_inserter 创建插入迭代器
    std::back_insert_iterator<std::vector<int>> backInserter(destination);

    // 使用 std::copy 将 source 中的元素插入到 destination 的尾部
    std::copy(source.begin(), source.end(), backInserter);

    // 输出结果
    std::cout << "Destination vector after insertion: ";
    for (int num : destination) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，std::back_inserter 用于创建一个插入迭代器，然后使用 std::copy 将 source 容器中的元素插入到 destination 容器的尾部。最终输出结果为 Destination vector after insertion: 1 2 3 4 5。

C++ std::front_inserter 详解

在 C++ 标准库的 <iterator> 头文件中，std::front_inserter 是一个函数模板，用于创建一个插入迭代器，该迭代器允许在容器的开头插入元素。这通常用于在容器的前部执行插入操作。

下面是 std::front_inserter 的声明：

template< class Container >
std::front_insert_iterator<Container> front_inserter( Container& c );

Container 是容器的类型。

std::front_inserter 返回一个 std::front_insert_iterator 对象，该对象可以通过 operator++ 和 operator* 来在容器的开头插入元素。

以下是一个简单的例子，演示了 std::front_inserter 的使用：

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

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

    // 使用 std::front_inserter 创建插入迭代器
    std::front_insert_iterator<std::list<int>> frontInserter(destination);

    // 使用 std::copy 将 source 中的元素插入到 destination 的开头
    std::copy(source.begin(), source.end(), frontInserter);

    // 输出结果
    std::cout << "Destination list after insertion: ";
    for (int num : destination) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，std::front_inserter 用于创建一个插入迭代器，然后使用 std::copy 将 source 容器中的元素插入到 destination 容器的开头。最终输出结果为 Destination list after insertion: 5 4 3 2 1。

C++ std::inserter 详解

std::inserter 是 C++ 标准库中 <iterator> 头文件中定义的一个函数模板，用于创建一个插入迭代器，该迭代器允许在容器的任意位置插入元素。与 std::back_inserter 和 std::front_inserter 不同，std::inserter 允许指定插入位置。

这个函数模板的声明如下：

template< class Container, class Iterator >
std::insert_iterator<Container> inserter( Container& c, Iterator p );

Container 是容器的类型。
Iterator 是指定插入位置的迭代器。

std::inserter 返回一个 std::insert_iterator 对象，该对象可以通过 operator++ 和 operator* 来在指定位置插入元素。

以下是一个简单的例子，演示了 std::inserter 的使用：

#include <iostream>
#include <iterator>
#include <set>
#include <algorithm>

int main() {
    std::set<int> source = {1, 2, 3, 4, 5};
    std::set<int> destination;

    // 获取 destination 中的迭代器指向第一个元素
    auto it = destination.begin();

    // 使用 std::inserter 创建插入迭代器，指定插入位置为 it
    std::insert_iterator<std::set<int>> inserter(destination, it);

    // 使用 std::copy 将 source 中的元素插入到 destination 的指定位置
    std::copy(source.begin(), source.end(), inserter);

    // 输出结果
    std::cout << "Destination set after insertion: ";
    for (int num : destination) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，std::inserter 用于创建一个插入迭代器，指定插入位置为 it，然后使用 std::copy 将 source 容器中的元素插入到 destination 容器的指定位置。最终输出结果为 Destination set after insertion: 1 2 3 4 5。

C++ std::istream_iterator 详解

std::istream_iterator 是 C++ 标准库中 <iterator> 头文件中定义的一个模板类，用于创建一个输入迭代器，该迭代器从输入流中读取数据。

这个模板类的声明如下：

template< class T, class CharT = char, class Traits = std::char_traits<CharT>, class Distance = std::ptrdiff_t >
class istream_iterator;

T 是迭代器指向的元素类型。
CharT 是字符类型，默认为 char。
Traits 是字符特性，用于处理字符操作，默认为 std::char_traits<CharT>。
Distance 是迭代器之间的距离类型，默认为 std::ptrdiff_t。

std::istream_iterator 的对象通过输入流（如 std::cin）进行初始化，并通过 operator++ 和 operator* 来读取输入流中的数据。

以下是一个简单的例子，演示了 std::istream_iterator 的使用：

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

int main() {
    // 使用 std::istream_iterator 从标准输入流读取整数
    std::istream_iterator<int> it(std::cin);
    std::istream_iterator<int> end;

    // 使用 std::vector 存储从输入流读取的整数
    std::vector<int> numbers(it, end);

    // 输出结果
    std::cout << "Numbers entered: ";
    std::copy(numbers.begin(), numbers.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

在这个例子中，std::istream_iterator 用于从标准输入流中读取整数，然后使用 std::vector 存储这些整数，最终输出结果为用户输入的整数序列。

C++ std::ostream_iterator 详解

std::ostream_iterator 是 C++ 标准库中 <iterator> 头文件中定义的一个模板类，用于创建一个输出迭代器，该迭代器将数据写入输出流。

这个模板类的声明如下：

template< class T, class CharT = char, class Traits = std::char_traits<CharT> >
class ostream_iterator;

T 是迭代器指向的元素类型。
CharT 是字符类型，默认为 char。
Traits 是字符特性，用于处理字符操作，默认为 std::char_traits<CharT>。

std::ostream_iterator 的对象通过输出流（如 std::cout）进行初始化，并通过 operator++ 和 operator* 来将数据写入输出流。

以下是一个简单的例子，演示了 std::ostream_iterator 的使用：

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

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

    // 使用 std::ostream_iterator 将整数输出到标准输出流
    std::ostream_iterator<int> outputIterator(std::cout, " ");

    // 使用 std::copy 将 vector 中的整数写入到输出流
    std::copy(numbers.begin(), numbers.end(), outputIterator);

    std::cout << std::endl;

    return 0;
}

在这个例子中，std::ostream_iterator 用于将整数输出到标准输出流，并通过 std::copy 将 numbers 容器中的整数写入到输出流。最终输出结果为 1 2 3 4 5。

C++ std::begin()函数详解

std::begin() 是 C++ 标准库中 <iterator> 头文件中定义的一个函数模板，用于获取容器的起始迭代器。

这个函数模板的声明如下：

template< class Container >
constexpr auto begin( const Container& cont ) -> decltype(cont.begin());

Container 是容器类型。

std::begin() 接受一个容器作为参数，返回该容器的起始迭代器。它是用于支持范围迭代的标准库函数。

以下是一个简单的例子，演示了 std::begin() 的使用：

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

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

    // 使用 std::begin() 获取 vector 的起始迭代器
    auto it = std::begin(numbers);

    // 输出结果
    std::cout << "First element of the vector: " << *it << std::endl;

    return 0;
}

在这个例子中，std::begin() 用于获取 numbers 容器的起始迭代器，然后通过迭代器 it 输出 vector 的第一个元素。最终输出结果为 First element of the vector: 1。

C++ std::end()函数详解

std::end() 是 C++ 标准库中 <iterator> 头文件中定义的一个函数模板，用于获取容器的结束迭代器。

这个函数模板的声明如下：

template< class Container >
constexpr auto end( const Container& cont ) -> decltype(cont.end());

Container 是容器类型。

std::end() 接受一个容器作为参数，返回该容器的结束迭代器。它是用于支持范围迭代的标准库函数。

以下是一个简单的例子，演示了 std::end() 的使用：

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

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

    // 使用 std::end() 获取 vector 的结束迭代器
    auto it = std::end(numbers);

    // 输出结果
    std::cout << "Iterator pointing beyond the last element: " << *it << std::endl;

    return 0;
}

在这个例子中，std::end() 用于获取 numbers 容器的结束迭代器，然后通过迭代器 it 输出 vector 结束位置的元素（由于 it 指向容器的结束位置，解引用操作是未定义行为，这里只是演示目的）。最终输出结果为 “Iterator pointing beyond the last element”。

简介

C++ 是什么

1. 迭代器标签

2. 迭代器类别

3. 迭代器操作

4. 插入迭代器

5. 流迭代器

6. 其他

C++ 详解

1. 迭代器标签

2. 迭代器类别

3. 迭代器操作

4. 插入迭代器

5. 流迭代器

6. std::begin 和 std::end

示例

C++ std::prev()函数 详解

C++ std::advance()函数 详解

C++ std::distance()函数 详解

C++ std::back_inserter 详解

C++ std::front_inserter 详解

C++ std::inserter 详解

C++ std::istream_iterator 详解

C++ std::ostream_iterator 详解

C++ std::begin()函数 详解

C++ std::end()函数 详解

最近更新

标签排行

6. `std::begin` 和 `std::end`

C++ std::prev()函数详解

C++ std::advance()函数详解

C++ std::distance()函数详解

C++ std::begin()函数详解

C++ std::end()函数详解