...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
The function
class template
provides a mechanism for implementing lazily evaluated functions. Syntactically,
a lazy function looks like an ordinary C/C++ function. The function call
looks familiar and feels the same as ordinary C++ functions. However, unlike
ordinary functions, the actual function execution is deferred.
#include <boost/phoenix/function.hpp>
Unlike ordinary function pointers or functor objects that need to be explicitly bound through the bind function (see Bind), the argument types of these functions are automatically lazily bound.
In order to create a lazy function, we need to implement a model of the
Polymorphic
Function Object concept. For a function that takes N
arguments, a model of Polymorphic
Function Object must provide:
operator()
that takes N
arguments,
and implements the function logic. This is also true for ordinary function
pointers.
result<Signature>
or nested typedef result_type
,
following the Boost.Result
Of Protocol
For example, the following type implements the FunctionEval concept, in order to provide a lazy factorial function:
struct factorial_impl { template <typename Sig> struct result; template <typename This, typename Arg> struct result<This(Arg const &)> { typedef Arg type; }; template <typename Arg> Arg operator()(Arg const & n) const { return (n <= 0) ? 1 : n * (*this)(n-1); } };
(See factorial.cpp)
Having implemented the factorial_impl
type, we can declare and instantiate a lazy factorial
function this way:
function<factorial_impl> factorial;
Invoking a lazy function such as factorial
does not immediately execute the function object factorial_impl
.
Instead, an actor object is created
and returned to the caller. Example:
factorial(arg1)
does nothing more than return an actor. A second function call will invoke the actual factorial function. Example:
std::cout << factorial(arg1)(4);
will print out "24".
Take note that in certain cases (e.g. for function objects with state), an instance of the model of Polymorphic Function Object may be passed on to the constructor. Example:
function<factorial_impl> factorial(ftor);
where ftor is an instance of factorial_impl (this is not necessary in this
case as factorial_impl
does
not require any state).
Important | |
---|---|
Take care though when using function objects with state because they are often copied repeatedly, and state may change in one of the copies, rather than the original. |