我正在使用 QI 和 Phoenix,我想编写一个小语法来返回 4 个 bool 值,这些 bool 值将用作语义操作中函数调用的参数。
我有几个函数需要这些东西,到目前为止我已经使用了这种方法:
( 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 )]
.
这意味着,我的问题是解包参数以匹配要调用的函数的签名,因为参数的数量在签名级别不同(一个包含四个 bool 值的元组,而不是单独的四个 bool 值)。
是否可以直接使用 phoenix 占位符解包,而不是编写包装器,将元组转换为需要它们分开的现有函数的单独参数?
如果是,那么它的语法是什么?
毕竟,像 ( qi::_bool >> qi::_bool >> qi::_bool >> qi::_bool)
这样的内联版本在被 spirit “解包”时工作正常: :_1 - spirit::_4,
占位符。
这让我觉得好像这个版本也返回一个元组,并且在某种程度上无法用上述方法解包,这与返回元组的语法不同。
我该如何处理?
最佳答案
如果您不发布完整、连贯的重现,就几乎不可能诊断出您的问题;可能是语法错误,也可能是缺少 #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>
.
EDIT(响应 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++11 result_of
协议(protocol),而 Boost.Phoenix v2 实现了 Boost.Lambda result_of
协议(protocol)——这些不兼容。因此,您必须自己解压元组元素:
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++11 result_of
协议(protocol)。因此,从 Boost 1.47 开始,您将能够使用 boost::fusion::fused<>
并为自己省去一些乏味的样板文件。
关于c++ - boost::spirit::气。如何将内联解析器表达式变成独立的语法,以及如何解包它们生成的元组?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/6157584/