A function object f is compatible if for the given set of argument types Arg1, Arg2, ..., ArgN and a return type ResultType, the appropriate following function is well-formed: // if ResultType is not void ResultType foo(Arg1 arg1, Arg2 arg2, ..., ArgN argN) { return f(arg1, arg2, ..., argN); } // if ResultType is void ResultType foo(Arg1 arg1, Arg2 arg2, ..., ArgN argN) { f(arg1, arg2, ..., argN); } A special provision is made for pointers to member functions. Though they are not function objects, Boost.Function will adapt them internally to function objects. This requires that a pointer to member function of the form R (X::*mf)(Arg1, Arg2, ..., ArgN) cv-quals be adapted to a function object with the following function call operator overloads: template<typename P> R operator()(cv-quals P& x, Arg1 arg1, Arg2 arg2, ..., ArgN argN) const { return (*x).*mf(arg1, arg2, ..., argN); } A function object f of type F is stateless if it is a function pointer or if boost::is_stateless<F> is true. The construction of or copy to a Boost.Function object from a stateless function object will not cause exceptions to be thrown and will not allocate any storage.

std::runtime_error An exception type thrown when an instance of a function object is empty when invoked. Constructs a bad_function_call exception object. The common base class for all Boost.Function objects. Objects of type function_base may not be created directly. bool false if this has a target, and true otherwise. Will not throw. Functor* const Functor* If this stores a target of type Functor, returns the address of the target. Otherwise, returns the NULL pointer. Will not throw. bool const Functor& true if this->target<Functor>() is non-NULL and function_equal(*(this->target<Functor>()), f) const std::type_info& typeid of the target function object, or typeid(void) if this->empty(). Will not throw. function_base A set of generalized function pointers that can be used for callbacks or wrapping function objects. Class template functionN is actually a family of related classes function0, function1, etc., up to some implementation-defined maximum. In this context, N refers to the number of parameters. R T1If N == 1 T1 If N == 2 T2 If N == 2 T1 T2 TN int N Lambda library support result_type this->empty() Will not throw. const functionN& Contains a copy of the f's target, if it has one, or is empty if f.empty(). Will not throw unless copying the target of f throws. functionN&& C++11 compatible compiler. Moves the value from f to *this. If the argument has its function object allocated on the heap, its buffer will be assigned to *this leaving argument empty. Will not throw unless argument has its function object allocated not on the heap and copying the target of f throws. F F is a function object Callable from this. *this targets a copy of f if f is nonempty, or this->empty() if f is empty. F Allocator F is a function object Callable from this, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw. *this targets a copy of f if f is nonempty, or this->empty() if f is empty. If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory. If !this->empty(), destroys the target of this. const functionN& If copy construction does not throw, *this targets a copy of f's target, if it has one, or is empty if f.empty(). If copy construction does throw, this->empty(). functionN&& C++11 compatible compiler. Moves the value from f to *this. If the argument has its function object allocated on the heap, its buffer will be assigned to *this leaving argument empty. Will not throw unless argument has its function object allocated not on the heap and copying the target of f throws. void const functionN& Interchanges the targets of *this and f. void this->empty() bool false if this has a target, and true otherwise. Will not throw. safe_bool A safe_bool that evaluates false in a boolean context when this->empty(), and true otherwise. Will not throw. bool this->empty() Will not throw. Functor* const Functor* If this stores a target of type Functor, returns the address of the target. Otherwise, returns the NULL pointer. Will not throw. bool const Functor& true if this->target<Functor>() is non-NULL and function_equal(*(this->target<Functor>()), f) const std::type_info& typeid of the target function object, or typeid(void) if this->empty(). Will not throw. result_type arg1_type arg2_type ... argN_type f(a1, a2, ..., aN), where f is the target of *this. if R is void, nothing is returned; otherwise, the return value of the call to f is returned. bad_function_call if this->empty(). Otherwise, may through any exception thrown by the target function f. void functionN<T1, T2, ..., TN>& functionN<T1, T2, ..., TN>& f1.swap(f2) bool const functionN<T1, T2, ..., TN>& Functor bool Functor const functionN<T1, T2, ..., TN>& bool const functionN<T1, T2, ..., TN>& reference_wrapper<Functor> bool reference_wrapper<Functor> const functionN<T1, T2, ..., TN>& void const functionN<T1, T2, ..., TN>& const functionN<U1, U2, ..., UN>& True when f stores an object of type Functor and one of the following conditions applies: g is of type reference_wrapper<Functor> and f.target<Functor>() == g.get_pointer(). g is not of type reference_wrapper<Functor> and function_equal(*(f.target<Functor>()), g). functionN objects are not EqualityComparable. The safe_bool conversion opens a loophole whereby two functionN instances can be compared via ==, although this is not feasible to implement. The undefined void operator== closes the loophole and ensures a compile-time or link-time error. bool const functionN<T1, T2, ..., TN>& Functor bool Functor const functionN<T1, T2, ..., TN>& bool const functionN<T1, T2, ..., TN>& reference_wrapper<Functor> bool reference_wrapper<Functor> const functionN<T1, T2, ..., TN>& void const functionN<T1, T2, ..., TN>& const functionN<U1, U2, ..., UN>& True when f does not store an object of type Functor or it stores an object of type Functor and one of the following conditions applies: g is of type reference_wrapper<Functor> and f.target<Functor>() != g.get_pointer(). g is not of type reference_wrapper<Functor> and !function_equal(*(f.target<Functor>()), g). functionN objects are not EqualityComparable. The safe_bool conversion opens a loophole whereby two functionN instances can be compared via !=, although this is not feasible to implement. The undefined void operator!= closes the loophole and ensures a compile-time or link-time error. functionN<R, T1, T2, ..., TN> A generalized function pointer that can be used for callbacks or wrapping function objects. Class template function is a thin wrapper around the numbered class templates function0, function1, etc. It accepts a function type with N arguments and will will derive from functionN instantiated with the arguments it receives. The semantics of all operations in class template function are equivalent to that of the underlying functionN object, although additional member functions are required to allow proper copy construction and copy assignment of function objects. R T1If N == 1 T1 If N == 2 T2 If N == 2 T1 T2 TN int N Lambda library support result_type this->empty() Will not throw. const functionN& Contains a copy of the f's target, if it has one, or is empty if f.empty(). Will not throw unless copying the target of f throws. functionN&& C++11 compatible compiler. Moves the value from f to *this. If the argument has its function object allocated on the heap, its buffer will be assigned to *this leaving argument empty. Will not throw unless argument has its function object allocated not on the heap and copying the target of f throws. const function& Contains a copy of the f's target, if it has one, or is empty if f.empty(). Will not throw unless copying the target of f throws. function&& C++11 compatible compiler. Moves the value from f to *this. If the argument has its function object allocated on the heap, its buffer will be assigned to *this leaving argument empty. Will not throw unless argument has its function object allocated not on the heap and copying the target of f throws. F F is a function object Callable from this. *this targets a copy of f if f is nonempty, or this->empty() if f is empty. F Allocator F is a function object Callable from this, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw. *this targets a copy of f if f is nonempty, or this->empty() if f is empty. If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory. If !this->empty(), destroys the target of this. const functionN& If copy construction does not throw, *this targets a copy of f's target, if it has one, or is empty if f.empty(). If copy construction does throw, this->empty(). functionN&& C++11 compatible compiler. Moves the value from f to *this. If the argument has its function object allocated on the heap, its buffer will be assigned to *this leaving argument empty. Will not throw unless argument has its function object allocated not on the heap and copying the target of f throws. const function& If copy construction of the target of f does not throw, *this targets a copy of f's target, if it has one, or is empty if f.empty(). Will not throw when the target of f is a stateless function object or a reference to the function object. If copy construction does throw, this->empty(). function&& C++11 compatible compiler. Moves the value from f to *this. If the argument has its function object allocated on the heap, its buffer will be assigned to *this leaving argument empty. Will not throw unless argument has its function object allocated not on the heap and copying the target of f throws. void const function& Interchanges the targets of *this and f. void this->empty() Will not throw. bool false if this has a target, and true otherwise. Will not throw. safe_bool A safe_bool that evaluates false in a boolean context when this->empty(), and true otherwise. Will not throw. bool this->empty() Will not throw. Functor* const Functor* If this stores a target of type Functor, returns the address of the target. Otherwise, returns the NULL pointer. Will not throw. bool const Functor& true if this->target<Functor>() is non-NULL and function_equal(*(this->target<Functor>()), f) const std::type_info& typeid of the target function object, or typeid(void) if this->empty(). Will not throw. result_type arg1_type arg2_type ... argN_type f(a1, a2, ..., aN), where f is the target of *this. if R is void, nothing is returned; otherwise, the return value of the call to f is returned. bad_function_call if this->empty(). Otherwise, may through any exception thrown by the target function f. void function<Signature>& function<Signature>& f1.swap(f2) bool const function<Signature>& Functor bool Functor const function<Signature>& bool const function<Signature>& reference_wrapper<Functor> bool reference_wrapper<Functor> const function<Signature>& void const function<Signature1>& const function<Signature2>& True when f stores an object of type Functor and one of the following conditions applies: g is of type reference_wrapper<Functor> and f.target<Functor>() == g.get_pointer(). g is not of type reference_wrapper<Functor> and function_equals(*(f.target<Functor>()), g). function objects are not EqualityComparable. The safe_bool conversion opens a loophole whereby two function instances can be compared via ==, although this is not feasible to implement. The undefined void operator== closes the loophole and ensures a compile-time or link-time error. bool const function<Signature>& Functor bool Functor const function<Signature>& bool const function<Signature>& reference_wrapper<Functor> bool reference_wrapper<Functor> const function<Signature>& void const function<Signature1>& const function<Signature2>& True when f does not store an object of type Functor or it stores an object of type Functor and one of the following conditions applies: g is of type reference_wrapper<Functor> and f.target<Functor>() != g.get_pointer(). g is not of type reference_wrapper<Functor> and !function_equals(*(f.target<Functor>()), g). function objects are not EqualityComparable. The safe_bool conversion opens a loophole whereby two function instances can be compared via !=, although this is not feasible to implement. The undefined void operator!= closes the loophole and ensures a compile-time or link-time error.

bool const F& const G& Compare two function objects for equality. f == g. Only if f == g throws.