Если вы хотите приспособить уже существующие функции или функциональные объекты, это станет репрезентативной задачей. Для этого предоставляются следующие макросы boilerplate, чтобы помочь вам адаптировать уже выходящие функции, тем самым уменьшая потребность в функциях phoenix.modules.bind.

BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY

Description

BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY - это макрос, который может быть использован для генерации всего необходимого бойлерпланта, чтобы сделать произвольную нулярную функцию ленивой функцией.

	Note
	Эти макросы не генерируют глобальных объектов. Полученные ленивые функции являются реальными функциями, которые создают объект выражения ленивых функций

Synopsis

BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY(
    RETURN_TYPE
  , LAZY_FUNCTION
  , FUNCTION
)

Semantics

Вышеупомянутый макрос генерирует весь необходимый код, чтобы иметь нулевую ленивую функцию LAZY_FUNCTION, которая называет нулевую FUNCTION, которая имеет тип возврата RETURN_TYPE

Header

#include <boost/phoenix/function/adapt_function.hpp>

Example

namespace demo
{
    int foo()
    {
        return 42;
    }
}
BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY(int, foo, demo::foo)
int main()
{
    using boost::phoenix::placeholders::_1;
    assert((_1 + foo())(1) == 43);
}

BOOST_PHOENIX_ADAPT_FUNCTION(
    RETURN_TYPE
  , LAZY_FUNCTION
  , FUNCTION
  , FUNCTION_ARITY
)

#include <boost/phoenix/function/adapt_function.hpp>

namespace demo
{
    int plus(int a, int b)
    {
        return a + b;
    }
    template <typename T>
    T
    plus(T a, T b, T c)
    {
        return a + b + c;
    }
}
BOOST_PHOENIX_ADAPT_FUNCTION(int, plus, demo::plus, 2)
BOOST_PHOENIX_ADAPT_FUNCTION(
    typename remove_reference<A0>::type
  , plus
  , demo::plus
  , 3
)
int main()
{
    using boost::phoenix::arg_names::arg1;
    using boost::phoenix::arg_names::arg2;
    int a = 123;
    int b = 256;
    assert(plus(arg1, arg2)(a, b) == a+b);
    assert(plus(arg1, arg2, 3)(a, b) == a+b+3);
}

BOOST_PHOENIX_ADAPT_CALLABLE_NULLARY(
    LAZY_FUNCTION
  , CALLABLE
)

#include <boost/phoenix/function/adapt_callable.hpp>

namespace demo
{
    struct foo
    {
        typedef int result_type;
        result_type operator()() const
        {
            return 42;
        }
    }
}
BOOST_PHOENIX_ADAPT_CALLABLE_NULLARY(foo, demo::foo)
int main()
{
    using boost::phoenix::placeholders::_1;
    assert((_1 + foo())(1) == 43);
}

BOOST_PHOENIX_ADAPT_CALLABLE(
    LAZY_FUNCTION
  , FUNCTION_NAME
  , FUNCTION_ARITY
)

#include <boost/phoenix/function/adapt_callable.hpp>

namespace demo
{
    struct plus
    {
        template <typename Sig>
        struct result;
        template <typename This, typename A0, typename A1>
        struct result<This(A0, A1)>
            : remove_reference<A0>
        {};
        template <typename This, typename A0, typename A1, typename A2>
        struct result<This(A0, A1, A2)>
            : remove_reference<A0>
        {};
        template <typename A0, typename A1>
        A0 operator()(A0 const & a0, A1 const & a1) const
        {
            return a0 + a1;
        }
        template <typename A0, typename A1, typename A2>
        A0 operator()(A0 const & a0, A1 const & a1, A2 const & a2) const
        {
            return a0 + a1 + a2;
        }
    };
}
BOOST_PHOENIX_ADAPT_CALLABLE(plus, demo::plus, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(plus, demo::plus, 3)
int main()
{
    using boost::phoenix::arg_names::arg1;
    using boost::phoenix::arg_names::arg2;
    int a = 123;
    int b = 256;
    assert(plus(arg1, arg2)(a, b) == a+b);
    assert(plus(arg1, arg2, 3)(a, b) == a+b+3);
}