Question

我正在解析一个文本文件，大小可能是几GB，由以下行组成：

11 0.1
14 0.78
532 -3.5

基本上，每行一个int和一个float。整数应该是有序的而且是非负的。我想验证数据是如上所述，并返回给我范围内的最小和最大int。这就是我想出来的：

#include <iostream>
#include <string>

#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/std_pair.hpp>

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

namespace my_parsers
{
using namespace qi;
using px::at_c;
using px::val;
template <typename Iterator>
struct verify_data : grammar<Iterator, locals<int>, std::pair<int, int>()>
{
    verify_data() : verify_data::base_type(section)
    {
        section
            =  line(val(0))    [ at_c<0>(_val) = _1]
            >> +line(_a)       [ _a = _1]
            >> eps             [ at_c<1>(_val) = _a]
            ;

        line
            %= (int_ >> other) [
                                   if_(_r1 >= _1)
                                   [
                                       std::cout << _r1 << " and "
                                       << _1 << val(" out of order\n")
                                   ]
                               ]
            ;

        other
            = omit[(lit(' ') | '\t') >> float_ >> eol];
    }
    rule<Iterator, locals<int>, std::pair<int, int>() > section;
    rule<Iterator, int(int)> line;
    rule<Iterator> other;
};
}

using namespace std;
int main(int argc, char** argv)
{
    string input("11 0.1\n"
                 "14 0.78\n"
                 "532 -3.6\n");

    my_parsers::verify_data<string::iterator> verifier;
    pair<int, int> p;
    std::string::iterator begin(input.begin()), end(input.end());
    cout << "parse result: " << boolalpha
         << qi::parse(begin, end, verifier, p) << endl; 
    cout << "p.first: " << p.first << "\np.second: " << p.second << endl;
    return 0;
}

我想知道的是：

有没有更好的方法来解决这个问题？我使用了继承和合成的属性，局部变量和一些凤凰伏都教。这很棒;学习工具很好，但我不禁想到可能有一种更简单的方法来实现同样的事情：/（在PEG解析器中......）
如果没有本地变量，怎么办呢？

更多信息：我还有其他同时被解析的数据格式，因此我希望将返回值保留为解析器属性。目前这是一个std :: pair，其他数据格式在解析时会暴露自己的std ::对，这就是我想要在std :: vector中填充的内容。

Answer 1

我想更简单的方法是使用标准流操作解析文件，然后检查循环中的排序。首先，输入：

typedef std::pair<int, float> value_pair;

bool greater(const value_pair & left, const value_pair & right) {
    return left.first > right.first;
}

std::istream & operator>>(std::istream & stream, value_pair & value) {
    stream >> value.first >> value.second;
    return stream;
}

使用它是这样的：

std::ifstream file("your_file.txt");
std::istream_iterator<value_pair> it(file);
std::istream_iterator<value_pair> eof;

if(std::adjacent_find(it, eof, greater) != eof) {
    std::cout << "The values are not ordered" << std::endl;
}

我发现这更简单。

Answer 2

这至少要短得多：

降至28 LOC
不再是当地人
不再有融合载体at<>巫术
不再有继承的属性
没有更多的语法课
不再需要手动迭代
使用期望点（请参阅other）来增强解析错误报告
如果你选择用vector<int>分配它，那么这个解析器表达式会整齐地合成%=（但除了可能分配更大的数组之外，它会降低性能）

#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>

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

typedef std::string::iterator It;

int main(int argc, char** argv)
{
    std::string input("11 0.1\n"
            "14 0.78\n"
            "532 -3.6\n");

    int min=-1, max=0;
    {
        using namespace qi;
        using px::val;
        using px::ref;

        It begin(input.begin()), end(input.end());
        rule<It> index = int_ 
            [
                if_(ref(max) < _1)  [ ref(max) = _1 ] .else_ [ std::cout << _1 << val(" out of order\n") ],
                if_(ref(min) <  0)  [ ref(min) = _1 ]
            ] ;

        rule<It> other = char_(" \t") > float_ > eol;

        std::cout << "parse result: " << std::boolalpha 
                  << qi::parse(begin, end, index % other) << std::endl; 
    }
    std::cout << "min: " << min << "\nmax: " << max << std::endl;
    return 0;
}

加成

我可能会建议从表达式中取出验证并使其成为一个独立的函数;当然，这会让事情变得更加冗长（并且......清晰易读），而我的脑死亡样本会使用全局变量...... - 但我相信您知道如何使用boost::bind或px::bind来让它更真实

除上述

外

即使使用免费功能
不再有凤凰，不再有凤凰（yay编译时间）
调试构建中没有更多的phoenix表达式类型使二进制文件膨胀并减慢它的速度
不再有var，ref，if_，.else_和可怜的operator,（其中存在重大漏洞风险（在某个时间< / em>）由于phoenix.hpp中没有包含过载而且

（轻松移植到c ++ 0x lambda - 立即删除对全局变量的需求）

#include <boost/spirit/include/phoenix.hpp> #include <boost/spirit/include/qi.hpp> namespace px = boost::phoenix; namespace qi = boost::spirit::qi; typedef std::string::iterator It; int min=-1, max=0, linenumber=0; void validate_index(int index) { linenumber++; if (min < 0) min = index; if (max < index) max = index; else std::cout << index << " out of order at line " << linenumber << std::endl; } int main(int argc, char** argv) { std::string input("11 0.1\n" "14 0.78\n" "532 -3.6\n"); It begin(input.begin()), end(input.end()); { using namespace qi; rule<It> index = int_ [ validate_index ] ; rule<It> other = char_(" \t") > float_ > eol; std::cout << "parse result: " << std::boolalpha << qi::parse(begin, end, index % other) << std::endl; } std::cout << "min: " << min << "\nmax: " << max << std::endl; return 0; }

如何使用qi解析和验证有序的整数列表

2 个答案:

加成