2

是否有像 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::

4

3 回答 3

4

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

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

你所要求的将是微不足道的，只是在我看来没有那么有用。要么控制迭代器在循环中的更新方式（如上面的代码），要么迭代器本身几乎没有用处。你想从迭代器中得到什么？

于 2013-02-04T19:34:05.827 回答
3

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

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
              });

或者使用手动循环。

于 2013-02-04T19:34:58.723 回答
1

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

#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-loop 更有帮助，但你必须有你的理由......

于 2013-02-04T19:41:57.650 回答