Passing output of c++ transform to a function - c++

Question

I'm sorry if this is a stupid question but I'm a bit of a c++ noob and I haven't been able to find the answer. I'm working with boost multi_array, and I'm trying to do something like this:
typedef boost::multi_array<double,2> array2D;
typedef array2D::array_view<1>::type array2Drow;
typedef boost::multi_array_types::index_range range;
...
array2D A = ... (2-d array) ...;
array2Drow X = A(boost::indices[0][range()]);
...
returnVal1 = f(X);
returnVal2 = f(X+0.1*X);
returnVal3 = f(X-0.1*X);
I was trying to use std::transform for this; I understand I can write some sort of functor (call it "op") that multiplies X by 0.1 and adds/subtracts the result from X, but this is where I run into trouble--I don't know what to put in place of the ???:
returnVal1 = f(X);
returnVal2 = f(transform(X.begin(),X.end(),???,op(0.1,X)));
returnVal3 = f(transform(X.begin(),X.end(),???,op(-0.1,X)));
Is there a way to do this without defining an intermediate object that then gets passed to f? Thanks in advance!

Answer 1

If your function f takes a container, then you will have to create a container with the transformed values. In your example you seem to also expect that X remains unchanged by the first transformation, so you you cannot just modify it inplace
returnVal1 = f( X );
transform( X.begin(), X.end(), X.begin(),
[]( double val ){ return val + 0.1*val; } );
returnVal2 = f( X );
If you don't want to create explicit local temporaries then you can construct them using a helper function.
// pass in by value to get a copy, modify it inplace and return it
array2Drow transformed( array2Drow copy, double factor )
{
std::transform( copy.begin(), copy.end(), copy.begin(),
[&]( double val ){ return val + factor*val; } ) );
return copy;
}
The calculation of the return values can then be written using the helper.
returnVal1 = f( X );
returnVal2 = f( transformed( X, 0.1 ) );
returnVal3 = f( transformed( X, -0.1 ) );

Answer 2

The ??? needs to be an iterator for a container where you want to store the result of the transform operation, i.e. the return value of op
However, your idea is wrong.
std::transform returns (see http://en.cppreference.com/w/cpp/algorithm/transform)
Return value
Output iterator to the element past the last element transformed.
It makes no sense to pass that iterator to a function as it is end of the container.
Further, the signature of op doesn't fulfil the requirements for std::transform.

Answer 3

If f expects to receive a array2Drow, then you need to pass it one (containing the correct data).
With that given, you really only have a couple of choices: either modify the data in the existing collection (and repeatedly pass the same collection), or else create a new collection each time you invoke it.
If f really only needs one of the items at a time (e.g., like an accumulator), then you may be able to rewrite f to only take one input at a time, then at the end of each "run", retrieve the value and reset the accumulator.
In that case, you can probably create an iterator type that will invoke the accumulator for each item as its created, and pass an instance of that accumulator to std::transform as the destination where the result should be written.
For reference, you may want to look at Boost Accumulators.