C++之STL的algorithm（9）advance和prev（移动迭代器）算法整理

C++之STL的algorithm（9）之移动迭代器advance和prev算法整理

注：整理一些突然学到的C++知识，随时mark一下
例如：忘记的关键字用法，新关键字，新数据结构

---

---

提示：本文为 C++ 中advance、prev的写法和举例

---

一、 advance移动迭代器

  std::advance 是 C++ 标准库中的一个用于移动迭代器指定的次数的算法，它能指定移动步长。当你想要移动一个迭代器，而不是通过多次递增或递减它时，当容器不适用随机访问迭代器时候，这对于基于范围的 for循环或其他不需要手动迭代的情况特别有用。尤其是对于不支持简单算术操作的迭代器类型（如双向链表list或关联容器map、set的迭代器）。

这个函数有两个参数：要移动的迭代器和一个整数，表示要移动的次数。如果是正数，迭代器会向前移动；如果是负数，迭代器会向后移动。
请注意，尽管在随机访问迭代器上可以使用it = it + 2这样的操作，但使用std::advance可以提供更通用和一致的行为，因为它可以处理所有类型的迭代器，包括那些不支持简单算术运算的迭代器。因此，在编写可移植和健壮的代码时，通常推荐使用std::advance。对于std::prev，它提供了一种简洁的方法来获取指向容器中当前元素之前元素的迭代器。

std::advance 和prev语法格式

std::advance 用于将迭代器向前或向后移动指定的次数。（负数就向前，这时相当于prev算法）
std::prev 用于返回指向容器中当前迭代器位置向前1个或几个元素的迭代器。

template<class InputIterator, class Distance>  
void advance(InputIterator& it, Distance n);
InputIterator：迭代器类型，通常是容器的迭代器。
Distance：要移动的次数，可以是正数（向前移动）或负数（向后移动）。
it：要移动的迭代器引用。

1、移动vector的迭代器

对于 std::vector，由于它是连续内存存储的，std::advance 的操作通常是非常高效的，因为它可以通过简单的指针算术来移动迭代器。

下面是一些使用 std::advance 来移动不同容器迭代器的例子：

std::vector 示例

#include <iostream>  
#include <vector>  
#include <iterator>  
  
int main() {  
    std::vector<int> vec = {1, 2, 3, 4, 5};  
    std::vector<int>::iterator it = vec.begin();  
    std::advance(it, 3); // 移动到第4个元素  
    std::cout << *it << std::endl; // 输出: 4  
    return 0;  
}

2、移动list

下面是一个简单的例子，展示了如何使用 std::advance 来移动 std::list 的迭代器：

#include <iostream>  
#include <list>  
#include <iterator>  
  
int main() {  
    std::list<int> myList = {1, 2, 3, 4, 5};  
  
    // 获取指向列表开始的迭代器  
    std::list<int>::iterator it = myList.begin();  
  
    // 使用 std::advance 向前移动迭代器 3 次  
    std::advance(it, 3);  
  
    // 此时，it 指向第 4 个元素（值为 4）  
    std::cout << "The element at the current position is: " << *it << std::endl; // 输出: 4  
  
    // 使用 std::advance 向后移动迭代器 2 次（注意这会导致迭代器回退）  
    std::advance(it, -2);  
  
    // 此时，it 再次指向第 3 个元素（值为 3）  
    std::cout << "The element at the current position after going back is: " << *it << std::endl; // 输出: 3  
  
    return 0;  
}

在上面的例子中，我们首先创建了一个包含整数的 std::list。然后，我们获取了一个指向列表开始的迭代器，并使用 std::advance 向前移动了 3 次，这样迭代器就指向了第 4 个元素。接着，我们又使用 std::advance 向后移动了 2 次，迭代器回退到了第 3 个元素。

需要注意的是，当使用 std::advance 时，必须确保移动后的迭代器仍然有效。例如，向前移动一个已经指向容器末尾的迭代器是未定义行为。同样，向后移动一个已经指向容器开头的迭代器也是未定义行为。因此，在使用 std::advance 时，应确保移动次数不会导致迭代器超出容器的有效范围。

