Question

我熟悉boost :: spirit并希望解析下面的字符串：

double_1 | double_2 | ...... | double_n | double_1％| double_2％... | double_m％

其中m> = 0，n> = 0。

例如，下面的所有行都应解析好：

91.3 | 44 | 5e-3 | 12％| 11％

91.3 | 44 | 5e-3

12％| 11％

我想使用boost::spirit::qi。

所以，我已经编写了两个解析器，如下所示：

namespace client
{
    namespace qi = boost::spirit::qi;
    namespace ascii = boost::spirit::ascii;

    template <typename Iterator>
    bool parse_numbers(Iterator& first, Iterator last, std::vector<double>& v)
    {
        using qi::double_;
        using qi::phrase_parse;        
        using ascii::space;

        bool r = phrase_parse(first, last,

            //  Begin grammar
            (
                // double_ % '|'
                double_ >> *('|' >> double_ >> '|')
            )
            ,
            //  End grammar

            space, v);
        return r;
    }

    template <typename Iterator>
    bool parse_numbersWithPercents(Iterator& first, Iterator last, std::vector<double>& v)
    {
        using qi::double_;
        using qi::phrase_parse;
        using ascii::space;

        bool r = phrase_parse(first, last,

            //  Begin grammar
            (
                (double_ >> '%') % '|'
            )
            ,
            //  End grammar

            space, v);

        if (first != last) // fail if we did not get a full match
            return false;
        return r;
    }
}

然后，我就像在下面那样称呼他们：

int main()
{
    std::cout << "Give me a list of numbers in a format  double_1 | double_2 | ... | double_n | double_1% | double_2% ... | double_m%\n";
    std::cout << "The numbers will be inserted in a vector of numbers\n";
    std::cout << "Type [q or Q] to quit\n\n";

    std::string str;
    while (getline(std::cin, str))
    {
        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
            break;

        std::vector<double> v;
        std::string::iterator begin = str.begin(), end = str.end();
        if (client::parse_numbers(begin, end, v))
        {
            std::cout << "-------------------------\n";
            std::cout << "First Part Parsing succeeded\n";

            for (std::vector<double>::size_type i = 0; i < v.size(); ++i)
                std::cout << i << ": " << v[i] << std::endl;

            std::cout << "\n-------------------------\n";
            if(begin != end) {
                if('|' == *begin) ++begin;
                if(begin != end) {
                    std::cout << "Parsing second part: " << std::string(begin, end) << std::endl;
                    std::vector<double> v1;
                     if (client::parse_numbersWithPercents(begin, end, v1))
                    {
                        std::cout << "-------------------------\n";
                        std::cout << "Second Part Parsing succeeded\n";

                        for (std::vector<double>::size_type i = 0; i < v1.size(); ++i)
                            std::cout << i << ": " << v1[i] << std::endl;

                        std::cout << "\n-------------------------\n";
                } else {
                    std::cout << "-------------------------\n";
                    std::cout << "Second Part Parsing failed\n";
                    std::cout << "-------------------------\n";

                    if(begin != end) {
                        std::cout << "Remaining part is: " << std::string(begin, end) << std::endl; }
                    }
            }
        }
        }
        else
        {
            std::cout << "-------------------------\n";
            std::cout << "First Part Parsing failed\n";
            std::cout << "-------------------------\n";

            if(begin != end) {
                std::cout << "Remaining part is: " << std::string(begin, end) << std::endl; }
        }
    }

    std::cout << "Bye... :-) \n\n";
    return 0;
}

正如您所看到的，此方法无法正确处理角落情况，例如：

91.3 | 44 | 5e-3

12％| 11％

我感兴趣的是有另一种方法可以使用boost库以更简单的方式做同样的事情。或者以某种方式纠正我的解析器以正确解析上面的角落情况。将第一和第二部分放在一个单独的容器中会很不错。

提前致谢。

Answer 1

哈。我的直觉是这应该非常简单。但是，我得出的结论是，它确实有点不重要。

问题在于使非列表重复分隔符可选。我想到了最优雅的方式，让它成为可选的并想出了这个：

<强> Live On Coliru

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

namespace qi = boost::spirit::qi;

namespace {
    using double_vec = std::vector<double>;
    using It         = std::string::const_iterator;

    static const qi::rule<It, double_vec(bool percent), qi::blank_type> doubles_
        = (qi::double_ >> (qi::eps(qi::_r1) >> '%' | !qi::lit('%'))) % '|';
}

int main() {
    std::string str;
    while (std::getline(std::cin, str)) {
        It f = str.begin(), l = str.end();

        double_vec v, w;

        bool ok = qi::phrase_parse(f, l, 
                  (doubles_(false) >> -('|' >> doubles_(true))) 
                | qi::attr(double_vec{}) >> doubles_(true),
                qi::blank, v, w);

        if (ok && f == l) {
            std::cout << "Parsed " << v.size() << "/" << w.size() << " elements\n";
        } else {
            std::istringstream iss(str);
            if (iss >> str && (str == "q" || str == "Q"))
                break;
            std::cout << "Invalid input. Remaining '" << std::string(f,l) << "'\n";
        }
    }
}

根据测试输入，其产生以下结果：

./test <<INPUT
91.3 | 44 | 5e-3 | 12% | 11% 
91.3 | 44 | 5e-3 
12% | 11%
q
INPUT
Parsed 3/2 elements
Parsed 3/0 elements
Parsed 0/2 elements

取决于你在这里尝试/实际/实现的目标，事情可能更加优雅

更新在回应评论时，我们通过放松语法来实际改进这一点。请注意我们如何忽视＆＃39; |＆＃39;船长：

<强> Live On Coliru

qi::phrase_parse(
        f, l, *(qi::double_>>!qi::lit('%')) >> *(qi::double_>>'%'),
        qi::blank | '|', v, w);

Answer 2

我建议做两次通行证。第一步是应用这个语法。它要求第二部分中至少有一个元素。

*(double_ >> '|') >> ((double_ >> '%') % '|')

如果该语法无法解析，那么我们可以尝试另一个。此时，我们知道n == 0。所以我们可以编写一个非常简单的解析器，只处理第一部分：

double_ % '|'

我会留下一个处理m == 0和n == 0案例的解析器。

使用boost :: spirit :: qi解析双精度列表

2 个答案: