boost 的函数式编程库 Phoenix入门学习

这篇文章是我学习boost phoenix的总结。

序言

Phoenix是一个C++的函数式编程（function programming)库。Phoenix的函数式编程是构建在函数对象上的。因此，了解Phoenix，必须先从它的基础函数对象上做起。

Phoenix能够提供令人惊艳的编码效果。我先撂一个出来，看看用Phoenix能写出什么样的代码：

    std::for_each(vec.begin(), vec.end(),        if_(arg1 > 5)        [            std::cout << arg1 << ">5\n"        ]        .else_        [            if_(arg1 == 5)            [                std::cout << arg1 << "== 5\n"            ]            .else_            [                std::cout << arg1 << "< 5\n"            ]        ]    );

这是C++代码？答案是肯定的！只需要C++编译器，不需要任何额外的工具，就能实现这样的效果。这是怎么回事？且看下面逐步分解。

在此之前，编译phoenix库必须

包含核心头文件

#include <boost/phoenix/core.hpp>

注意，不要使用using namespace boost::phoenix,而要直接使用using boost::phoenix::val, ....，如

using boost::phoenix::val;using boost::phoenix::arg_names::arg1;using boost::phoenix::arg_names::arg2;using boost::phoenix::case_;using boost::phoenix::ref;using boost::phoenix::for_;using boost::phoenix::let;using boost::phoenix::lambda;using boost::phoenix::local_names::_a;

为什么不要直接使用using namespace boost::phoenix呢？因为这样会带来不可预知的问题。这是我在实践中发现的。boost的宏BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY以及类似的宏，会出现编译错误。真实的原因是什么，没有细致考究。

另外一个原因是，要防止不必要的命名污染，因为phoenix用了很多和boost库冲突的名称，这些在使用的时候，很容易造成问题。

基础函数对象

values

包含头文件：

#include <boost/phoenix/core.hpp>

使用命名空间：

using boost::phoenix::val;

例子

val(3)val("Hello, World")

val(3) 生成一个包含整数3的函数对象。val("Hello, World")则是一个包含字符串的函数对象。

他们是函数对象，因此，你可以象函数那样调用他们

std::cout << val(3)() << val("Hello World")()<<std::endl;

val(3)() 将返回值3， val("Hello World")() 将返回值"Hello World"。

也许，你会觉得，这简直是多此一举。但是，事实上，你没有明白phoenix的真正用以。

val(3)和val("Hello World") 实际上实现了一个懒惰计算的功能，将对3和"Hello World"的求值，放在需要的时候。

上面的表达式，还可以写成这样

(std::cout << val(3) << val("Hello World")<<std::endl)();

括号中std::cout << .. 这一长串，实际上生成了一个函数对象，因此我们才能在需要的时候，调用这个函数对象。

这是val的真正威力，它让求值推迟到需要的时候。在普通编程中，我们必须通过类和接口才能完成。

References

包含头文件

#include <boost/phoenix/core.hpp>

使用命名空间

using boost::phoenix::ref;

如果声明了如下变量：

    int i = 3;    char const* s = "Hello World";    std::cout << (++ref(i))() << std::endl;    std::cout << ref(s)() << std::endl;

ref与val都是可以延迟求值的，但是，不同的是，ref相当于 int& 和 char const*& 的调用。

因此，上面 (++ref(i))()的返回值是4，而且，变量i的值也将变为4.

references是phoenix的函数对象和外部变量交换数据的桥梁。

Arguments

还记得boost中有_1, _2, _3, ...这些东西吗？在phoenix中有一种类似的 arg1, arg2, arg3, ...。他们有相似的作用，但是arg1 事实上是函数对象。

包含头文件

#include <boost/phoenix/core.hpp>

使用命名空间

using boost::phoenix::arg_names::arg1;using boost::phoenix::arg_names::arg2;using boost::phoenix::arg_names::arg3;....

看下面的例子

    std::cout << arg1(3) << std::endl;    std::cout << arg2(2, "hello world") << std::endl;

输出的结果是 3, "Hello world"。 

• arg1接收1个以上的参数，然后返回第1个参数
• arg2接受2个以上的参数，然后返回第2个参数
• arg3接受3个以上的参数，然后返回第3个参数

依次类推。

那么，这样的东西有什么用呢？它实际上是用来提取参数的。arg1提取第一个参数，arg2提取第二个参数，....

比如，我们有一个函数

void testArg(F f){    f(1,2,3);}...int main(){    testArg(std::cout<<arg1<<"-"<<arg2<<"-"<<arg3<<std::endl);}

std::cout ... 这一长串生成了一个函数对象。arg1 ，arg2, arg3分别提取了testArg传递的参数1，2，3。因此，这个函数会返回"1-2-3"。如果你将arg1和arg3的位置兑换下，返回的结果将是"3-2-1"。

Lazy Operators

操作符也可以生成函数对象。

头文件

#include <boost/phoenix/operator.hpp>

