Passing a lambda into a function template

by

Your function binsearch takes a function pointer as argument. A lambda and a function pointer are different types: a lambda may be considered as an instance of a struct implementing operator().

Note that stateless lambdas (lambdas that don’t capture any variable) are implicitly convertible to function pointer. Here the implicit conversion doesn’t work because of template substitution:

#include <iostream>

template <typename T>
void call_predicate(const T& v, void (*predicate)(T)) {
    std::cout << "template" << std::endl;
    predicate(v);
}

void call_predicate(const int& v, void (*predicate)(int)) {
    std::cout << "overload" << std::endl;
    predicate(v);
}

void foo(double v) {
    std::cout << v << std::endl;
}

int main() {
    // compiles and calls template function
    call_predicate(42.0, foo);

    // compiles and calls overload with implicit conversion
    call_predicate(42, [](int v){std::cout << v << std::endl;});

    // doesn't compile because template substitution fails
    //call_predicate(42.0, [](double v){std::cout << v << std::endl;});

    // compiles and calls template function through explicit instantiation
    call_predicate<double>(42.0, [](double v){std::cout << v << std::endl;});
}

You should make your function binsearch more generic, something like:

template <typename T, typename Predicate>
T binsearch(const std::vector<T> &ts, Predicate p) {

    // usage

    for(auto& t : ts)
    {
        if(p(t)) return t;
    }

    // default value if p always returned false

    return T{};
}

Take inspiration from standard algorithms library.

More Related Contents:

  1. C++11 does not deduce type when std::function or lambda functions are involved
  2. C++ lambda with captures as a function pointer
  3. Passing capturing lambda as function pointer
  4. How to convert a lambda to an std::function using templates
  5. Can lambda functions be templated?
  6. Lambda expressions as class template parameters
  7. What is the purpose of std::function and how to use it?
  8. Specializing a template on a lambda in C++0x
  9. Lambdas and std::function
  10. What is the type of lambda when deduced with “auto” in C++11?
  11. How to initialize std::array elegantly if T is not default constructible?
  12. Why should I avoid std::enable_if in function signatures
  13. Template tuple – calling a function on each element
  14. Calling a function for each variadic template argument and an array
  15. Lambda capture as const reference?
  16. Lifetime of lambda objects in relation to function pointer conversion
  17. Variadic templates
  18. What is the easiest way to print a variadic parameter pack using std::ostream?
  19. Variadic function template with pack expansion not in last parameter
  20. std::remove_if – lambda, not removing anything from the collection
  21. Lambda functions as base classes
  22. C++11 is_same type trait for templates
  23. Dependent name resolution & namespace std / Standard Library
  24. Why do we use std::function in C++ rather than the original C function pointer? [duplicate]
  25. templated typedef?
  26. std::enable_if : parameter vs template parameter
  27. Is there a way to write make_unique() in VS2012?
  28. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  29. Concatenate compile-time strings in a template at compile time?
  30. using extern template (C++11) to avoid instantiation

Leave a Comment