4

我想使用 transform_iterator 在范围上进行增量转换。通过增量转换，我的意思是 r 0应该保持不变，并且后续元素 r i被映射到 (r i - r i - 1 )。

我的问题是，据我所知，transform_iterator 需要一个 const 仿函数，但我的仿函数需要记住以前的值。我该如何解决这个问题？我应该只写自己的迭代器吗？

我想要它作为迭代器的原因是在下一步中我想从中制作一个范围适配器。

编辑：似乎 transform_iterator 确实允许非常量函子，而且确实是我的范围适配器抱怨缺乏常量性。我将保持问题的开放性，因为关于使用 transform_iterator 的适当性的讨论似乎很有趣。

4

2 回答 2

4

我不认为你可以用 boost::transform_iterator 完全正确地完成这项工作。这是一个简单的实现，一开始似乎可以工作，但实际上效果不佳：

#include <boost/iterator/transform_iterator.hpp>
#include <vector>
#include <iostream>

using std::cout;

struct Delta {
  Delta() : prev_value(0) { }

  int operator()(int value) const
  {
    int result = value-prev_value;
    prev_value = value;
    return result;
  }

  mutable int prev_value;
};

int main(int,char**)
{
  typedef std::vector<int> Items;
  typedef boost::transform_iterator<Delta,Items::iterator,int> Iter;

  Items items;
  items.push_back(4);
  items.push_back(3);
  items.push_back(8);
  { // prints 4 -1 5  -- excellent
    Iter i(items.begin(),Delta()), end(items.end(),Delta());
    for (;i!=end;++i) {
      cout << *i << " ";
    }
    cout << "\n";
  } 
  { // prints 4 0 -- crap
    Iter i(items.begin(),Delta());
    cout << *i << " ";
    cout << *i << "\n";
  }
  return 0;
}

要真正完成这项工作，您需要知道迭代器何时先进，所以我认为您需要自己的迭代器。

于 2012-10-10T13:45:29.363 回答
4

这对我来说似乎工作得很好，即使我使用指针来记住以前的值（在你的情况下这可能是一个好主意，也可能不是一个好主意）。

#include <algorithm>
#include <iostream>
#include <vector>
#include <boost/iterator/transform_iterator.hpp>

class delta {
public:
  typedef int result_type;

  int operator()(const int& i) const {
    if(prev) {
      const int* tmp = prev;
      prev = &i;
      return i - *tmp;
    } else {
      prev = &i;
      return i;
    }
  }
private:
  mutable const int* prev = nullptr;
};

int main()
{
  std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  std::for_each(boost::make_transform_iterator(begin(v), delta()), 
                boost::make_transform_iterator(end(v), delta()),
                [](int i) { std::cout << i << std::endl; });

  return 0;
}

但是，即使您使用 decltype，它也不适用于 lambda，因为有状态的 lambda 必须标记为可变的，并且您不能像使用可变成员那样隐藏副作用。

于 2012-10-10T13:58:29.133 回答