无需命名空间

看个例子

std::find_if(vec.begin(), vec.end(), arg1 %2 == 1);

find_if的功能是查找第一个符合条件的对象，然后返回。它要求最后一个参数为一个函数或者函数对象。那么 arg1 %2 == 1是一个函数对象吗？

答案是肯定的！。

它一共涉及两个操作符 %和 == 。 arg1 % 2 生成一个函数对象，新生成的函数对象在通过 == 操作符，又生成了新的对象。

它实际上就是

auto func1 = operator % (arg1, 2);auto func2 = operator == (func1, 1);

最后的func2被传递给了find_if。

phoenix支持所有的操作符，包括一元操作符在内，

如：

1 << 3;      // Immediately evaluatedval(1) << 3; // Lazily evaluated

支持的单目运算符有

prefix:   ~, !, -, +, ++, --, & (reference), * (dereference)postfix:  ++, --

支持的双目运算符有

=, [], +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=+, -, *, /, %, &, |, ^, <<, >>==, !=, <, >, <=, >=&&, ||, ->*

三目运算符

if_else(c, a, b)

支持成员函数指针操作

struct A{    int member;};A* a = new A;...(arg1->*&A::member)(a); // returns member a->member

arg1->*&A::member实现一个对A对象的访问操作。

Lazy Statements

懒惰语句。

头文件

#include <boost/phoenix/statement.hpp>

命名空间

using boost::phoenix::if_;using boost::phoenix::switch_;using boost::phoenix::case_;using boost::phoenix::while_;using boost::phoenix::for_;....

我们看看if_的例子

    std::for_each(vec.begin(), vec.end(),        if_(arg1 > 5)        [            std::cout << arg1 << ","        ]        );

虽然看起来很奇怪，但是，它的确是C++的语法。这个里面也充斥了函数对象。我们可以这样看

if_.operator()(      operator > (arg1, 5) ) .operator[](    operator<<(               operator<<(std::cout, arg1)             , ","))

Lazy Statement还有很多类似的语法。它的目的是为了模拟C++的语法。用C++模拟C++！

它用逗号代替分号，模拟语句序列，如

statement,statement,....statement

主要，最后一条"语句"(实际上是函数对象），不能有“，”，如是这样

statement,statement,statement, // ERROR!

就错了。

可以用括号来扩住一些语句（即函数对象）

statement,statement,(    statement,    statement),statement

括号也可以用在最外层，将语句（即函数对象）进行分组，如

std::for_each(c.begin(), c.end(),    (        do_this(arg1),        do_that(arg1)    ));

Construct, New, Delete, Casts

可以重载类的这些实现：

construct<std::string>(arg1, arg2)  // constructs a std::string from arg1, arg2new_<std::string>(arg1, arg2)       // makes a new std::string from arg1, arg2delete_(arg1)                       // deletes arg1 (assumed to be a pointer)static_cast_<int*>(arg1)            // static_cast's arg1 to an int*

函数适配器

头文件

#include <boost/phoenix/function.hpp>

命名空间

boost::phoenix::function

函数对象包装

考虑一个factorial函数

struct factorial_impl{    template <typename Sig>    struct result;        template <typename This, typename Arg>    struct result<This(Arg)>        : result<This(Arg const &)>    {};    template <typename This, typename Arg>    struct result<This(Arg &)>    {        typedef Arg type;    };    template <typename Arg>    Arg operator()(Arg n) const    {        return (n <= 0) ? 1 : n * this->operator()(n-1);    }};

解析一个这个实现：

factorial_impl的result声明是必须的，这是phoenix的模板要求的。result的声明使用了半实例化模板

    template <typename Sig>    struct result;

这是声明一个主模板，当然，主模板没有任何用处，因此只声明不定义。

    template <typename This, typename Arg>    struct result<This(Arg &)>    {        typedef Arg type;    };

这是一个半实例化的模板。从 result<This(Arg&)>可以看出。 This(Arg&)声明一个返回对象为 This, 参数为Arg& 的函数。

后面，Arg operator()(Arg)就是函数对象的实现体了。

使用时，需要这样

intmain(){    using boost::phoenix::arg_names::arg1;    boost::phoenix::function<factorial_impl> factorial;    int i = 4;    std::cout << factorial(i)() << std::endl;    std::cout << factorial(arg1)(i) << std::endl;    return 0;}

适配函数宏

上面的代码，书写起来，还是比较麻烦的，因此，phoniex提供了几个宏，用于帮助实现函数对象的适配。

针对普通函数的宏

BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY

BOOST_PHOENIX_ADAPT_FUNCTION

它的语法是

BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY(    RETURN_TYPE  , LAZY_FUNCTION  , FUNCTION)

BOOST_PHOENIX_ADAPT_FUNCTION(    RETURN_TYPE  , LAZY_FUNCTION  , FUNCTION  , FUNCTION_ARITY)

NULLARY表明是没有参数的。

针对NULLARY的例子：

声明函数:

namespace demo{    int foo()    {           return 42;     }   }

生成函数对象

BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY(int, foo, demo::foo)

使用它：

std::cout << "foo()():"<<foo()() << std::endl;

foo() 返回一个函数对象。 foo是一个函数，你可以认为是函数对象的工厂。

带参数的例子

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, myplus, demo::plus, 2)BOOST_PHOENIX_ADAPT_FUNCTION(    typename boost::remove_reference<A0>::type    , myplus    , demo::plus    , 3     )   

