Class method accepting lambdas representing functions of various number of argument

Question

I would like to pass functions in to a generic class method, so the generic class can invoke functions requiring no args, one arg, two args etc.

I have seen variadic templates but I do not like the syntax. A previous SO question recommended passing lambdas, wrapping the function:

https://stackoverflow.com/a/48976528/997112

where the answer is:

void run_callback(std::function<void()>& func) 
{
    func();
}

run_callback([]{ func_without_params(); });

and I therefore added a method which requires no argument:

void func_without_params()
{
    std::cout << "x" << std::endl;
}

but when I call:

run_callback([]{ func_without_params(); });

in VS2013 the intellisense detects an error and i get the compiler error:

error C2664: 'void run_callback(std::function<void (void)> &)' :
cannot convert argument 1 from
'main::<lambda_de925f4d5cd926a8bb664f9c057a7a19>' to
'std::function<void (void)> &'

What is a main::<lambda_de925f4d5cd926a8bb664f9c057a7a19> type? I don't fully-understand the error.

Are you stuck with VS2013? It's C++11 wasn't great. 2015 update 3 or 2017 have much better support — NathanOliver, Jan 09 '19 at 18:52

Swordfish · Accepted Answer · 2019-01-09T18:57:14.983

3

Except for evil compiler extensions you cannot initialize a non-const reference (parameter func) with something that is not an l-value. Make the parameter const:

#include <functional>
#include <iostream>

void run_callback(std::function<void()> const &func)
{
    func();
}

void func_without_params()
{
    std::cout << "x" << std::endl;
}

int main()
{
    run_callback([] { func_without_params(); });
}

edited Jan 09 '19 at 18:57

answered Jan 09 '19 at 18:55

Swordfish

12,971
3
21
43

2

maybe I completely misunderstand the qeustion, but you could pass `func_without_params` directly without using the lambda, no? – 463035818_is_not_an_ai Jan 09 '19 at 19:21
@user463035818 I guess the point of using a lambda is to be able to capture variables to use as parameters for the encapsulated function. – Swordfish Jan 09 '19 at 20:53
yes `func_without_params` is just an example for `func_with_any_number_of_params` where the lambda is necessary – 463035818_is_not_an_ai Jan 09 '19 at 21:09

score 1 · Answer 2 · answered Jan 09 '19 at 19:54

What is a main::<lambda_de925f4d5cd926a8bb664f9c057a7a19> type?

What references says about lambda expression:

The lambda expression is a prvalue expression of unique unnamed non-union non-aggregate class type, known as closure type, which is declared in the smallest block scope, class scope, or namespace scope that contains the lambda expression.

unnamed only for programmers, compiler knows this name and in your case lambda_de925f4d5cd926a8bb664f9c057a7a19 is the name of closure type. main refers to the function inside which closure type was defined.

You can use cppinsights to look behind the scenes. cppinsights uses Clang which doesn't accept binding Rvalue to Lvalue reference, so change your code into:

void run_callback(std::function<void()> func) // take by value

and the output from cppinsights is:

int main() { // scope of closure type

  class __lambda_14_16 { // closure type
    public: inline /*constexpr */ void operator()() const
    {
      func_without_params();
    }

  };

  run_callback(std::function<void ()>(__lambda_14_16{}));
}

Class method accepting lambdas representing functions of various number of argument

2 Answers2