Brave Search

stackoverflow.com › questions › 36030589 › i-cannot-pass-lambda-as-stdfunction

It's because a lambda function is not a std::function<...>. The type of

auto lambda = [](const std::string& s) { return std::stoi(s); };

is not std::function<int(const std::string&)>, but something unspecified which can be assigned to a std::function. Now, when you call your method, the compiler complains that the types don't match, as conversion would mean to create a temporary which cannot bind to a non-const reference.

This is also not specific to lambda functions as the error happens when you pass a normal function. This won't work either:

int f(std::string const&) {return 0;}

int main()
{
    std::vector<int> vec;
    C<int> c;
    c.func(vec, f);
}

You can either assign the lambda to a std::function

std::function<int(const std::string&)> lambda = [](const std::string& s) { return std::stoi(s); };

,change your member-function to take the function by value or const-reference or make the function parameter a template type. This will be slightly more efficient in case you pass a lambda or normal function pointer, but I personally like the expressive std::function type in the signature.

template<typename T>
class C{
    public:
    void func(std::vector<T>& vec, std::function<T( const std::string)> f){
        //Do Something
    }

    // or
    void func(std::vector<T>& vec, std::function<T( const std::string)> const& f){
        //Do Something
    }

    // or
    template<typename F> func(std::vector<T>& vec, F f){
        //Do Something
    }
};

Answer from Jens on Stack Overflow

Shaharmike

shaharmike.com › cpp › lambdas-and-functions

Under the hood of lambdas and std::function | Shahar Mike's Web Spot

February 23, 2016 - $ clang++ main.cpp -std=c++14 && ./a.out Assigning lambda1 of size 16 Assigning lambda2 of size 17 Allocating 17 bytes · 17. That’s the threshold beyond which std::function reverts to dynamic allocation (on clang).

Cppreference

en.cppreference.com › w › cpp › utility › functional › function.html

std::function - cppreference.com

#include <functional> #include <iostream> struct Foo { Foo(int num) : num_(num) {} void print_add(int i) const { std::cout << num_ + i << '\n'; } int num_; }; void print_num(int i) { std::cout << i << '\n'; } struct PrintNum { void operator()(int i) const { std::cout << i << '\n'; } }; int main() { // store a free function std::function<void(int)> f_display = print_num; f_display(-9); // store a lambda std::function<void()> f_display_42 = []() { print_num(42); }; f_display_42(); // store the result of a call to std::bind std::function<void()> f_display_31337 = std::bind(print_num, 31337); f_di

Discussions

c++ - I cannot pass lambda as std::function - Stack Overflow

Please explain me what is not ok and how to implement it with std::bind as well. ... It's because a lambda function is not a std::function<...>. The type of More on stackoverflow.com

stackoverflow.com

When to use a lambda over a function pointer?

So there are three main things I use lambdas for (NOTE: The Reddit numbered list functionality is literally so shitty that I cannot put any code blocks between numbered entries whatsoever, so you get no numbers): They make it easier to pass a function as an argument. Consider the situation where you have a very simple thing to do, but creating an entire separate function is both harder to maintain as well as more difficult to mentally parse. For example: int example(std::vector nums) { return std::accumulate(nums.begin(), nums.end(), 0, [](int acc, int num){ return num > 0 ? acc + num : acc; }); } They allow you to easily bind arguments for functions without needing to use the unnecessarily complicated std::bind. Before lambdas, C++ tried to get first class function using std::function and std::bind. The std::function thing mostly remains, but std::bind has been wholesale replaced by lambdas. struct MyObject { int doSomething(int argument); }; int deriveInfo(std::function f); int example() { MyObject o; // Instead of doing this: // return deriveInfo(std::bind(&MyObject::doSomething, &o)); // You do this: return deriveInfo([&o](int arg){ return o.doSomething(arg); }); } They allow you to create function objects without needing to do all of the class or struct definitions manually. A lambda is effectively an object that runs the function provided upon a call to operator(). As such, if you need to have multiple different function objects passed to the same object or template, this makes it very easy to do so. constexpr static auto A = [](int a, int b){ return example(a * b); }; constexpr static auto B = [](int a, int b){ return example(a + b); }; constexpr static auto C = [](int a, int b){ return example(a - b); }; template constexpr static inline void doSomething(Func f) { f(10, 5); } void someFunc() { doSomething(A); doSomething(B); doSomething(C); } I find lambdas to be quite useful and would be very disappointed if I was forced to make it work with just function pointers. More on reddit.com

r/cpp_questions

27

19

September 10, 2023

c++ - How to convert a lambda to an std::function using templates - Stack Overflow

My goal was to be able to do something ... to use std::bind and have used it extensively before. This problem on the other hand is simply a challenge to see what I can accomplish with variadic templates. 2012-11-13T10:30:24.8Z+00:00 ... @retep998: in your example code, your lambda captures nothing and therefore is convertible to a function ... More on stackoverflow.com

stackoverflow.com

lambda to std::function template - C++ Forum

I want a template function('Convert') ... Convert([](int&){});//f3 type is std::function; how to implement 'Convert'? ... Do you realize that a lambda is a callable target? http://en.cppreference.com/w/cpp/utility/functional/function There is an example where a lambda is stored ... More on cplusplus.com

cplusplus.com

October 27, 2017

Videos