c++ - capturing perfectly forwarded vars in a lambda

Question

I'm pretty new with c++ and am currently writing an inversion of control container for my first project, expanding on this blog post by adding registering on base classes and forwarding additional arguments to the constructor.

It works pretty good for now but when I instantiate a lambda multiple times the captured values seem to get overridden.

Example:

struct A{
    short a;
    explicit A(short a_) : a(a_) {}
};
struct IC{
    virtual unsigned C() = 0;
};
struct CImpl : public IC{
    explicit CImpl(unsigned c_) : IC(), c(c_) {}
    unsigned C() override{return c;}
private:
    unsigned c;
};
template<class T, typename...TArgs> 
std::function<T*()> AsMinimalAsItGets(TArgs&&...args)
{ 
    return [&args...]() mutable -> T* 
    { 
        return new T(std::forward<TArgs>(args)...); 
    }; 
} 
auto aFactory = AsMinimalAsItGets<A>(3);
auto cFactory = AsMinimalAsItGets<CImpl>(5);
auto aInst = aFactory();//aInst->a should be 3 but is 5
auto cInst = cFactory();//cInst->C() is 5

A gets instantiated with 5 instead of 3.

I tried this as solution, but it didn't fix the problem.

So how do I correctly capture the variables when instantiating the lambda? I need to capture in a way that enables me to use perfect forwarding in the lambda

`&args` becomes a refeence to a temporal../ which coincentrntally changed to the new value — Swift - Friday Pie, Aug 14 '20 at 14:38

lubgr · Accepted Answer · 2020-08-14T15:04:59.747

Don't try to avoid a copy when you actually need one. In your case, you try to preserve the value categories of the arguments by std::forward them. But when you return a factory function std::function<T*()>, this closure must own the data it uses to perform the delayed construction. Otherwise, you end up with dangling references, as the arguments passed to AsMinimalAsItGets only outlive the scope of the function call.

The fix is easy:

template<class T, typename...TArgs> 
std::function<T*()> AsMinimalAsItGets(TArgs&&...args)
{ 
    return [args...]() mutable -> T* 
    //      ^^^^^^^ (1) Copy the arguments into the closure
    { 
        return new T(args...); 
        //           ^^^^^^^ (2) Pass them as is to the ctor
    }; 
}

Note that as @HolyBlackCat pointed out, this does not perfectly forward the arguments into the lambda capture. As shown in this answer, in C++20, you can

return [...args = std::forward<TArgs>(args)]() mutable -> T* 
{ 
    return new T(args...); 
};

while in C++17, you need this workaround:

return [args = std::make_tuple(std::forward<TArgs>(args)...)]() mutable -> T* 
{ 
    return std::apply([](auto&&... args){ return new T(args...); },
        std::move(args));
};

Doesn't this fail to perfect-forward `args`? The capture has to be `...args = std::forward(args)`, and using `args` inside of the lambda also requires `forward`. — HolyBlackCat, Aug 14 '20 at 14:49
I want to note that std::make_tuple doesn't work for lvalue references, they would be captured by value. I used std::tuple(std::forward(args)...) instead and now it works for all values — climb4, Aug 16 '20 at 13:25

c++ - capturing perfectly forwarded vars in a lambda

1 Answers1