掘根宝典之C++迭代器简介

简介

迭代器是一种用于遍历容器元素的对象。它提供了一种统一的访问方式，使程序员可以对容器中的元素进行逐个访问和操作，而不需要了解容器的内部实现细节。

C++标准库里每个容器都定义了迭代器

迭代器的作用类似于指针，可以指向容器中的某个元素，并通过操作迭代器来访问和操作该元素。通过迭代器，我们可以实现对容器的遍历、查找、修改等操作，大大增强了程序的灵活性和通用性。

声明迭代器

有迭代器的容器类型使用iterator和const_iterator类型来表示迭代器的类型

我们可以看个例子

vector<int>::iterator it1;
//it1能读取和修改vector<int>的元素string::iterator it2;
//it2能读取和修改string的元素vector<int>::const_iterator it3;
//it3能读取vector<int>的元素，不能修改string的元素string::const_iterator it4;
//it4能读取string的元素，不能修改string的元素

const_iterator的对象和常量指针差不多，能读取但是不能修改它所指元素的值。相反，iterator的对象可读可写。

如果vector和string对象是个常量，只能使用const_iterator;

如果vector和string对象不是常量，则既可以使用iterator也可以使用const_iterator

begin成员和end成员 

begin和end 操作生成指向容器中第一个元素和尾元素之后位置的迭代器。

这两个迭代器最常见的用途是形成一个包含容器中所有元素的迭代器范围。

begin和end有多个版本：带r的版本返回反向迭代器；以c开头的版本则返回const迭代器：

list<string> a ={"Milton", "Shakespeare", "Austen"};
auto itl = a.begin(); // list<string>::iterator
auto it2 = a.rbegin(); // list<string>::reverse iterator
auto it3 = a.cbegin(); // list<string>::const iterator
auto it4 = a.crbegin();// list<string>::const reverse iterator

不以c开头的函数都是被重载过的。

也就是说，实际上有两个名为begin的成员。

一个是const成员，返回容器的const iterator类型。

另一个是非常量成员，返回容器的iterator类型。r

begin、end和rend的情况类似。当我们对一个非常量对象调用这些成员时，得到的是返回iterator的版本。只有在对一个const对象调用这些函数时，才会得到一个const版本。

与const指针和引用类似可以将一个普通的iterator转换为对应的const_iterator，但反之不行。

以c开头的版本是C++新标准引入的，用以支持auto与begin和end函数结合使用。过去，没有其他选择，只能显式声明希望使用哪种类型的迭代器：
//显式指定类型
list<string>::iterator it5 = a.begin()；

在C++中，容器的end()函数返回一个迭代器，指向容器中的最后一个元素的下一个位置。而begin()函数返回一个迭代器，指向容器中的第一个元素的位置。

在使用迭代器遍历容器时，通常会将begin()函数返回的迭代器作为起始位置，将end()函数返回的迭代器作为结束位置。遍历过程中，迭代器会从起始位置逐个前进到结束位置，直到到达结束位置为止。

例如，对于一个vector<int>容器，可以使用迭代器来遍历其中的元素：

vector<int> vec = {1, 2, 3, 4, 5};for (auto it = vec.begin(); it != vec.end(); ++it) {cout << *it << " ";
}
cout << endl;

在这个例子中，vec.begin()返回一个迭代器，指向第一个元素1的位置，vec.end()返回一个迭代器，指向最后一个元素5的下一个位置。循环中，首先将迭代器从起始位置1依次移动到2、3、4、5，最后到达结束位置，输出结果为

1 2 3 4 5

需要注意的是，end()函数返回的迭代器实际上指向了容器的末尾，并不指向容器中的最后一个元素。这是一个常见的迭代器设计约定。

begin和end运算符的返回类型

begin和end运算符的返回类型取决于调用它的这个对象是否是常量

如果对象是常量，begin和end返回const_iterator，如果对象不是常量，begin和end返回iterator

vector<int> a;
const vector<int> cv;
auto it1=v.begin();
auto it2=cv.begin();

我们可以看到it1的类型是vector<int>::iterator，it2的类型是vector<int>::const_iterator 

cbegin()和cend()函数——常量迭代器

为了便于专门得到const_iterator类型的返回值，C++11引入了两个新函数：cbegin()和cend()函数，

我们看看

vector<int> v;
auto it3=v.cbegin();

可以看到啊，it3是const_iterator类型 

我们来详细介绍一下它们两个

在C++中，容器类提供了两个函数，即cbegin()和cend()函数，用于获取一个常量迭代器的起始和结束位置。

1. cbegin()函数返回一个指向容器中第一个元素的常量迭代器。这个迭代器只能用于读取元素的值，不能修改容器的内容。如果容器为空，cbegin()函数将返回一个指向末尾的常量迭代器。

