2013/6/1 Vicente J. Botet Escriba
From the standard: template<class F> function(F f); template
function(allocator_arg_t, const A& a, F f); 7 Requires: F shall be *CopyConstructible*. f shall be Callable (20.10.11.2) for argument types ArgTypes and return type R. The copy constructor and destructor of A shall not throw exceptions. 8 Postconditions: !*this if any of the following hold: — f is a NULL function pointer. — f is a NULL pointer to member. — F is an instance of the function class template, and !f 9 Otherwise, *this targets a copy of f initialized with std::move(f). [Note: Implementations are encouraged to avoid the use of dynamically allocated memory for small callable objects, for example, where f’s target is an object holding only a pointer or reference to an object and a member function pointer. — end note ] 10 Throws: shall not throw exceptions when f is a function pointer or a reference_wrapper<T> for some T. Otherwise, may throw bad_alloc or any exception thrown by F’s copy or move constructor. But I find an assignment
template<class F> function& operator=(F&& f); 18 Effects: function(std::forward<F>(f)).swap(*this); 19 Returns: *this
This seems confusing. What am I missing?
I don't have a standard but this is in sync what you describe:
http://en.cppreference.com/w/cpp/utility/functional/function/function
http://en.cppreference.com/w/cpp/utility/functional/function/operator%3D
confusing indeed.
Anyway, trying to:
#define BOOST_THREAD_VERSION 4
#include