Boost 将数据分配给规则内向量中的给定元素

我试图建立一个解析器，给定一个值，它可以将它分配给向量的某个元素，但我不完全确定如何实现它

假设下面的代码分析字符串

（0）{**++}

。它应该为每个

+

增加

bar.a[0]

一次，为每个

*

增加

bar.b[0]

一次。我遇到的问题是，我不确定如何使用

\u a

获取对向量元素的引用：

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <vector>

//The struct containing the vector.
struct testStruct {
    std::vector<int> a, b;
};

BOOST_FUSION_ADAPT_STRUCT (
    testStruct,
    (std::vector<int>, a)
    (std::vector<int>, b)
)

namespace qi = boost::spirit::qi;
namespace phoenix = boost::phoenix;
namespace ascii = boost::spirit::ascii;

template<typename Iterator>
struct foo : qi::grammar<Iterator, testStruct(), qi::locals<unsigned>, ascii::space_type> {
    foo() : foo::base_type(start) {
        using namespace qi::labels;
        using qi::eps;
        using qi::lit;
        using qi::uint_;
        using phoenix::at_c;

        start = lit('(')
                >> uint_                [_a = _1]
                >> ')'
                >> '{'
                >>  starsOrPlus(
                        at_c<_a>(at_c<0>(_val)),    //This is where I'm not sure what to do.
                        at_c<_a>(at_c<1>(_val))
                    )
                >> '}'
                ;

        starsOrPlus = eps               [_r1 = 0]
                                        [_r2 = 0]
            >> (
                * (
                    (
                        +lit('+')       [_r1 += 1]
                    )
                    ^ (
                        +lit('*')       [_r2 += 1]
                    )
                )
            )
        ;
    }

    qi::rule<Iterator, testStruct(), qi::locals<unsigned>, ascii::space_type> start;

    //Parses stars and pluses. Sets the first uint8_t to the number of *, and the
    //second to the number of +.
    qi::rule<Iterator, void(int&, int&), ascii::space_type> starsOrPlus;
};

//Main program
int main() {
    std::string testString = "(2){**++*+}";

    typedef foo<std::string::const_iterator> foo;
    foo grammar;

    testStruct bar;
    std::string::const_iterator iter = testString.begin();
    std::string::const_iterator end = testString.end();
    bool parsed = phrase_parse(iter, end, grammar, ascii::space, bar);

    if (parsed) {
        //Do something with the data...
    }

    return 0;
}

#包括
#包括
#包括
#包括
#包括
//包含向量的结构。
结构测试结构{
std：：载体a，b；
};
增强融合适应结构(
testStruct，
（标准：：向量，a）
（标准：：向量，b）
)
名称空间qi=boost:：spirit:：qi；
名称空间phoenix=boost:：phoenix；
名称空间ascii=boost:：spirit:：ascii；
模板
结构foo:qi:：语法{
foo（）：foo:：基本类型（开始）{
使用名称空间qi：：标签；
使用qi：：eps；
使用qi：：lit；
使用qi：：uint_；
使用phoenix:：at_c；
开始=点亮（“（”）
>>uint_uu[\u a=\u 1]
>> ')'
>> '{'
>>斯达索普罗斯(
at_c（at_c（_val））//这就是我不确定该做什么的地方。
at_c（at_c（_val））
)
>> '}'
;
starsOrPlus=eps[_r1=0]
[[u r2=0]
>> (
* (
(
+发光（+'）[_r1+=1]
)
^ (
+发光（'*'）[_r2+=1]
)
)
)
;
}
qi：：规则开始；
//解析星号和加号。将第一个uint8\u t设置为*的数目，然后
//其次是+的数量。
齐：规则之星；
};
//主程序
int main（）{
std:：string testString=“（2）{**++*+}”；
类型def foo foo；
foo语法；
测试结构条；
std:：string:：const_迭代器iter=testString.begin（）；
std:：string:：const_迭代器end=testString.end（）；
boolparsed=短语解析（iter，end，grammar，ascii:：space，bar）；
如果（已解析）{
//对数据做点什么。。。
}
返回0；
}

编译失败，出现以下错误：

main.cpp||In constructor 'foo<Iterator>::foo()':|
main.cpp|36|error: 'boost::spirit::_a' cannot appear in a constant-expression|
main.cpp|36|error: no matching function for call to 'at_c(boost::phoenix::actor<boost::phoenix::composite<boost::phoenix::at_eval<0>, boost::fusion::vector<boost::spirit::attribute<0>, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_> > >&)'|
main.cpp|37|error: 'boost::spirit::_a' cannot appear in a constant-expression|
main.cpp|37|error: no matching function for call to 'at_c(boost::phoenix::actor<boost::phoenix::composite<boost::phoenix::at_eval<1>, boost::fusion::vector<boost::spirit::attribute<0>, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_> > >&)'|

构造函数“foo:：foo（）”中的

main.cpp | |：|
main.cpp | 36 |错误：“boost:：spirit:：_a”不能出现在常量表达式中|
main.cpp | 36 |错误：调用“at|c（boost:：phoenix:：actor&）”时没有匹配函数|
main.cpp | 37 |错误：“boost:：spirit:：_a”不能出现在常量表达式中|
main.cpp | 37 |错误：调用“at|c（boost:：phoenix:：actor&）”时没有匹配函数|

因此，很明显，我不能在

at_c

中使用占位符值。我也知道，即使我可以，如果给定位置超出范围，也会出现重新调整向量大小的问题

---

我如何实现这样的东西？我这样做完全是错误的吗？

这应该让你开始：

#包括
#包括
#包括
#包括
#包括
#包括
#包括
结构测试结构
{
std：：载体a，b；
};
增强融合适应结构
(
testStruct，
（标准：：向量，a）
（标准：：向量，b）
)
命名空间bp=boost:：phoenix；
名称空间bs=boost:：spirit；
名称空间bsq=bs:：qi；
模板
结构foo:bsq:：语法
{
foo（）：foo:：基本类型（开始）
{
使用名称空间bs：：标签；
使用bp：：at_c；
使用bp：：resize；
使用bs：：lit；
使用bs：：uint；
开始
=   '('
>>尤因_
[
_a=_1，
调整大小（在c（_val），_1+1），
调整大小（在c（_val），_1+1）
]
>> "){"
>>斯塔索普卢斯（at_c（_val）[u a]，at_c（_val）[u a]）
>> '}'
;
斯达索普罗斯
=  *(
发光（+'）[_r1+=1]
|发光（'*'）[_r2+=1]
)
;
}
bsq：：规则开始；
bsq：：规则starsOrPlus；
};
无效打印向量（标准：：向量常量和向量）
{
bool first=true；
对于（std:：vector:：const_迭代器it=vec.begin（），it_end=vec.end（）；
它！=它结束了；
++(it)
{
如果（第一）
第一个=假；
其他的
非常感谢！我不知道为什么我没有考虑过这样做。而且，这肯定是做starsOrPlus更好的方法，所以谢谢你的建议。是否有必要通过testStruct（）测试语法。我不能在语法中使用它而不显式地传递它吗？假设您的开始规则没有testStruct作为属性，但是其他一些规则有，那么？@Dilawar:
testStruct
只需要在
parse
的调用方希望它作为“返回值”时传递到
parse
也就是说，如果
testStruct
仅在语法中内部使用，并且在解析完成时可以丢弃，则不需要将其传递到
parse
。