Question

I have a program, where I cannot use the standard std::async and threading mechanisms. Instead I have to code the program like so:

void processor( int argument, std::function<void(int)> callback ) {
  int blub = 0;

  std::shared_ptr<object> objptr = getObject();

  // Function is called later.
  // All the internal references are bound here!
  auto func = [=, &blub]() {
    // !This will fail since blub is accessed by reference!
    blub *= 2;

    // Since objptr is copied by value it works.
    // objptr holds the value of getObject().
    objptr->addSomething(blub);

    // Finally we need to call another callback to return a value
    callback(blub);
  };

  objptr = getAnotherObject();

  // Puts func onto a queue and returns immediately.
  // func is executed later.
  startProcessing(func);
}

I now would like to know whether I am doing it right or what the best way of using lambdas as asynchronous callbacks is.

EDIT: Added expected behavior to the code comments.
See answer/comments for possible solutions for the problem with blub.

Answer 1

The function object will contain a reference to the local variable blub. As in every other situation in the language, this won’t make the local variable live after the function ends.

Copies of all the other captured objects will be stored within the function object, since they’re captured-by-value. This means there’s no issue with them.

If you want it to live after the function ends, you cannot tie its lifetime to the function: you need dynamic storage duration. A std::unique_ptr can be used to to handle the cleanup of such an object, but it gets a bit annoying because you can’t “capture-by-move” into a lambda :S

auto blub = make_unique<int>(0); // [1]

std::shared_ptr<object> objptr = getObject();

// use std::bind to store the unique_ptr with the lambda
auto func = std::bind([=](std::unique_ptr<int>& blub) {
  *blub *= 2;

  objptr->addSomething(*blub);

  callback(*blub);
}, std::move(blub)); // move the unique_ptr into the function object

objptr = getAnotherObject();

// func is not copiable because it holds a unique_ptr
startProcessing(std::move(func)); // move it

As an added note, the old deprecated std::auto_ptr would actually work fine here, because if the lambda captures it by value it gets copied and its strange copy semantics are exactly what’s needed.

---

_{1. See GOTW #102 for make_unique.}