是的，std::advance 算法可以移动 std::vector、std::map、std::set（以及其它标准模板库中的容器）的迭代器。这些容器都提供了迭代器，它们支持前向迭代（至少），这意味着你可以递增它们来访问容器中的元素。

3、移动map和set的迭代器

对于 std::map 和 std::set，这些容器是基于红黑树实现的，不能使用随机访问迭代器的it=it+n的形式访问，而 std::advance 会沿着树的路径来移动迭代器。虽然这不是简单的指针算术，但它仍然是一个有效的操作。

std::map 示例

#include <iostream>  
#include <map>  
#include <iterator>  
  
int main() {  
    std::map<std::string, int> myMap = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};  
    std::map<std::string, int>::iterator it = myMap.begin();  
    std::advance(it, 1); // 移动到第二个元素  
    std::cout << it->first << ": " << it->second << std::endl; // 输出: banana: 2  
    return 0;  
}

std::set 示例

#include <iostream>  
#include <set>  
#include <iterator>  
  
int main() {  
    std::set<int> mySet = {1, 2, 3, 4, 5};  
    std::set<int>::iterator it = mySet.begin();  
    std::advance(it, 2); // 移动到第三个元素  
    std::cout << *it << std::endl; // 输出: 3  
    return 0;  
}

在这些例子中，std::advance 被用来向前移动迭代器到容器的不同位置。同样地，你也可以使用负数来向后移动迭代器，只要确保迭代器不会移动到容器的开始之前的位置。

需要注意的是，虽然 std::advance 对于大多数容器都有效，但在某些情况下，如果你需要频繁地移动迭代器，尤其是进行大量的随机访问，使用 std::vector 通常会比使用基于树的容器（如 std::map 和 std::set）更加高效，因为 std::vector 提供了连续的内存，可以通过简单的指针算术来进行高效的访问。

二、prev算法移动迭代器

std::prev 是advance的相反操作。
std::prev 用于返回指向容器中当前迭代器位置前几个元素的迭代器，是向前移动（it--）。

template<class BidirectionalIterator>  
BidirectionalIterator prev(BidirectionalIterator it);  
  
template<class BidirectionalIterator, class Distance>  
BidirectionalIterator prev(BidirectionalIterator it, Distance n);

第一个版本返回当前迭代器it所指向元素的前一个元素的迭代器。
第二个版本返回当前迭代器it所指向元素前n个位置的迭代器。

BidirectionalIterator：双向迭代器类型，因为std::prev需要能够向前和向后移动。
Distance：要向后移动的次数（可选参数）。
it：要操作的迭代器。
示例
下面是使用std::advance和std::prev的示例：

#include <iostream>  
#include <vector>  
#include <list>  
#include <iterator>  
  
int main() {  
    // 示例：使用std::vector（随机访问迭代器）  
    std::vector<int> vec = {1, 2, 3, 4, 5};  
    std::vector<int>::iterator it = vec.begin();  
    std::advance(it, 2); // it现在指向第3个元素（值为3）  
    std::cout << *it << std::endl; // 输出: 3  
  
    // 使用std::prev回到前一个元素  
    it = std::prev(it); // it现在指向第2个元素（值为2）  
    std::cout << *it << std::endl; // 输出: 2  
  
    // 示例：使用std::list（双向迭代器）  
    std::list<int> lst = {1, 2, 3, 4, 5};  
    std::list<int>::iterator lit = lst.begin();  
    std::advance(lit, 2); // lit现在指向第3个元素（值为3）  
    std::cout << *lit << std::endl; // 输出: 3  
  
    // 使用std::prev回到前一个元素  
    lit = std::prev(lit); // lit现在指向第2个元素（值为2）  
    std::cout << *lit << std::endl; // 输出: 2  
  
    return 0;  
}

总结