Boost.Function Reference Manual<boost/function.hpp> synopsis Here MAX_ARGS is an implementation-defined constant that defines the maximum number of function arguments supported by Boost.Function and will be at least 10. The MAX_ARGS constant referred to in this document need not have any direct representation in the library.
namespace boost {
class function_base
{
typedef implementation-defined safe_bool;
bool empty() const;
operator safe_bool() const;
safe_bool operator!() const;
};
// For N in [0, MAX_ARGS]
template<typename ResultType,
typename Arg1,
typename Arg2,
...
typename ArgN,
typename Policy = empty_function_policy,
typename Mixin = empty_function_mixin,
typename Allocator = std::allocator<function_base> >
class functionN : public function_base, public Mixin
{
typedef ResultType result_type;
typedef Policy policy_type;
typedef Mixin mixin_type;
typedef Allocator allocator_type;
typedef Arg1 argument_type; // If N == 1
typedef Arg1 first_argument_type; // If N == 2
typedef Arg2 second_argument_type; // If N == 2
// Construction
explicit functionN(const Mixin& = Mixin());
functionN(const functionN&);
template<typename F> functionN(const F&, const Mixin& = Mixin());
// Assignment
functionN& operator=(const functionN&);
template<typename F> functionN& operator=(const F&);
void set(const functionN&);
template<typename F> void set(const F&);
void swap(functionN&);
void clear();
// Invocation
result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
};
template<typename ResultType,
typename Arg1,
typename Arg2,
...
typename ArgN,
typename Policy,
typename Mixin,
typename Allocator>
void swap(const functionN<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>&,
const functionN<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>&);
// For any N in [0, MAX_ARGS]
template<typename ResultType,
typename Arg1,
typename Arg2,
...
typename ArgN,
typename ArgN+1 = implementation-defined,
typename ArgN+2 = implementation-defined,
...
typename ArgMAX_ARGS = implementation-defined>
class function : public functionN<Arg1, Arg2, ..., ArgN>
{
// Construction
function();
function(const function&);
functionN(const functionN&);
template<typename F> functionN(const F&);
// Assignment
function& operator=(const function&);
functionN& operator=(const functionN&);
template<typename F> function& operator=(const F&);
void set(const function&);
void set(const functionN&);
template<typename F> void set(const F&);
};
template<typename ResultType,
typename Arg1,
typename Arg2,
...
typename ArgMAX_ARGS>
void swap(const function<Arg1, Arg2, ..., ArgMAX_ARGS>&,
const function<Arg1, Arg2, ..., ArgMAX_ARGS>&);
}
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:
R operator()(cv-quals X& x, Arg1 arg1, Arg2 arg2, ..., ArgN argN) const
{
return x.*mf(arg1, arg2, ..., argN);
}
R operator()(cv-quals X* x, Arg1 arg1, Arg2 arg2, ..., ArgN argN) const
{
return x->*mf(arg1, arg2, ..., argN);
}
template<typename P>
R operator()(cv-quals P& x, Arg1 arg1, Arg2 arg2, ..., ArgN argN) const
{
return (*x).*mf(arg1, arg2, ..., argN);
}
function_base Class function_base is the common base class for all Boost.Function objects. Objects of type function_base may not be created directly.
true if the function object has a target, false otherwise.safe_bool equivalent of !empty()safe_bool type can be used in contexts where a bool is expected (e.g., an if condition); however, implicit conversions (e.g., to int) that can occur with bool are not allowed, eliminating some sources of user error.
safe_bool equivalent of empty()safe_bool conversion
functionN 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 and f refers to the implicit object parameter.
explicit functionN(const Mixin& = Mixin());
Mixin subobject with the given mixin.f.empty(). functionN(const functionN& g);
f contains a copy of the g's target, if it has one, or is empty if g.empty(). The mixin for the f is copy-constructed from the mixin of g. template<typename F> functionN(const F& g, const Mixin& = Mixin());
g is a compatible function object.Mixin subobject from the given mixin.f targets a copy of g if g is nonempty, or f.empty() if g is empty.g is a reference-to-const because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of g is reference-to-const pointer-to-function. functionN& operator=(const functionN& g);
f targets a copy of g's target, if it has one, or is empty if g.empty(). The mixin for f is assigned the value of the mixin for g.*this. template<typename F> functionN& operator=(const F& g);
g is a compatible function object.f targets a copy of g if g is nonempty, or f.empty() if g is empty.*this.g is a reference-to-const because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of g is reference-to-const pointer-to-function.*this = g. template<typename F> void set(const F& g);
*this = g.f and g and swaps the mixins of f and g. result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
!empty().const or volatile qualified.
policy_type policy;policy.precall(this);target(a1, a2, ..., aN);policy.postcall(this);function Class template function is a thin wrapper around the numbered class templates function0, function1, etc. It accepts up to MAX_ARGS arguments, but when passed N arguments it will derive from functionN specialized 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.
template<typename ResultType,
typename Arg1,
typename Arg2,
...
typename ArgN,
typename Policy,
typename Mixin,
typename Allocator>
void swap(const functionN<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>& f,
const functionN<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>& g);
f.swap(g);
template<typename ResultType,
typename Arg1,
typename Arg2,
...
typename ArgMAX_ARGS>
void swap(const function<Arg1, Arg2, ..., ArgMAX_ARGS>& f,
const function<Arg1, Arg2, ..., ArgMAX_ARGS>& g);
f.swap(g);