记录的签名here：

void f(Attrib const&);
void f(Attrib const&, Context&);
void f(Attrib const&, Context&, bool&);

• 注意函数对象的精度。我认为差异只是由于遗留C++03兼容性 *

是低级，我们可以说是“原始”语义动作函数。只有当您是一个库开发人员，希望了解有关Context如何静态组成和动态访问的所有细节时，它们才是有趣的。
上下文包含skippers、本地属性、继承属性、合成属性、绑定属性引用 * 和 * parse-result标志。
人们使用Phoenix表达式来创建具体的语义动作，而不是处理这些签名。Qi defines placeholder actors对应于上下文元素：

• _1，_2 ...，_N

p的第n个属性

• _val

封闭规则的合成属性。

• _r1，_r2 ...，_rN

封闭规则的第N个继承属性。

• _a，_b ...，_j

封闭规则的局部变量（_a指第一个）。

• _pass

将false赋给_pass以强制解析器失败。
您已经选择了Phoenix（使用phoenix::bind）。所以我建议你还是采用Phoenix式的动作。让你的例子工作的最简单的方法：

qi::_val = boost::phoenix::bind(
        [](const std::string&, const boost::optional<std::string>&, bool& pass)
        {    pass = rand()%2;   
             return std::string();
        },
        qi::_1,
        qi::_2,
        qi::_pass
)

奖励/升级

但请注意，您也可以***雇用更多的高级Phoenix设施。
我个人更喜欢Phoenix改编的callables。例如，让我们编写一个功能性更强的语义动作：

struct magic_f {
    std::string operator()(std::string const& s1, boost::optional<std::string> s2, bool& pass) const {
        if (s2) {
            std::reverse(s2->begin(), s2->end());
        } else {
            s2 = s1;
        }
        pass = (s1 == s2);
        return std::move(s2.value());
    }
};

它实现的验证逻辑是：如果存在第二个字符串，则它必须与第一个字符串 * 反向 * 匹配。
现在，您可以使用phoenix::function创建相应的actor：

boost::phoenix::function<magic_f> magic;

这意味着您可以简单地编写操作：

word  = +qi::graph;
pair  = (word >> -word)[ _val = magic(_1, _2, _pass) ];

看到这个**Live On Coliru**

#include <boost/spirit/include/qi.hpp>
#include <boost/phoenix.hpp>
#include <iomanip>
namespace qi = boost::spirit::qi;
using Word = std::string;
template <typename It> struct Demo : qi::grammar<It, Word()> {
    Demo() : Demo::base_type(start) {
        using namespace qi::labels; // for the phoenix expression placeholders
        word  = +qi::graph;
        pair  = (word >> -word)[ _val = magic(_1, _2, _pass) ];
        start = qi::skip(qi::space)[ pair ];
    }
  private:
    struct magic_f {
        Word operator()(Word const& s1, boost::optional<Word> s2, bool& pass) const {
            if (s2)
                std::reverse(s2->begin(), s2->end());
            else
                s2 = s1;
            pass = (s1 == s2);
            return std::move(s2.value());
        }
    };
    boost::phoenix::function<magic_f> magic;
    qi::rule<It, Word()> start, word;
    qi::rule<It, Word(), qi::space_type> pair;
};
int main() {
    static Demo<Word::const_iterator> const p;
    for (std::string const s : {"", "foo", "foo foo", "foo bar", "foo oof", "bar bra", "bar rab"})
        if (Word word; parse(begin(s), end(s), p, word))
            std::cout << std::setw(12) << quoted(s) << " -> MATCH " << quoted(word) << std::endl;
        else
            std::cout << std::setw(12) << quoted(s) << " -> FAIL" << std::endl;
}

输出：

"" -> FAIL
       "foo" -> MATCH "foo"
   "foo foo" -> FAIL
   "foo bar" -> FAIL
   "foo oof" -> MATCH "foo"
   "bar bra" -> FAIL
   "bar rab" -> MATCH "bar"

观察结果：

请注意，这样你就不需要把bool& pass作为参数了。相反，你可以返回bool：

struct magic_f {
    bool operator()(Word& s1, boost::optional<Word> s2, Word& out) const {
        if (s2) {
            std::reverse(s2->begin(), s2->end());
            if (s1!=s2)
                return false;
        }
        out = std::move(s1);
        return true;
    }
};

并将动作写为：

pair  = (word >> -word)[ _pass = magic(_1, _2, _val) ];

关于exact same results
通常，您可以利用现有的参与者（例如对于标准库函数和运算符），并且根本不使用自定义函数编写，例如匹配一个词，只有当它的长度：

pair %= word >> qi::omit[qi::int_[_pass = size(_val) == _1]];

看到它**Live On Coliru**

C++17甜

在C++17中，由于CTAD，可以方便地使用lambda表达式。这样就可以避免像以前一样定义magic_f类型：

boost::phoenix::function magic = [](auto& s1, auto& s2, bool& pass) {
    if (s2)
        std::reverse(s2->begin(), s2->end());
    else
        s2 = s1;
    pass = (s1 == s2);
    return std::move(s2.value());
};
word  = +qi::graph;
pair  = (word >> -word)[ _val = magic(_1, _2, _pass) ];

看到它**Live On Coliru**