lambda with templates

Question

I am currently doing some exercises with templated functions. I had the task to write a implementation of the transform algorithm. I did it like the following and it works:

template <class in, class out, class T>
out stransform(in b, in e, out d, T p(const T&)) {
    while (b != e) 
        *d++ = p(*b++);
    return d;
}

As with the normal transform I have to call the predicate with an explicit type like

stransform(begin(vec1), end(vec1), back_inserter(vec2), predi<double>);

Now, I stumbled upon the C++11 Lambdas and wanted to call my function like this:

stransform(begin(vec1), end(vec1), back_inserter(vec2), [] (double x) ->double {return x * 10;} );

With that I do get a compiler error that the type cant be deduced. This is the thing I dont understand as I am defining the T type in my lambda actually twice.

I did also check back the original transform function, with which it is working. I then checked the implementation of that one and it is obviously implemented with a template class for the whole function. Is that the correct way for implementing predicates with templates?

visitor · Accepted Answer · 2011-10-06 09:24:37Z

13

The predicate is normally a simple template argument:

template <class in, class out, class UnaryPredicate>
out stransform(in b, in e, out d, UnaryPredicate p);

This will accept pointers to function, lambdas and function objects.

answered Oct 6, 2011 at 9:24

visitor

1,80111 silver badges7 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

Christian Rau Over a year ago

@bamboon I guess because a lambda is no function but a function object, as it may also hold state (it's a closure and not just a function).

spraff Over a year ago

Note that a lambda which does not perform any capturing is convertible to an ordinary function (pointer).

Stack Overflow is garbage Over a year ago

@spraff: but that conversion is not implemented in MSVC2010, so depending on your compiler, it may not work. (what's more, the conversion is unnecessary and potentially inefficient)

visitor Over a year ago

So the type of the lambda is a class which is implicitly convertible to a function pointer? Such an implicit conversion wouldn't be considered in type deduction anyway.

David Rodríguez - dribeas Over a year ago

@visitor: The type of a lambda is an unknown class type that implements operator() for the defined parameters and returning the same return type. In the particular case of a lambda that does not capture anything (and only then) it is convertible to a function pointer with the same signature, but only if the lambda does not capture anything at all.

|

spraff · Accepted Answer · 2011-10-06 09:38:56Z

2

T p(const T&) is the type of a function which takes a T by reference. Your lambda takes its argument by value.

stransform (
    begin (vec1),
    end (vec1),
    back_inserter (vec2),
    [] (const double & x) -> double {
        return x * 10;
    });

This should work. A lambda which does not perform any capturing is convertible to an ordinary function.

answered Oct 6, 2011 at 9:38

spraff

33.7k27 gold badges137 silver badges258 bronze badges

3 Comments

Stack Overflow is garbage Over a year ago

but why rely on an unnecessary conversion to function pointer, when you could just redefine the functor to work with functors as well as function pointers?

spraff Over a year ago

@jalf Redefining the functor is a better solution, I agree. If this problem arose with immutable library code then conversion can work.

David Rodríguez - dribeas Over a year ago

@spraff: Even if the type is convertible, by using it in a template, the compiler must deduce the T, and at that stage I don't think that it can apply any conversions (unless the type of the lambda is a function itself, not a functor, in the case where there are no captures).

Luc Danton · Accepted Answer · 2011-10-06 10:49:00Z

it is obviously implemented with a template class for the whole function

Slight aside for proper terminology: std::transform is a function template, not a function. More importantly, in a declaration of the style

template<class InputIterator, class OutputIterator, class Functor>
OutputIterator
transform(InputIterator begin, InputIterator end, OutputIterator out, Functor f);

the template parameters InputIterator, OutputIterator and Functor are not required to be class types. Consider this example:

// function declaration
int increment(int);

int array[] = { 0, 1, 2, 3, 4 };
transform(std::begin(array), std::end(array), std::begin(array), increment);

Then InputIterator and OutputIterator are deduced to be int* and Functor is int(*)(int), none of which is a class type -- much less a template class, but I digress. And in fact, transform could just as well be declared

template<typename InputIterator, typename OutputIterator, typename Functor>
OutputIterator
transform(InputIterator begin, InputIterator end, OutputIterator out, Functor f);

where the keyword typename is a bit more clear on the nature of the template parameters: they're types, of any nature.

Collectives™ on Stack Overflow

lambda with templates

3 Answers 3

7 Comments

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

7 Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related