...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
An n-ary Polymorphic Function Object adapter template for an unary Polymorphic Function Object target function. When called, its arguments are bundled to a Random Access Sequence of references that is passed to the target function. Non-const LValue arguments are transported as references to non-const, otherwise references to const are used.
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 if the target function object is const - or, in case the target function object is held by value, the adapter is const).
/functional/adapter/unfused_generic.hpp>
template <class Function> class unfused_generic;
Parameter |
Description |
Default |
---|---|---|
Function |
An unary Polymorphic Function Object |
|
Notation
A possibly const qualified, unary Polymorphic Function Object type or reference type thereof
An object convertible to F
The type unfused_generic<F>
An instance of UG, initialized with f
Arguments to ug
Expression |
Semantics |
---|---|
UG(f) |
Creates a fused function as described above, initializes the target function with f. |
UG() |
Creates a fused function as described above, attempts to use F's default constructor. |
ug(a0...aN) |
Calls f with a Sequence that contains references to the arguments a0...aN. |
template <typename Function, typename T> class fused_bound_1st { typename traits::deduce<Function>::type fnc_deferred; typename traits::deduce<T>::type xxx_bound; public: fused_bound_1st(Function deferred, T bound) : fnc_deferred(deferred), xxx_bound(bound) { } template <typename Sig> struct result; template <class Self, class Seq> struct result< Self(Seq) > : result_of::invoke< Function, typename result_of::push_front< typename remove_reference<Seq>::type, T>::type > { }; template <class Seq> typename result< void(Seq) >::type operator()(Seq const & s) const { return invoke(fnc_deferred, push_front(s,xxx_bound)); } }; template <typename Function, typename T> unfused_generic< fused_bound_1st<Function,T> > bind_1st(Function f, T const & x) { return unfused_generic< fused_bound_1st<Function,T> >( fused_bound_1st<Function,T>(f,x) ); } int test_func(int a, int b, int c) { return a+b+c; } void try_it() { assert(bind_1st(& test_func,3)(-2,-1) == 0); assert(bind_1st(std::plus<float>(), 1)(0.5f) == 1.5f); }