2. cend()函数返回一个指向容器中最后一个元素之后位置的常量迭代器。这个迭代器只能用于判断循环结束的条件，不能访问迭代器指向的元素的值。

这两个函数适用于所有标准容器，如vector、list、set等，并且它们返回的迭代器类型都是const_iterator。

常见的用法是在for循环中使用cbegin()和cend()函数来遍历容器中的元素，例如：

std::vector<int> vec = {1, 2, 3, 4, 5};for (auto it = vec.cbegin(); it != vec.cend(); ++it) {std::cout << *it << " ";
}

注意：在使用cbegin()和cend()函数获取到的常量迭代器时，不能通过迭代器修改容器的值，只能读取元素的值。如果需要修改容器的值，需要使用普通迭代器，而不是常量迭代器。

使用迭代器

在C++中，可以使用迭代器来遍历容器中的元素。以下是使用迭代器的一般步骤：

1. 定义一个迭代器变量，将其初始化为容器的起始位置。例如：

   vector<int> vec = {1, 2, 3, 4, 5};
   vector<int>::iterator it = vec.begin();
   

2. 使用迭代器来访问容器中的元素。可以使用解引用操作符*来获取迭代器指向的元素值。例如：

   cout << *it << endl;  // 输出第一个元素的值
   

3. 可以使用++操作符将迭代器前进到容器的下一个元素。例如：

   ++it;  // 前进到下一个元素
   

