//------------------------------------------------------------------------------ struct A {     A(){}     A(A&&){}     A& operator=(A&&){return *this;}     void operator()(){}  private:     A(const A&);     A& operator=(const A&);      int x; };  //------------------------------------------------------------------------------ int main() {     A a;     std::function<void()> func(std::move(a)); } 'A::A' : cannot access private member declared in class 'A'
It seems like when I capture something by reference or const I can make a non-copyable lambda. However when I do that it actually works to give it to a std::function.
You can recover the desired behavior by always using thread-local copies of the std::function because they'll each have an isolated copy of the state variables.
Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target -- functions, lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and pointers to data members.
The short answer is that the C++11 specification requires your A to be CopyConstructible to be used with std::function.
The long answer is this requirement exists because std::function erases the type of your functor within the constructor.  To do this, std::function must access certain members of your functor via virtual functions.  These include the call operator, the copy constructor and the destructor.  And since these are accessed via a virtual call, they are "used" whether or not you actually use std::function's copy constructor, destructor or call operator.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With