嵌套lambda中的C ++完美转发

Question

I have a case where I am constructing a special thread object. This object must take a callable in the same way the std::thread does, do some validation, and then wrap it in another function which does some additional things (exact rationale is complicated and not relevant to this question). I have a working solution but I am not convinced that it is optimal as I have not managed to get perfect forwarding working.

I created the following example to debug the issue and try to understand what my error is.

The example compiles and runs without issue. However googletest's address sanitizer gives me this error:

AddressSanitizer: stack-use-after-scope on address 0x7ffcea0a8ff0 at pc 0x00000052a019 bp 0x7fee283febb0 sp 0x7fee283feba8

In the example I have a function called safe_function_executer . In this safe function the outermost lambda captures the function and arguments by value. I also have a function called bad_function_executer in which I attempt perfect forwarding by capturing the function and arguments by reference.

Googletest's address sanitizer does not throw an error for the safe_function_executer but it does for the bad_function_excecuter .

I am having difficulty understanding where I am accessing a value that has gone out of scope in this example. Does anyone know why Googletest's address sanitizer would be throwing this error?

#include <atomic>
#include <thread>
#include <array>
#include <functional>
#include <iostream>
#include <chrono>

//!!!WARNING Contrived Example Follows!!!

template<class SomeType, class F, class ...Args>
void a_function_running_function( SomeType& some_arg, F&& f, Args&&... args)
{
    f(std::forward<Args>(args)...);
    *some_arg = 42;
}

template<class SomeType, class F, class ...Args>
std::thread safe_function_executer( SomeType& some_arg, F&& f, Args&&... args )
{
    return std::thread( [=]() mutable { 
        a_function_running_function( some_arg, [&]() mutable {
            f( std::forward<Args>(args)... ); });});

}   


template<class SomeType, class F, class ...Args>
std::thread bad_function_executer( SomeType& some_arg, F&& f, Args&&... args )
{
    return std::thread( [&,some_arg]() mutable { 
        a_function_running_function( some_arg, [&]() mutable {
            f( std::forward<Args>(args)... ); });});

}

void some_function(int arg1, bool arg2, std::tuple<int,bool>& ret)
{
    std::get<0>(ret) = arg1;
    std::get<1>(ret) = arg2;
}

int main()
{
    auto arg = std::make_shared<std::atomic<int>>(0);
    auto ret = std::tuple<int,bool>{0, false};

    //works (but not perfectly forwarded?)
    auto good_thread = safe_function_executer( arg, &some_function,
                                               45, true, ret ); 
    good_thread.join();

    //address sanitizer errors
    auto bad_thread = bad_function_executer( arg, &some_function,
                                             45, true, ret );
    bad_thread.join();
}

Answer 1

All the parameters you are passing to bad_function_executer are temporaries and go out of scope in your main thread as soon as bad_function_executer returns. The temporaries are gone but you still use a reference to them in your lambda in the other thread.

In your good version, you capture the args by value, making a local copy of them, which stays around through the lifetime of the lambda.

If you made them all lvalues and passed them in that way, then they would remain in scope until the join() call, which would allow things to work with bad_function_executer .

int arg1 = 45;
bool arg2 = true;
//address sanitizer errors
auto bad_thread = bad_function_executer( arg, &some_function,
                                         arg1, arg2, ret );

but I think you're better off just capturing by value in this case, as you do with your good version.