Question

是否有像std :: for_each这样的函数直接传递迭代器而不是取消引用它们的结果？

我们拥有什么

std::vector<int> ints;
std::for_each(ints.begin(), ints.end(),
[](int i)
{
  //how to get the iterator of this element???
}

我在寻找什么

for_each_iterator(ints.begin(), ints.end(),
[](const std::vector<int>::const_iterator &i)
{
  //we know the iterator here
}

当然，编写这样的函数是相当简单的，但我想问是否存在来自std::，std::tr1::或boost::的标准解决方案

Answer 1

您正在查看错误的抽象级别。 for_each算法将函数应用于范围中的每个元素 。如果需要对迭代器进行操作，则应该展开循环：

for (auto it = ints.begin(); it != ints.end(); ++it ) {
   // do something
}

你要求的内容可以轻易实现，在我看来并不是那么有用。要么控制循环中迭代器的更新方式（如上面的代码所示），要么迭代器本身几乎没用。你想从迭代器中得到什么？

Answer 2

标准库中没有这样的东西。但是自己实现起来并不难：

template<typename It, typename Functor >
void iterate(It begin, It end, Functor && f)
{
    while ( begin != end ) { f(begin); ++begin; }
}

并将其用作：

iterate(ints.begin(), ints.end(), [](std::vector<int>::iterator it)
              {
                 //use it
              });

或使用手动循环。

Answer 3

我只能想到如何使用包装器进行迭代器，我想不出只使用标准算法的方法，所以你仍然需要编写一些辅助代码。例如：

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

template<typename T>
struct it_wrapper {
   it_wrapper(const T& t) : it(t) { }

   T operator*() const {
      return it;
   }

   it_wrapper& operator++() {
      ++it;
      return *this;
   }

   it_wrapper operator++(int) {
      it_wrapper old = *this;
      ++it;
      return old;
   }

   bool operator!=(const it_wrapper& rhs) {
      return it != rhs.it;
   }

   T it;
};

template<typename T>
it_wrapper<T> wrap(const T& t) {
   return it_wrapper<T>(t);
}

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

   std::for_each(wrap(v.begin()), wrap(v.end()), [](decltype(v.begin()) i) {
      std::cout << *i << '\n';
   });
}

打印

1

2

3

4

我不确定这比仅使用for循环更有帮助，但你必须有自己的理由......

std :: for_each等效，不取消引用迭代器

3 个答案: