如何将括号中的字符串解析为具有给定分隔符的字符串列表

Question

我的任务是解析带括号的字符串，比如

[foo | bar | foobar]，到vector 的std::strings。

在这种情况下， vector 应该以内容 {"foo" , "bar", "foobar"} 结尾。

这些括号可以嵌套。例如，给定的括号字符串

[[john | doe] | [ bob | dylan]]

会变成{ "[john | doe]" , "[bob | dylan] }"

到目前为止我能做到的最好的事情是

int main(int argc, char ** argv)
{
    const std::string input {argv[1]};
    std::vector<std::string> res;

    qi::phrase_parse(input.cbegin(), input.cend(),
     '[' 
     >> *qi::lexeme[ +(qi::char_ - '|')  >> '|'] 
     > -qi::lexeme[ +(qi::char_  - ']') >> ']' ],
     qi::space ,
     res);

    for (const auto& v: res)
        std::cout << v  <<std::endl;

    return 0;
}

这对于嵌套的情况非常失败。有人可以指出我正确的方向吗？

注意 #1：嵌套案例可以不止一个。

注意 #2：我欢迎任何更简单的解决方案，即使不使用 Boost Spirit。

Answer 1

这是一个简单的 C++ 解析器，它假设括号是平衡的，即每个 [ 都有一个 ]。

bracket 是左括号的数量。当该号码为 1 时，我们会做出重要决定。

#include <iostream>
#include <vector>
#include <string>
#include <string_view>

bool edge(const int num){
    return num == 1;
}

int main(){
    std::vector<std::string> all;
    std::string line;
    // std::getline(std::cin, line);
    line = "[[john | doe] | [ bob | dylan]]";

    int bracket = 0;
    std::string::size_type start = 0;
    for(int i = 0; i < line.size(); i++){
        const char c = line[i];
        if(c == '['){
            bracket++;
            if(edge(bracket)){
                start = i + 1;
            }
        }
        if(c == ']'){
            if(edge(bracket)){
                all.push_back(line.substr(start, i - start));
            }
            bracket--;
        }
        if(c == '|' && edge(bracket)){
            all.push_back(line.substr(start, i - start));
            start = i + 1;
        }
    }
    for(std::string_view t : all){
        std::cout << t << std::endl;
    }
}

Answer 2

如果你想要嵌套的字符串列表，首先你需要一个可以存储嵌套列表的结果。幸运的是，在 C++17 中，您可以拥有前向引用的向量（只要它们在某个时候定义）。所以你可以创建一个列表类型，其中每个项目要么是字符串，要么是另一个列表：

struct Expr : std::vector<
    boost::variant<
        std::string,
        Expr>>
{ 
    using std::vector<boost::variant<std::string, Expr>>::vector;
};

之后的语法就很简单了。请注意，它是递归的 - Term 可以有一个 Expr 嵌套在其中：

WORD = /[^\[\|\]]+/
Term = WORD | Expr
Expr = '[' Term ('|' Term)* ']';

您可以分别表达每条规则。 Boost Spirit Qi 方便地使用% 运算符，它解析分隔列表并将其插入到容器中。

using It = std::string::const_iterator;
using Sk = qi::space_type;
qi::rule<It, std::string(), Sk> word;
qi::rule<It, boost::variant<std::string, Expr>(), Sk> term;
qi::rule<It, Expr(), Sk> expr;

word = +(qi::char_ - '[' - '|' - ']'); 
term = word | expr;
expr = '[' >> (term % '|') >> ']';

然后qi::phrase_parse 会做你想做的事：

Expr res;
qi::phrase_parse(input.cbegin(), input.cend(), expr, qi::space, res);

演示：https://godbolt.org/z/5W993s

Answer 3

这个更简单的版本似乎正是你想要的：

qi::phrase_parse(input.cbegin(), input.cend(),
    '[' 
    >> qi::lexeme[ +~qi::char_("|]") ] % '|' 
    >> ']',
    qi::space,
    res);

它会解析：

"foo "
"bar "
"foobar"

也许您实际上并不希望将空格作为匹配的一部分。那么它可以更简单：

qi::phrase_parse(input.cbegin(), input.cend(),
    '[' 
    >> qi::lexeme[ +(qi::graph - qi::char_("|]")) ] % '|' 
    >> ']',
    qi::space,
    res);

看Live On Coliru

注意：如果您有 C++14，请考虑使用 X3：Live On Coliru。这样编译起来会快很多