Passing arguments to std::async by reference fails

by

It’s a deliberate design choice/trade-off.

First, it’s not necessarily possible to find out whether the functionoid passed to async takes its arguments by reference or not. (If it’s not a simple function but a function object, it could have an overloaded function call operator, for example.) So async cannot say, “Hey, let me just check what the target function wants, and I’ll do the right thing.”

So the design question is, does it take all arguments by reference if possible (i.e. if they’re lvalues), or does it always make copies? Making copies is the safe choice here: a copy cannot become dangling, and a copy cannot exhibit race conditions (unless it’s really weird). So that’s the choice that was made: all arguments are copied by default.

But then, the mechanism is written so that it actually fails to then pass the arguments to a non-const lvalue reference parameter. That’s another choice for safety: otherwise, the function that you would expect to modify your original lvalue instead modifies the copy, leading to bugs that are very hard to track down.

But what if you really, really want the non-const lvalue reference parameter? What if you promise to watch out for dangling references and race conditions? That’s what std::ref is for. It’s an explicit opt-in to the dangerous reference semantics. It’s your way of saying, “I know what I’m doing here.”

More Related Contents:

  1. Why is the destructor of a future returned from `std::async` blocking?
  2. Can I use std::async without waiting for the future limitation?
  3. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  4. How do I terminate a thread in C++11?
  5. Concurrency: Atomic and volatile in C++11 memory model
  6. Passing object by reference to std::thread in C++11
  7. Why don’t compilers merge redundant std::atomic writes?
  8. What are the correct link options to use std::thread in GCC under linux?
  9. std::thread pass by reference calls copy constructor
  10. C++11 thread-safe queue
  11. How to use std::async on a member function?
  12. How to give priority to privileged thread in mutex locking?
  13. Which std::async implementations use thread pools?
  14. C++0x thread interruption
  15. What causes runtime error message: std::system_error – operation not permitted, including mult-threading? [duplicate]
  16. What is the difference between packaged_task and async
  17. Get the status of a std::future
  18. std::thread is not a member of namespace std using Eclipse Kepler MinGW
  19. Why should I use std::async?
  20. C++ terminate called without an active exception
  21. What is different between join() and detach() for multi threading in C++?
  22. std::thread error (thread not member of std)
  23. When must you pass io_context to boost::asio::spawn? (C++)
  24. C++11 std::threads vs posix threads
  25. Understanding std::atomic::compare_exchange_weak() in C++11
  26. GCC std::thread not found in namespace std
  27. std::thread calling method of class [duplicate]
  28. Write concurrently vector
  29. Why does this simple std::thread example not work?
  30. std::async won’t spawn a new thread when return value is not stored

Leave a Comment