c++ - 使用 Boost.Phoenix 有什么好处？

Question

我无法理解使用 Boost.Phoenix 的真正好处是什么。

当我将它与 Boost.Spirit 语法一起使用时，它真的很有用:

double_[ boost::phoenix::push_back( boost::phoenix::ref( v ), _1 ) ]

当我将它用于 lambda 函数时，它也很有用且优雅:

boost::range::for_each( my_string, if_ ( '\\' == arg1 ) [ arg1 = '/' ] );

但是这个库中其他所有内容的好处是什么？文档说:“无处不在的仿函数”。不明白有什么好处？

Answer 1

我会指出 Boost.Lambda 和 Boost.Phoenix 之间的关键区别是什么:

Boost.Phoenix 支持(静态)多态仿函数，而 Boost.Lambda 绑定(bind)始终是单态的。

(同时，这两个库在很多方面是可以组合的，所以它们不是唯一的选择。)

让我举例说明(警告:代码未测试。):

凤凰

在 Phoenix 中，仿函数可以转换为 Phoenix“惰性函数”(来自 http://www.boost.org/doc/libs/1_54_0/libs/phoenix/doc/html/phoenix/starter_kit/lazy_functions.html)

struct is_odd_impl{
    typedef bool result_type; // less necessary in C++11
    template <typename Arg>
    bool operator()(Arg arg1) const{
        return arg1 % 2 == 1;
    }
};

boost::phoenix::function<is_odd_impl> is_odd;

is_odd 是真正的多态(作为仿函数 is_odd_impl)。那就是 is_odd(_1) 可以作用于任何东西(这是有道理的)。例如在 is_odd(_1)(2u)==true 和 is_odd(_1)(2l)==true 中。 is_odd 可以组合成更复杂的表达式，而不会失去其多态行为。

Lambda 尝试

在 Boost.Lambda 中我们最接近这个的是什么？我们可以定义两个重载:

bool is_odd_overload(unsigned arg1){return arg1 % 2 == 1;}
bool is_odd_overload(long     arg1){return arg1 % 2 == 1;}

但要创建一个 Lambda“惰性函数”，我们必须选择以下两者之一:

using boost::lambda::bind;
auto f0 = bind(&is_odd_overload, _1); // not ok, cannot resolve what of the two.
auto f1 = bind(static_cast<bool(*)(unsigned)>(&is_odd_overload), _1); //ok, but choice has been made
auto f2 = bind(static_cast<bool(*)(long)>(&is_odd_overload), _1); //ok, but choice has been made

即使我们定义了一个模板版本

template<class T>
bool is_odd_template(T arg1){return arg1 % 2 == 1;}

我们必须绑定(bind)到模板函数的特定实例，例如

auto f3 = bind(&is_odd_template<unsigned>, _1); // not tested

f1 和 f2 和 f3 都不是真正的多态，因为在绑定(bind)时已经做出选择。

(注意 1:这可能不是最好的例子，因为从 unsigned 到 long 的隐式转换，事情似乎可以正常工作，但这是另一回事。)

总而言之，给定一个多态函数/仿函数 Lambda 不能绑定(bind)到多态函数(据我所知)，而 Phoenix 可以。确实，Phoenix 依赖于“协议(protocol)结果”http://www.boost.org/doc/libs/1_54_0/libs/utility/utility.htm#result_of但是 1) 至少有可能，2) 这在 C++11 中问题不大，返回类型很容易推断并且可以自动完成。

其实在 C++11 中，Phoenix lambdas 还是比 C++11 更强大 内置 lambda。即使在 C++14 中，template 通用 lambda 实现了，Phoenix 还是比较通用的，因为它允许一个 一定程度的自省(introspection)。 (为此，乔尔·德 Guzman(Phoenix 的开发者)过去和现在都远远领先于他的 时间。)