<functional>

Defines Standard Template Library (STL) functions that help construct function objects, also known as functors, and their binders. A function object is an object of a type that defines operator(). A function object can be a function pointer, but more typically, the object is used to store additional information that can be accessed during a function call.

For a list of all members of this header, see <functional> Members.

#include <functional>

Remarks

Algorithms require two types of function objects: unary and binary. Unary function objects require one argument, and binary function objects require two arguments. A function object and function pointers can be passed as a predicate to an algorithm, but function objects are also adaptable and increase the scope, flexibility, and efficiency of the STL. If, for example, a value needed to be bound to a function before being passed to an algorithm, then a function pointer could not be used. Function adaptors convert function pointers into adaptable function objects that can be bound to a value. The header <functional> also contains member function adaptors that allow member functions to be called as adaptable function objects. Functions are adaptable if they have nested type declarations specifying their argument and return types. The C++ Standard requires that this adaptability is implemented by having all standard object classes inherit from the unary_function or binary_function base classes. Function objects and their adaptors allow the STL to upgrade existing applications and help integrate the STL into the C++ programming environment.

TR1 Extensions

The following features are added in the Visual C++ implementation of TR1:

• A call signature is the name of a return type followed by a parenthesized comma-separated list of zero or more argument types.

• A call wrapper is an object of a call wrapper type.

• A call wrapper type is a type that holds a callable object and supports a call operation that forwards to that object.

• A callable object is an object of a callable type.

• A callable type is a pointer to function, a pointer to member function, a pointer to member data, or a class type whose objects can appear immediately to the left of a function call operator.

• A target object is the callable object held by a call wrapper object.

The pseudo-function INVOKE(f, t1, t2, ..., tN) means one of the following things:

• (t1.*f)(t2, ..., tN) when f is a pointer to member function of class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T.

• ((*t1).*f)(t2, ..., tN) when f is a pointer to member function of class T and t1 is not one of the types described in the previous item.

• t1.*f when f is a pointer to member data of class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T.

• (*t1).*f when f is a pointer to member data of class class T and t1 is not one of the types described in the previous item.

• f(t1, t2, ..., tN) in all other cases.

The pseudo-function INVOKE(f, t1, t2, ..., tN, R) means INVOKE(f, t1, t2, ..., tN) implicitly converted to R.

If a call wrapper has a weak result type, the type of its member type result_type is based on the type T of the target object of the wrapper, as follows:

• If T is a pointer to function, result_type is a synonym for the return type of T.

• If T is a pointer to member function, result_type is a synonym for the return type of T.

• If T is a pointer to data member, result_type is a synonym for the declared type of the data member.

• If T is a class type that has a member type result_type, then result_type is a synonym for T::result_type.

• Otherwise, there is no member result_type.

Every call wrapper has a copy constructor. A simple call wrapper is a call wrapper that has an assignment operator and whose copy constructor and assignment operator do not throw exceptions. A forwarding call wrapper is a call wrapper that can be called by using an argument list t1, t2, ..., tN, where each ti is an lvalue.

The call wrappers defined in this header support function call operators that have arguments of types T1, T2, ..., TN, where 0 <= N <= NMAX. In this implementation, the value of NMAX is 10.

See Also

Reference

Thread Safety in the Standard C++ Library

Standard Template Library

Other Resources

<functional> Members

Header Files

Change History