Это не игрушечный пример. На самом деле это часть библиотеки. Помните<while>ленивое утверждение? Составляя все, что мы узнали до сих пор, мы представляем его здесь полностью (дословно):

BOOST_PHOENIX_DEFINE_EXPRESSION(
    (boost)(phoenix)(while_)
  , (meta_grammar)           // Cond
    (meta_grammar)           // Do
)
namespace boost { namespace phoenix
{
    struct while_eval
    {
        typedef void result_type;
        template <typename Cond, typename Do, typename Context>
        result_type
        operator()(Cond const& cond, Do const& do_, Context & ctx) const
        {
            while(eval(cond, ctx))
            {
                eval(do_, ctx);
            }
        }
    };
    template <typename Dummy>
    struct default_actions::when<rule::while_, Dummy>
        : call<while_eval, Dummy>
    {};
    template <typename Cond>
    struct while_gen
    {
        while_gen(Cond const& cond) : cond(cond) {}
        template <typename Do>
        typename expression::while_<Cond, Do>::type const
        operator[](Do const& do_) const
        {
            return expression::while_<Cond, Do>::make(cond, do_);
        }
        Cond const& cond;
    };
    template <typename Cond>
    while_gen<Cond> const
    while_(Cond const& cond)
    {
        return while_gen<Cond>(cond);
    }
}}

<while_eval>является примером того, как можно оценить выражение. Называется она в действии<rule::while>.<while_gen>и<while_>являются выражением шаблона передних концов. Давайте разобьём это на части, чтобы понять, что происходит. Давайте начнем снизу. Так проще.

Когда вы пишете:

while_(cond)

<while_gen<Cond>>, где<Cond>является типом<cond>.<cond>может быть произвольно сложным актерским выражением.<while_gen>класс шаблонов имеет<operator[]>принятие другого выражения. Если мы напишем:

while_(cond)
[
    do_
]

Он будет генерировать подходящий композит с типом:

expression::while_<Cond, Do>::type

<Cond>является типом<cond>и<Do>является типом<do_>. Обратите внимание, как мы используем механизм выражения Фениксаздесь.

template <typename Do>
typename expression::while_<Cond, Do>::type const
operator[](Do const& do_) const
{
    return expression::while_<Cond, Do>::make(cond, do_);
}

В конце концов,<while_eval>делает свое дело:

while(eval(cond, ctx))
{
    eval(do_, ctx);
}

<cond>и<do_>на данный момент являются примерамиАктера.<cond>и<do_>являютсяАктерыприняты в качестве параметров<call>, ctx являетсяКонтекст