c++ - 提升::精神::气。如何将内联解析器表达式变成独立的语法，以及如何解包它们生成的元组？

Question

我正在使用 QI 和 Phoenix，我想编写一个返回 4 个布尔值的小语法，这些布尔值将用作语义操作中函数调用的参数。

我有几个需要这些东西的功能，到目前为止我已经使用了这种方法：

( qi::_bool >>  qi::_bool >>  qi::_bool >>  qi::_bool)
[px::bind(&Bool4Function, spirit::_val, spirit::_1, spirit::_2, spirit::_3, spirit::_4)]

虽然它本身没问题，但在整个地方使用它只是丑陋和令人困惑，即使“使用”命名空间部分也是如此。

这就是为什么我想把这个表达式提取成一个独立的语法。

所以我尝试了这个（归功于 ildjarn 的测试平台）：

///// grammar implementation /////
#include <boost/fusion/include/vector10.hpp>
#include <boost/spirit/include/qi_bool.hpp>
#include <boost/spirit/include/qi_char_.hpp>
#include <boost/spirit/include/qi_grammar.hpp>
#include <boost/spirit/include/qi_operator.hpp>
#include <boost/spirit/include/qi_rule.hpp>
#include <boost/spirit/include/qi_string.hpp>

struct FourBools : boost::spirit::qi::grammar<
    char const*,
    boost::fusion::vector4<bool, bool, bool, bool>()
>
{
    typedef boost::fusion::vector4<bool, bool, bool, bool> attribute_type;

    FourBools() : base_type(start_)
    {
        using boost::spirit::bool_;

        start_
            =   "4bools:"
            >> bool_ >> ','
            >> bool_ >> ','
            >> bool_ >> ','
            >> bool_ >> ';'
            ;
    }

private:
    boost::spirit::qi::rule<
        base_type::iterator_type,
        base_type::sig_type
    > start_;
};
FourBools const fourBools;


///// demonstration of use /////
#include <string>
#include <ios>
#include <iostream>
#include <boost/fusion/include/at_c.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/qi_action.hpp>
#include <boost/spirit/include/qi_parse.hpp>



void noDice(bool a, bool b, bool c, bool d) 
{

}

void worksFine(boost::fusion::vector4<bool, bool, bool, bool> a)
{

}
int main()
{
    namespace phx = boost::phoenix;
    namespace spirit = boost::spirit;

    std::string const input("4bools:true,true,true,false;");


    char const* first = input.c_str();
    char const* const last = first + input.size();
    bool const success = spirit::qi::parse(
        first, last,
        fourBools[phx::bind(&noDice, spirit::_1)]
    );


    if (!success)
        std::cout << "parse() failed\n";
    else if (first != last)
        std::cout << "didn't consume all input\n";
    std::cout.flush();
}

除非fourBools[phx::bind(&noDice, spirit::_1)]用fourBools[phx::bind(&worksFine, spirit::_1)].

这意味着，我的问题是解包参数以匹配要调用的函数的签名，因为参数的数量在签名级别不同（四个布尔值的一个元组，而不是四个布尔值）。

是否可以直接使用 phoenix 占位符进行解包，而不是编写将元组转换为需要将它们分开的现有函数的单独参数的包装器？如果是，那将是什么语法？毕竟，当被占位符( qi::_bool >> qi::_bool >> qi::_bool >> qi::_bool)“解包”时，像这样的内联版本可以正常工作。spirit::_1 - spirit::_4,

这让我觉得这个版本好像也返回一个元组，并且在某种程度上无法使用上述方法解包，这与返回一个的语法不同。

我该如何处理？

score 12 · Accepted Answer

如果您不发布完整、连贯的复制品，几乎不可能诊断出您的问题；可能是语法错误，也可能是缺失#include，谁知道..？

这是一个工作演示；希望您可以将其用作参考，以找出您的代码有什么问题：

///// grammar implementation /////
#include <boost/fusion/include/vector10.hpp>
#include <boost/spirit/include/qi_bool.hpp>
#include <boost/spirit/include/qi_char_.hpp>
#include <boost/spirit/include/qi_grammar.hpp>
#include <boost/spirit/include/qi_operator.hpp>
#include <boost/spirit/include/qi_rule.hpp>
#include <boost/spirit/include/qi_string.hpp>

struct FourBools : boost::spirit::qi::grammar<
    char const*,
    boost::fusion::vector4<bool, bool, bool, bool>()
>
{
    typedef boost::fusion::vector4<bool, bool, bool, bool> attribute_type;

    FourBools() : base_type(start_)
    {
        using boost::spirit::bool_;

        start_
            =   "4bools:"
                >> bool_ >> ','
                >> bool_ >> ','
                >> bool_ >> ','
                >> bool_ >> ';'
            ;
    }

private:
    boost::spirit::qi::rule<
        base_type::iterator_type,
        base_type::sig_type
    > start_;
};
FourBools const fourBools;


