C++: Can an unused lambda explicit capture be optimized out?

Question

I have a decent amount of code that relies on capturing a shared_from_this() when using a lambda expression as a callback to ensure that my instance stays alive:

std::shared_ptr<Thing> self = shared_from_this();
auto doSomething = [this, self] ()
{
    // various statements, none of which reference self, but do use this
}

So the question is: Since I am not referencing self inside the lambda body, is a conformant compiler allowed to optimize the capture away?

Consider the following program:

#include <functional>
#include <iostream>
#include <memory>

std::function<void ()> gFunc;

struct S : std::enable_shared_from_this<S>
{
    void putGlobal()
    {
        auto self = shared_from_this();
        gFunc = [self] { };
    }
};

int main()
{
    auto x = std::make_shared<S>();
    std::cout << x.use_count() << std::endl;
    x->putGlobal();
    std::cout << x.use_count() << std::endl;
}

The output is:

1
2

This indicates that g++-4.7.1 does not optimize the capture away (nor does clang-3.1).

GManNickG · Accepted Answer · 2012-10-03 23:47:24Z

35

The standard guarantees that captured values are not optimized away (per §5.1.2/14):

An entity is captured by copy if it is implicitly captured and the capture-default is = or if it is explicitly captured with a capture that does not include an &. For each entity captured by copy, an unnamed non- static data member is declared in the closure type. The declaration order of these members is unspecified. The type of such a data member is the type of the corresponding captured entity if the entity is not a reference to an object, or the referenced type otherwise.

So, self is copied into the closure on evaluation (per §5.1.2/21):

When the lambda-expression is evaluated, the entities that are captured by copy are used to direct-initialize each corresponding non-static data member of the resulting closure object.

edited Oct 3, 2012 at 23:47

GManNickG

506k55 gold badges505 silver badges551 bronze badges

answered Oct 3, 2012 at 23:42

Travis Gockel

27.9k16 gold badges93 silver badges116 bronze badges

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

4 Comments

GManNickG Over a year ago

This seems to contradict this answer, which says if it's ODR unused then it's not actually captured.

Nicol Bolas Over a year ago

@GManNickG: The difference is that of implicit capturing ([=]) and explicit capturing ([someNameHere]). Implicit capturing requires ODR used elements. Explicit capturing does not.

GManNickG Over a year ago

@NicolBolas: Gotcha. An entity is implicitly captured if and only if it's ODR used. At that point, it's in the same boat as explicitly captured entities. Thanks.

Weipeng Over a year ago

FWIW expr.prim.lambda.closure/2 says this: An implementation may define the closure type differently from what is described below provided this does not alter the observable behavior of the program other than by changing the size and/or alignment [..] Not sure whether this allows eliding the capture-by-copy but I suppose not, as copy-initialization of the captured variable has observable side effect to the abstract machine.

Collectives™ on Stack Overflow

C++: Can an unused lambda explicit capture be optimized out?

1 Answer 1

4 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

4 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related