//------------------------------------------------------------------------------ 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