...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
An unary Polymorphic Function Object adapter template for Callable Object target functions. It takes a Forward Sequence that contains the arguments for the target function.
The result is discarded and the adapter's return type is void
.
The type of the target function is allowed to be const qualified or a reference.
Const qualification is preserved and propagated appropriately (in other
words, only const versions of operator()
can be used
for a target function object that is const or, if the target function object
is held by value, the adapter is const - these semantics have nothing to
do with the const qualification of a member function, which is referring
to the type of object pointed to by this
which is specified
with the first element in the sequence passed to the adapter).
If the target function is a pointer to a members function, the corresponding
object can be specified as a reference, pointer, or smart pointer. In case
of the latter, a freestanding get_pointer
function must
be defined (Boost provides this function for std::auto_ptr
and boost::shared_ptr
).
The target function must not be a pointer to a member object (dereferencing such a pointer without returning anything does not make sense, so this case is not implemented).
#include <boost/fusion/functional/adapter/fused_procedure.hpp>
template <typename Function> class fused_procedure;
Parameter |
Description |
Default |
---|---|---|
|
Callable Object type |
Notation
R
A possibly const qualified Callable Object type or reference type thereof
r
An object convertible to R
s
A Sequence of arguments that
are accepted by r
f
An instance of fused_procedure<R>
Expression |
Semantics |
---|---|
|
Creates a fused function as described above, initializes the
target function with |
|
Creates a fused function as described above, attempts to use
|
|
Calls |
template<class SequenceOfSequences, class Func> void n_ary_for_each(SequenceOfSequences const & s, Func const & f) {for_each
(zip_view
<SequenceOfSequences>(s), fused_procedure<Func const &>(f)); } void try_it() {vector
<int,float> a(2,2.0f);vector
<int,float> b(1,1.5f); using namespace boost::lambda; n_ary_for_each(vector_tie
(a,b), _1 -= _2); assert(a ==make_vector
(1,0.5f)); }