stdasync

问题 The std::async has two overloads, one of them makes the parameter std::launch policy explicit while the other omits this parameter. The policy is a bitmask, so both launch::async|launch::deferred may be specified (or you may avoid the policy using the function that omits this parameter). Under the hood the policy is selected automatically in this case, and the choice is not guaranteed. I wonder what should be the reason of using this "unknown" policy. First of all, you shouldn't use this

问题 The std::async has two overloads, one of them makes the parameter std::launch policy explicit while the other omits this parameter. The policy is a bitmask, so both launch::async|launch::deferred may be specified (or you may avoid the policy using the function that omits this parameter). Under the hood the policy is selected automatically in this case, and the choice is not guaranteed. I wonder what should be the reason of using this "unknown" policy. First of all, you shouldn't use this

问题 What is the difference in the following: std::async(my_function); and std::async(std::launch::async, my_function); What is the difference in using the pilicy std::launch::async in this case?? Does the first option not launch the function asynchronously anyway?? 回答1: The first one is equivalent to passing launch::async | launch::deferred , in which case it is up to the implementation whether it is launched asynchronously or merely deferred (called when a non-timed waiting function like get()

问题 I got to know the reason that future returned from std::async has some special shared state through which wait on returned future happened in the destructor of future. But when we use std::pakaged_task , its future does not exhibit the same behavior. To complete a packaged task, you have to explicitly call get() on future object from packaged_task . Now my questions are: What could be the internal implementation of future (thinking std::async vs std::packaged_task )? Why the same behavior was

问题 I have a function template, where I want to do perfect forwarding into a lambda that I run on another thread. Here is a minimal test case which you can directly compile: #include <thread> #include <future> #include <utility> #include <iostream> #include <vector> /** * Function template that does perfect forwarding to a lambda inside an * async call (or at least tries to). I want both instantiations of the * function to work (one for lvalue references T&, and rvalue reference T&&). * However,

来源： https://stackoverflow.com/questions/64465888/why-am-i-getting-error-in-async-future-in-c

问题 Possible Duplicate: std::bind overload resolution Consider following C++ example class A { public: int foo(int a, int b); int foo(int a, double b); }; int main() { A a; auto f = std::async(std::launch::async, &A::foo, &a, 2, 3.5); } This gives 'std::async' : cannot deduce template argument as function argument is ambiguous. How do I resolve this ambiguity?? 回答1: Help the compiler resolve ambiguity telling which overload you want: std::async(std::launch::async, static_cast<int(A::*)(int,double

问题 Is it possible to call function objects created with std::bind using std::async. The following code fails to compile: #include <iostream> #include <future> #include <functional> using namespace std; class Adder { public: int add(int x, int y) { return x + y; } }; int main(int argc, const char * argv[]) { Adder a; function<int(int, int)> sumFunc = bind(&Adder::add, &a, 1, 2); auto future = async(launch::async, sumFunc); // ERROR HERE cout << future.get(); return 0; } The error is: No matching

问题 Is it possible to call function objects created with std::bind using std::async. The following code fails to compile: #include <iostream> #include <future> #include <functional> using namespace std; class Adder { public: int add(int x, int y) { return x + y; } }; int main(int argc, const char * argv[]) { Adder a; function<int(int, int)> sumFunc = bind(&Adder::add, &a, 1, 2); auto future = async(launch::async, sumFunc); // ERROR HERE cout << future.get(); return 0; } The error is: No matching

问题 Is it possible to call function objects created with std::bind using std::async. The following code fails to compile: #include <iostream> #include <future> #include <functional> using namespace std; class Adder { public: int add(int x, int y) { return x + y; } }; int main(int argc, const char * argv[]) { Adder a; function<int(int, int)> sumFunc = bind(&Adder::add, &a, 1, 2); auto future = async(launch::async, sumFunc); // ERROR HERE cout << future.get(); return 0; } The error is: No matching