8

From my experience it seems that either:

  • A lambda expression created inside a function call is destroyed just after the invocation
  • Calling a function that expects a std::function creates a temporary object (std::function) out of the lambda, and that object is destroyed after invocation

This behavior can be observed with the following snippet of code:

const function<void()>* pointer;

void a(const function<void()> & f)
{
    pointer = &f;
}

void b()
{
    (*pointer)();
}

int main()
{
    int value = 1;
    std::cout << &value << std::endl;

    // 1: this works    
    function<void()> f = [&] () { std::cout << &value << std::endl; };
    a(f);

    // 2: this doesn't
    a([&] () { std::cout << &value << std::endl; });

    /* modify the stack*/
    char data[1024];
    for (int i = 0; i < 1024; i++)
        data[i] = i % 4; 

    b();

    return 0;
}

What exactly s actually happening in the second case? Is there a correct way to call a() without creating an explicit std::function object?

Edit:: This both versions (1 and 2) compile just right but result in different outputs:

Version 1:

0x7fffa70148c8
0x7fffa70148c8

Version 2:

0x7fffa70148c8
0
Improve this question
3
  • 1
    What do you mean that the second case "doesn't work"? Does it compile? Does it crash? Does it write out "doesn't work" to your printer? Commented Dec 9, 2012 at 15:07
  • 1
    @jalf: You forgot: Does it halt and catch fire. Commented Dec 9, 2012 at 15:10
  • 1
    /*modify the stack*/ Most compilers preallocate the necessary space for all local variables upon function entry. Commented Dec 9, 2012 at 15:21

3 Answers 3

Reset to default
3

If you create a temporary, it will be gone at the end of the line. This means storing a pointer to it is a bad idea, as you correctly stated.

If you want to store a pointer to a std::function (or anything else really), you need to make sure it's lifetime doesn't end before you stop using the pointer. This means that you really do need a named object of type std::function.

As to what is happening in the second case: You create a temporary lambda to be passed to the function. Since the function expects a std::function, a temporary std::function will be created from the lambda. Both of those will be destroyed at the end of the line. Therefore you now have a pointer to an already destroyed temporary, which means that trying to use the pointed to object will bring you firmly into undefined behaviour territory.

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

7 Comments

well, this is not necessarily true for lambdas as they are rewritten to "real" functions so they stay in memory, at the same address.
At the end of the containing full expression actually. In this case, that is roughly that line.
@BarnabasSzabolcs: Are you sure about that? A lambda can be implicitely converted to a function pointer (so the function is somewhere, that much is true), but will the lambda actually be rewritten to be identical to that function pointer? seems wasteful in terms of missed inlining opportunity. Either way, it doesn't matter, since the important point is that the std::function is destroyed
Not 100% :) but I can't break the code. Not with even adding rude optimization flags. I've seen (worse) programs which would run just fine for sure(!) on single-threaded environments.
@BarnabasSzabolcs: Looking closer I must correct my statement: The lambda has a capture, as such it can't be converted to a plain (dump) function, but must remain a capture. For not beeing able to break the code: Well it is undefined behaviour, not automatically breaking behaviour. I tried it in ideone. Interestingly enough it breaks when the value instead of the address of value is printed (look here).
|
1

It's okay for stateless lambdas. Stateless lambdas have an implicit conversion to function pointer type.

Also, there is always an implicit conversion to std::function<> regardless of the actual callable type.

There are problems with keeping a pointer to temporaries, though. I hadn't noticed that on first reading of the code.

That has nothing to do with std::function, of course.

Improve this answer

4 Comments

It is ok to store a pointer to a temporary std::function, if the object wrapped inside the function is a functionpointer?
No. Pointers to temporaries are always bad. You know, that has nothing to do with std::function<> really
I know that, but your answer seems to imply that it is (so you might want to change the wording ;))
@Grizzly I take it you should refresh you browser more often :) Sorry for missing that on the first round, though
0

Temporary objects are destroyed at the end of the statement they are created in. You have just demonstrated this with a lambda.

The std function you pass the first time is not a temporary, so it lasts as long as the variable. It actually stores a copy of the temporary.

To have your lamdas last more than a line, you need to store it somewhere and have its lifetime determined.

There are many ways to do this. Std function is a type erasure based way to do the storage -- ie, store a std function instead of a pointer to a std function. Change the type of pointer to being a non pointer (and non const), get rid of the & when you assign to it, and call it directly.

In general avoid taking and storing the address of const reference function parameters as temporary bind to them, unless you catch the rvalue reference possibility in another overload.

Improve this answer

2 Comments

Any way to store the lambda without having the runtime overhead of the type erasure provided by std::function?
@joaorafael In a function, auto deduces the type. In a template class wrapping the call, a function based creator can deduce the lambda type and passing to the class so the class can store a non erased lambda. A philosophical approach can ask you if you know this is a performance bottleneck, and if your efforts are not better spent elsewhere. The code that stores and uses the lambda needs to be a function of the lambdas type if you want to avoid type erasure overhead.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.