Use boost::transform_iterator with a non-const functor

Question

I want to use a transform_iterator to make a delta transformation on a range. By delta transformation I mean that r₀ should stay the same and the subsequent elements, r_i, are mapped to (r_i - r_{i - 1}).

My problem is that as far as I can tell a transform_iterator needs a const functor, but my functor needs to remember the previous value. How can I solve this? Should I just write my own iterator?

The reason I want it as an iterator is that in the next step I want to make a range adaptor from it.

EDIT: It seems transform_iterator does allow non-const functors and that it was really my range adaptor that complained about the lack of constness. I'll keep the question open since the discussion about how appropriate it is to use transform_iterator anyway seems interesting.

partial_sum is good advice! I am doing this partly to learn how to make range adaptors, though. Also an iterator is lazy, which an algorithm is not. I can't iterate over an infinite series of deltas until some condition (say first non-zero delta) with partial_sum. — Gurgeh, Oct 10 '12 at 14:24
Actually, I think I meant [`std::adjacent_difference`](http://en.cppreference.com/w/cpp/algorithm/adjacent_difference). By the sounds of it though, you probably need [`std::find_if`](http://en.cppreference.com/w/cpp/algorithm/find) with an accumulating predicate object. — Peter Wood, Oct 11 '12 at 07:21

Vaughn Cato · Accepted Answer · 2014-02-23T17:05:00.260

I don't think you can have this work completely correctly with boost::transform_iterator. This is a simple implementation that seems like it might work at first, but doesn't really work well:

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

To really make this work, you need to know when the iterator is advanced, so I think you'll need your own iterator.

Yes you are right. This is even more obvious when you do your own iterator with iterator_facade, since dereference is const and increment is not. — Gurgeh, Oct 10 '12 at 14:30

pmr · Answer 2 · 2012-10-10T14:04:42.627

This seems to work fine for me, even when I use a pointer to remember the previous value (which might or might not be a good idea in your case).

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

It wont work with a lambda though, even if you use decltype, because a stateful lambda has to be marked mutable and you cannot hide the side effect as you can with a mutable member.

Use boost::transform_iterator with a non-const functor

2 Answers2

Linked