3d vectors - transform and minus - c++

Question

Can std::transform be used in a nested way? Tried to do this:
{
return std::transform(asciivec(inner.front()).begin(), asciivec(inner.front()).end(), asciivec(inner.back()).begin(), asciivec(inner.back()).end(),out.begin(), std::minus<float>{});
}
);
Error:
stl_algo.h||In instantiation of '_OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation) [with _IIter = __gnu_cxx::__normal_iterator<const std::vector<std::__cxx11::basic_string<char> >*, std::vector<std::vector<std::__cxx11::basic_string<char> > > >; _OIter = __gnu_cxx::__normal_iterator<double*, std::vector<double> >; _UnaryOperation = main()::<lambda(const auto:1&)>]':|
error: no matching function for call to 'transform(std::vector<double>::iterator, std::vector<double>::iterator, std::vector<double>::iterator, std::vector<double>::iterator, std::vector<double>::iterator, std::minus<float>)'|

Answer 1

You were on the right track, but you missed a few things.
For binary operations, std::transform only takes both begin and end iterators for the first input range; it takes a begin iterator for the second range, and assumes the second range is at least as large as the first (such that for any element in the range [first1, last1), there's a matching element in the range starting at first2).
Assuming that asciivec() returns a temporary object (and not a reference to a cached object), the iterators asciivec(inner.front()).begin() and asciivec(inner.front()).end() will actually refer to two different ranges; this will cause runtime errors. You'll need to cache the results of your asciivec() calls inside the lambda, to give them enough permanence to finish the operation.
std::minus evaluates its operands as lhs - rhs, and thus will return -1 for std::minus<float>{}('a', 'b'). As your example results are positive, I have assumed you want absolute values, and have expanded & commentated my code thusly.
So, considering that, we can make a few slight alterations...
// Renamed "inner" to "in" for convenience here.
std::transform (inp.cbegin(), inp.cend(), out.begin(), [&](const auto& in)
{
// Tying element type to asciivec() for convenience.
using Container = decltype(asciivec(in.front()));
using Elem = typename Container::value_type;
//using Elem = typename decltype(asciivec(in.front()))::value_type;
// Create non-temporary vectors first, to guarantee expected results.
std::vector<Container> inner = { asciivec(in.front()), asciivec(in.back()) };
// Use either...
// static Container ret;
// ret.clear(); ret.resize(inner.front().size());
// Or...
Container ret(inner.front().size());
std::transform(inner.front().begin(), // InputIt first1
inner.front().end(), // InputIt last1
inner.back().begin(), // InputIt first2
//asciivec(inner.back()).end(), // Omit
ret.begin(), // OutputIt d_first
std::minus<float>{}); // BinaryOperation binary_op
// I'm positive you want absolute values. ;3
// Lambda provides nice, clean overload resolution, compared to a function pointer or similar.
std::transform(ret.begin(), ret.end(), ret.begin(), [=](const Elem& e) { return std::fabs(e); });
return ret;
}
);
If signedness is, in fact, desired, we can comment out the second transform() call.
See it in action here.
Edited to increase genericity, it should be fine to just drop in regardless of your data's actual types.