PPL concurrency and co_await causes lambda capture variables to go out of scope at suspend

Question

If I call

concurrency::create_task([self,this]() -> concurrency::task<void>
{ 
   co_await 5s; //or really any task that suspends until complete
   MemberFunction();
   co_return;
});

after the suspension point when I call MemberFunction() the this pointer is NULL and the destructor on self has been called because while the code segment and local function stack have been resumed the actual lambda object which was initially used as a functor has gone out of scope. ASIO captures the functor and keeps it in scope until it is done executing but it appears the PPL Concurrency runtime does not. How do I maintain state after a co_await short of copying all the capture variables onto the local function stack before suspending (which does work but is maintainability nightmare)? I have tried putting the task returned by create_task in a variable and storing it until the task is done but that doesn't help and looking at the code it looks like it makes no effort to keep the functor in scope until it's done. This is only a problem at the top level because nested tasks are awaited so their functors don't go out of scope until they are done but how do a I start a top level coroutine and keep the functor in scope?

Answer 1

From https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines

"Usage patterns that are correct with normal lambdas are hazardous with coroutine lambdas. The obvious pattern of capturing variables will result in accessing freed memory after the first suspension point, even for refcounted smart pointers and copyable types."

Bad:

int value = get_value();
std::shared_ptr<Foo> sharedFoo = get_foo();
{
  const auto lambda = [value, sharedFoo]() -> std::future<void>
  {
    co_await something();
    // "sharedFoo" and "value" have already been destroyed
    // the "shared" pointer didn't accomplish anything
  };
  lambda();
} // the lambda closure object has now gone out of scope

Good:

int value = get_value();
std::shared_ptr<Foo> sharedFoo = get_foo();
{
  // take as by-value parameter instead of as a capture
  const auto lambda = [](auto sharedFoo, auto value) -> std::future<void>
  {
    co_await something();
    // sharedFoo and value are still valid at this point
  };
  lambda(sharedFoo, value);
} // the lambda closure object has now gone out of scope

Best:

std::future<void> Class::do_something(int value, std::shared_ptr<Foo> sharedFoo)
{
  co_await something();
  // sharedFoo and value are still valid at this point
}

void SomeOtherFunction()
{
  int value = get_value();
  std::shared_ptr<Foo> sharedFoo = get_foo();
  do_something(value, sharedFoo);
}