Automatically wrap lamda function with std::function

[Dave11]

Hi all,
My Problem goes like this:
If I want to save function in a std::map, I have the map value be either pointer to function or either std::function.

If I want to allow lamda functions to be saved in the map , and the lamda uses captures , in order for it work , the value must be std::function , and I must wrap the lamda with std::function.

for example , look at this snippet:

class SomeClass{

private:
static std::map<void* , std::function<void()>> functionMap;

public :
void setNewKeyValue (void* key ,std::function<void()>& function){
functionMap[key] = function;
}

void setNewKeyValue (void* key ,void(*function)()){
functionMap[key] = function;
}

};

int main (void){
SomeClass someObject;
int x;
double y =8.8 ; //dumm example, just to clarify the question
SomeObject.setNewKeyValue((void*)&x,std::function([&y]{y=-1;}));
return 0;
}

my question is , is there some way of setNewKeyValue to wrap the lamda expression from the inside so the outside developer won't be needing to wrap every lamda that uses capture with std::function?
or even something else , is there any "clean" solution to allow lamda functions with uses captures to be stored in a std::map?

[manasij7479]

I don't think you need to do that wrapping.
Unless I have totally misunderstood your question..the following code builds fine:

#include<map>
#include<functional>
int main()
{
    int x = 6;
    std::map<int, std::function<void()>> map;
    map[2] = [&x](){};
}

[Dave11]

your code is slightly different, if you try this:

#include<map>
#include<functional>

std::map<int, std::function<void()>> map;

void setFunction(int i, std::function<void()>& f){
    map[i] = f;
}

int main()
{
    int x = 6;
    setFunction(2, [&x](){});
}

it doesn't compile.
interestingly , if we pass the lamda by value , AKA void setFunction(int i, std::function<void()> f) it does.
I wonder what kind of effect on the time and memory passing lamda function by value makes.

[phantomotap]

static std::map<void* , std::function<void()>> functionMap;

O_o

SomeObject.setNewKeyValue((void*)&x,std::function([&y]{y=-1;}));

o_O

You shouldn't use that particular combination of code.

If your use was in a different function, I could show you how to make the code explode.

As is, you are just asking for trouble.

When `someObject' dies, the references are lost. You can't reliable determine the value of `&x', but the function called would use a reference to update an dead object if you could.

*shrug*

The `setNewKeyValue' shouldn't take the `std::function<???>' object as a mutable reference. You can take the `std::function<???>' object as a constant reference. Preferably given the C++11 code, you could use perfect forwarding and `std::map<???>::emplace' allowing you to implement just one version of `setNewKeyValue' which will try to do the right thing.

[Edit]
By the by, the cast is unnecessary and ugly. You should remove the cast.
[/Edit]

Soma

[Elysia]

it doesn't compile.
interestingly , if we pass the lamda by value , AKA void setFunction(int i, std::function<void()> f) it does.

The problem is not that you can't convert lambda -> std::function. The problem is that you're trying to pass a temporary to a non-const reference. The above code is non-standard, but supported at least on msvc as an extension.
You should take the function object by const reference and then make a copy of it.

For example:

#include <map>
#include <functional>

std::map<int, std::function<void()>> map;

void setFunction(int i, const std::function<void()>& f)
{
	map[i] = f;
}

int main()
{
	int x = 6;
	setFunction(2, [&x]() {});
}

This compiles fine.
Btw, yeah, don't store references to local variables.

[Dave11]

Of course , this is just some example code to illustrate the problem. I see what was I missing, thanks.

[phantomotap]

Of course , this is just some example code to illustrate the problem. I see what was I missing, thanks.

O_o

Did you understand why the code was missing what was missing?

Soma

[Dave11]

yes , I tried to pass a Temporary- lamda-function as argument on a function with reference std::function as parameter.
only const references can be bind to temporaries, no regular references , and that was the problem (lamda function are not different here).

[Elysia]

...only const references can be bind to temporaries...

And r-value references.