4. 可以使用循环结构（如while、for）和条件判断来遍历整个容器。例如：

   for (vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {cout << *it << " ";
   }
   cout << endl;
   

   或者使用基于范围的for 循环：

   for (int element : vec) {cout << element << " ";
   }
   cout << endl;
   

在使用迭代器遍历容器时，需要注意以下几点：

• 使用迭代器需要包含头文件<iterator>。
• 复制容器的迭代器可以使两个迭代器指向相同的位置。
• 不能在迭代器失效的情况下使用迭代器，例如在插入或删除元素后。

迭代器运算符 

在C++中，迭代器提供了一些运算符来对迭代器进行操作和访问容器中的元素。以下是常用的迭代器运算符：

1. 解引用运算符(*)：用于获取迭代器指向位置的元素值。例如，*it 表示获取迭代器 it 指向位置的元素值。

2. 自增运算符(++)：用于将迭代器向前移动一个位置。例如，++it表示将迭代器 it 向前移动一个位置。

3. 自减运算符(--)：用于将迭代器向后移动一个位置。例如，--it表示将迭代器 it 向后移动一个位置。

4. 箭头运算符(->)：用于获取迭代器指向位置的成员变量或成员函数。例如，it->member 表示获取迭代器 it 指向位置的成员变量或成员函数。

5. 等于运算符(==)和不等于运算符(!=)：用于比较两个迭代器是否指向同一个位置。例如，it1 == it2 表示判断迭代器 it1 和 it2 是否指向同一个位置。

6. 大于运算符(>)、小于运算符(<)、大于等于运算符(>=)和小于等于运算符(<=)：用于比较两个迭代器指向位置的相对顺序。例如，it1 > it2 表示迭代器 it1 指向位置在迭代器 it2 指向位置之后。

需要注意的是，不是所有运算符对所有类型的迭代器都可用。有些运算符只适用于双向迭代器或随机访问迭代器，而不适用于单向迭代器。

迭代器的算术运算

在C++中，一些迭代器支持算术运算符，这些运算符可以用于在迭代器上进行加法和减法操作。这些运算符包括：

1. 加法运算符(+)：用于将迭代器向前移动指定的步数。例如，it + n 表示将迭代器 it 向前移动 n 个位置。

2. 减法运算符(-)：用于将迭代器向后移动指定的步数，或者计算两个迭代器之间的距离。例如，it - n 表示将迭代器 it 向后移动 n 个位置，it1 - it2 表示计算迭代器 it1 和 it2 之间的距离。

需要注意的是，不是所有类型的迭代器都支持算术运算符。只有随机访问迭代器支持算术运算符，而单向迭代器和双向迭代器不支持算术运算符。在使用算术运算符之前，应该确保迭代器的类型是随机访问迭代器。

此外，还有一些其他的运算符可以与迭代器一起使用，如赋值运算符(=)、复合赋值运算符(+=、-=)等。这些运算符可以用于更新迭代器的位置或将一个迭代器赋值给另一个迭代器。

需要注意的是，在进行算术运算时，应该确保迭代器不超出容器的边界。否则，可能会导致未定义的行为或错误。在使用迭代器进行算术运算时，应该始终谨慎处理边界情况，并确保迭代器始终指向有效的位置。

插入迭代器

如果有一个容器，我们预先不知道它的长度，如果要把元素添加到这个容器中，而不是覆盖已有内容，那该怎么办呢？接下来就要使用到插入迭代器了。这三者都需要头文件<iterator>

back_insert_iterator

back_insert_iterator是一个插入迭代器适配器，用于在容器的末尾插入元素。它的用法如下：

1. 创建back_insert_iterator对象并绑定到容器：

std::back_insert_iterator<std::vector<int>> backIt(vec);

这里我们创建了一个back_insert_iterator对象backIt，并将它绑定到一个std::vector<int>容器vec上。通过这个back_insert_iterator对象，我们可以向vec插入元素。

1. 使用插入迭代器插入元素：

*backIt = 6;
backIt++;
*backIt = 7;
backIt++;
*backIt = 8;

我们可以通过解引用操作符*来访问插入迭代器对应的容器，并将值赋给它。然后，使用递增操作符++来移动插入迭代器的位置。这样，我们就可以在容器的末尾依次插入元素。

1. 使用实例：

std::vector<int> vec;
std::back_insert_iterator<std::vector<int>> backIt(vec);*backIt = 1;    // 插入元素1
backIt++;
*backIt = 2;    // 插入元素2
backIt++;
*backIt = 3;    // 插入元素3// 另一种更简洁的写法
std::vector<int> vec2;
std::back_insert_iterator<std::vector<int>> backIt2(vec2);std::fill_n(backIt2, 5, 42);   // 在vec2末尾插入5个值为42的元素

需要注意的是，back_insert_iterator是一个输出迭代器，只能用于写入操作，不能用于读取元素。

此外，它只能用于支持push_back操作的容器，比如std::vector和std::list等。

insert_iterator

insert_iterator是STL中的一个插入迭代器适配器，用于在容器的任意位置插入元素。它的用法如下：

1. 创建insert_iterator对象并绑定到容器以及插入位置：

std::insert_iterator<std::vector<int>> insertIt(vec, vec.begin());

这里我们创建了一个insert_iterator对象insertIt，并将它绑定到一个std::vector<int>容器vec上，同时指定插入位置为vec.begin()。通过这个insert_iterator对象，我们可以在指定位置插入元素。

1. 使用插入迭代器插入元素：

*insertIt = 6;
insertIt++;
*insertIt = 7;
insertIt++;
*insertIt = 8;

我们可以通过解引用操作符*来访问插入迭代器对应的容器，并将值赋给它。然后，使用递增操作符++来移动插入迭代器的位置。这样，我们就可以在指定位置插入元素。

1. 使用实例：

std::vector<int> vec;
std::insert_iterator<std::vector<int>> insertIt(vec, vec.begin());*insertIt = 1;    // 在vec的开始位置插入元素1
insertIt++;
*insertIt = 2;    // 在vec的第二个位置插入元素2
insertIt++;
*insertIt = 3;    // 在vec的第三个位置插入元素3// 另一种更简洁的写法
std::vector<int> vec2;
std::insert_iterator<std::vector<int>> insertIt2(vec2, vec2.begin());std::fill_n(insertIt2, 5, 42);   // 在vec2的开始位置插入5个值为42的元素

需要注意的是，insert_iterator是一个输出迭代器，只能用于写入操作，不能用于读取元素。此外，它可以用于支持insert操作的容器，比如std::vector和std::list等。

front_insert_iterator

front_insert_iterator是一个迭代器适配器，可以用于在容器的前端插入元素。它是C++标准库的一部分，可以用于修改向量、列表和双端队列等容器。

要使用front_insert_iterator，需要包含<iterator>头文件：

#include <iostream>
#include <iterator>
#include <vector>int main() {std::vector<int> myVector;std::front_insert_iterator<std::vector<int>> frontIt(myVector);*frontIt = 1;  // 在向量的前端插入1frontIt++;    // 迭代器前进// 或者，可以直接使用insert函数插入元素frontIt = std::insert_iterator<std::vector<int>>(myVector, myVector.begin(), 2);// 打印向量for (const auto& element : myVector) {std::cout << element << " ";}std::cout << std::endl;return 0;
}

在这个例子中，我们创建了一个名为myVector的std::vector<int>向量，以及一个名为frontIt的front_insert_iterator迭代器。我们使用frontIt迭代器向向量中插入元素。

*frontIt = 1语句在向量的前端插入值1。frontIt++语句将迭代器前进到下一个位置。

另外，你也可以使用insert_iterator(container, iterator, value)的语法，其中container是要修改的容器，iterator是要插入值的位置，value是要插入的值。

在代码中的frontIt = std::insert_iterator<std::vector<int>>(myVector, myVector.begin(), 2)一行中演示了这种用法。

最后，我们打印出向量的元素，以验证结果。输出将是：

2 1

这表明通过front_insert_iterator成功地在向量的前端插入了元素。