///// demonstration of use /////
#include <string>
#include <ios>
#include <iostream>
#include <boost/fusion/include/at_c.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/qi_action.hpp>
#include <boost/spirit/include/qi_parse.hpp>

typedef FourBools::attribute_type attr_t;

struct verify_same
{
    explicit verify_same(attr_t const& expected) : expected_(expected) { }

    void verify(attr_t const& actual) const
    {
        using boost::fusion::at_c;

        std::cout << std::boolalpha
            << "same as expected: " << (actual == expected_)
            << "\nactual values: "
            << at_c<0>(actual) << ' '
            << at_c<1>(actual) << ' '
            << at_c<2>(actual) << ' '
            << at_c<3>(actual) << '\n';
    }

private:
    attr_t expected_;
};

int main()
{
    namespace phx = boost::phoenix;
    namespace spirit = boost::spirit;

    std::string const input("4bools:true,true,true,false;");
    verify_same const vs(attr_t(true, true, true, false));

    char const* first = input.c_str();
    char const* const last = first + input.size();
    bool const success = spirit::qi::parse(
        first, last,
        fourBools[phx::bind(&verify_same::verify, phx::cref(vs), spirit::_1)]
    );
    if (!success)
        std::cout << "parse() failed\n";
    else if (first != last)
        std::cout << "didn't consume all input\n";
    std::cout.flush();
}

顺便说一句，我认为使用纯同质类型的元组很奇怪。就个人而言，我会将语法的综合属性更改为boost::array<bool, 4>.

编辑（响应 OP 的编辑）：有好消息，也有坏消息，还有更多好消息。

好消息是：Boost.Fusion的功能可以用最少的代码完成您想做的事情：boost::fusion::fused<>. 这将采用带有多个参数的可调用类型（包括自由函数指针和成员函数指针），并将该可调用类型包装在采用 Fusion 序列的仿函数中；当这个函子被调用时，它接受 Fusion 序列并将其解包，将元组的各个元素作为单独的参数转发到包装的可调用类型。

因此，鉴于我已经发布的语法以及以下内容：

#include <string>
#include <ios>
#include <iostream>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/include/make_fused.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/qi_action.hpp>
#include <boost/spirit/include/qi_parse.hpp>

typedef FourBools::attribute_type attr_t;

void free_func_taking_tuple(attr_t const& tup)
{
    using boost::fusion::at_c;

    std::cout << std::boolalpha
        << "inside free_func_taking_tuple() :: "
        << at_c<0>(tup) << ' '
        << at_c<1>(tup) << ' '
        << at_c<2>(tup) << ' '
        << at_c<3>(tup) << '\n';
}

void free_func_taking_bools(
    bool const a, bool const b,
    bool const c, bool const d
)
{
    std::cout << std::boolalpha
        << "inside free_func_taking_bools() :: "
        << a << ' '
        << b << ' '
        << c << ' '
        << d << '\n';
}

boost::spirit::qi::parse()可以这样调用：

namespace phx = boost::phoenix;
namespace spirit = boost::spirit;
using boost::fusion::make_fused;

// calls free_func_taking_tuple, nothing new here
spirit::qi::parse(
    first, last,
    fourBools[phx::bind(free_func_taking_tuple, spirit::_1)]
);

// calls free_func_taking_bools, using boost::fusion::fused<> to unpack the tuple
// into separate arguments
spirit::qi::parse(
    first, last,
    fourBools[phx::bind(make_fused(&free_func_taking_bools), spirit::_1)]
);

坏消息是：Boost.Fusion 的可调用类型包装器依赖于 TR1/C++11result_of协议，而 Boost.Phoenix v2 实现了 Boost.Lambdaresult_of协议——它们不兼容。因此，您必须自己解包元组元素：

namespace phx = boost::phoenix;
namespace spirit = boost::spirit;

spirit::qi::parse(
    first, last,
    fourBools[phx::bind(
        free_func_taking_bools,
        phx::at_c<0>(spirit::_1),
        phx::at_c<1>(spirit::_1),
        phx::at_c<2>(spirit::_1),
        phx::at_c<3>(spirit::_1)
    )]
);

呸！但是，还有更多好消息：Boost.Phoenix v3 将在 Boost 1.47 中发布，它实现了 TR1/C++11result_of协议。因此，从 Boost 1.47 开始，您将能够使用boost::fusion::fused<>并为自己节省一些乏味的样板文件。

score 3 · Accepted Answer

作为一般说明，我建议在这里阅读 Spirit 网站上有关属性处理的文章。这些构成了随图书馆分发的在线文档的一个很好的附录。

score 0 · Accepted Answer

qi::_bool >> qi::_bool >> qi::_bool >> qi::_boolis或任何其他 stl 容器的属性std::vector<bool>，如参考中所述：http: //www.boost.org/doc/libs/1_46_0/libs/spirit/doc/html/spirit/qi/quick_reference/compound_attribute_rules.html .

表的第一行就是这种情况：）

c++ - 提升::精神::气。如何将内联解析器表达式变成独立的语法，以及如何解包它们生成的元组？

3 回答 3

Related

Reference