这样使用

    int a = 123;    int b = 256;    std::cout<<"myplus:"<<(myplus(arg1, arg2)(a, b)) << std::endl;    std::cout<<"myplus<3>:"<<(myplus(arg1, arg2, 3)(a, b)) << std::endl;

myplus(arg1, arg2, 3) 生成一个函数对象，这个函数对象接收两个整数参数。

至于细节，了解不是很多，不管怎么样，用就是了。

针对函数对象的宏

BOOST_PHOENIX_ADAPT_CALLABLE_NULLARY

BOOST_PHOENIX_ADAPT_CALLABLE

在使用上，同FUNCTION对应的函数，但是，它是针对函数对象的。

如

namespace demo{    struct foo2 {        typedef int result_type;        int operator()() const        {            return 42;        }    };}BOOST_PHOENIX_ADAPT_CALLABLE_NULLARY(foo2, demo::foo2)

声明方法和BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY 几乎是一样的，但是它不需要给出返回值。

值得注意的是，foo2中 typedef int result_type;的声明是必须的，因为，它是phonix模板要求的，一旦没有，就会出错。

带有重载的例子

namespace demo{    struct plus    {        template<typename Sig>        struct result;        template<typename This, typename A0, typename A1>        struct result<This(A0, A1)>            :boost::remove_reference<A0>            {};        template<typename This, typename A0, typename A1, typename A2>        struct result<This(A0, A1,A2)>            :boost::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)

struct result的声明也是使用了半实例化的技巧。需要给出参数个数，这个是很重要的。

语句

语句在上面提到过，这里介绍更多的语句

if_else_语句

我们开头看到的，就是一个if_else_语句

    std::for_each(vec.begin(), vec.end(),        if_(arg1 > 5)        [            std::cout << arg1 << ">5\n"        ]        .else_        [            if_(arg1 == 5)            [                std::cout << arg1 << "== 5\n"            ]            .else_            [                std::cout << arg1 << "< 5\n"            ]        ]    );

if_最终生成了一个函数对象，它还有一个.else_对象，这个对象也是一个函数对象，可以接收任何函数对象。于是，这样就被层层包含起来，形成了上面的奇观。

switch_语句

看这个例子

    std::for_each(vec.begin(), vec.end(),        switch_(arg1)        [            case_<1>(std::cout<<arg1<<":"<<val("one") << "\n"),            case_<2>(std::cout<<arg1<<":"<<val("two") << "\n"),            default_(std::cout<<arg1<<":"<<val("other value") << "\n")        ]    );

注意default_后面是不加","的。

case_和default_都是函数对象。

while_语句

例子：

    int value;    std::for_each(vec.begin(), vec.end(),        (            ref(value) = arg1,            while_(ref(value)--)            [                std::cout<<ref(value)<<","            ],            std::cout << val("\n")        )    );

我用了ref(value)来作为临时变量。

这样的代码写起来，和对应的C++代码很相似。但是它实际上是一堆函数对象的组合。它是延迟加载的，这一点很重要。

与之相似的还有do_while_循环。

for_语句

    int iii;    std::for_each(vec.begin(), vec.end(),        (            for_(ref(iii) = 0, ref(iii) < arg1, ++ ref(iii))            [                std::cout << arg1 << ", "            ],            std::cout << val("\n")        )    );

无语了。

其他语句

另外还有，try_catch_和throw_语句，实现原理都差不多。

总结

以上的介绍是浅尝辄止，phoenix还有很多高级的东西未曾涉及，有兴趣的读者可以看boost相关内容。

phoenix让我重新认识了C++的模板。C++的模板是C++元编程的重要利器。它甚至一定程度上改变了C++语言的语法。

不过，个人觉得，phoenix也有些过度设计。其实，语句部分，可以通过编写专门的函数来实现。这对大多数人来说，也就是多敲几行代码的问题。

我觉得有价值的是phoenix对函数的包装，使得C++的函数具备了懒计算的能力。

懒计算避免了我们定义N多接口，以及和N多接口配合的N^N的类工厂和派生类。

使用FP编程，不必像OO编程那样，设计者为了保证接口的兼容性，绞尽脑汁的设计接口；使用者不必为了实现一个简单的功能，派生一大堆类，和一大堆工厂。

设计者根据需要，要求传递函数对象即可；使用者只需要包装一个自己的实现给它使用，一切都搞定了。