这是我尝试以尽可能最好的方式做的事情的一个大大减少的案例。 (当然，问题还在于，我试图了解如何最好地使用精神。)

我需要将数据解析为具有多个成员的结构。成员被简单地列为键值对，因此这很简单——但是，如果某些键不同，那么在我正在解析的数据中，不同的值可能会稍后出现，或者某些键可能会被省略。尽管如此，我最终解析的数据结构是有固定形式的。

在示例代码中，my_struct是 struct像这样:

struct my_struct {
  std::string a;
  std::string b;
  std::string c;
  std::string d;
};

和grammar1是一个像这样解析字符串的语法

"a: x b: y c: z d: w"

进入这样的结构

my_struct{ "x", "y", "z", "w" }

我还想像这样解析字符串:

"a: x b: y d-no-c: w"

进入这样的结构

my_struct{ "x", "y", "", "w" }

理想情况下，我希望以尽可能简单的方式完成此操作，而不会在此过程中制作不必要的字符串拷贝。

我的第一个想法是，应该重写主要规则，以便它解析“a”和“b”，然后根据“c”是否存在在两个备选方案之间进行选择。这作为一个语法很容易解决，但是当我们试图为它的属性语法部分获取正确的数据类型时，我似乎无法让它工作。我尝试使用 std::pair<std::string, std::string>还有fusion::vector对于替代类型，但这显然不能使用 qi 流式传输到我的结构中运算符(operator) << . (grammar2 测试被注释掉，因为它无法编译。)

我的下一个想法是，我们可以简单地有两种主要规则的替代形式，它们的属性类型为 my_struct以确保属性解析有效。令人惊讶的是，这个实现实际上被破坏了——似乎当语法回溯时，它复制了 a。和 b结果结构中的字段。我没想到会这样，我也不知道为什么会这样，你知道吗？ (这是 grammar3 )。

grammar3有一个问题，即使它像我认为的那样工作(测试通过)，当替代部分回溯时，它也必须重新解析 a和 b这是一些低效率。如果我们愿意将目标结构从 my_struct 更改为到不同的结构，那么我们可以使用 grammar4 ，与grammar2具有相同的计划, 但目标是其中一个元素是 std::pair 的结构.然后我们将所有字符串从这个临时结构中移出，变成我们真正想要的格式。

那么，问题是:

• grammar4有效，但是有没有办法按照 grammar2 的方式做一些事情？哪个可能更有效？
• 为什么 grammar3考试不及格？

完整 list :

#define SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/adapted/struct/define_struct.hpp>
#include <boost/fusion/include/define_struct.hpp>
#include <boost/fusion/include/std_pair.hpp>

#include <iostream>
#include <string>
#include <utility>

namespace qi = boost::spirit::qi;

BOOST_FUSION_DEFINE_STRUCT(
 /**/
 ,
 my_struct,
 (std::string, a)
 (std::string, b)
 (std::string, c)
 (std::string, d))

template<typename Iterator>
class grammar1 : public qi::grammar<Iterator, my_struct()> {
public:
  qi::rule<Iterator, std::string()> id;
  qi::rule<Iterator, my_struct()> main;

  grammar1() : grammar1::base_type(main) {
    using qi::lit;
    using qi::char_;
    using qi::omit;
    using qi::space;
    id = omit[ *space ] >> *char_("A-Za-z_") >> omit [ *space ];
    main = lit("a:") >> id >> lit("b:") >> id >> lit("c:") >> id >> lit("d:") >> id;
  }
};


//typedef std::pair<std::string, std::string> second_part_type;
typedef boost::fusion::vector<std::string, std::string> second_part_type;

template<typename Iterator>
class grammar2 : public qi::grammar<Iterator, my_struct()> {
public:
  qi::rule<Iterator, std::string()> id;
  qi::rule<Iterator, second_part_type()> with_c;
  qi::rule<Iterator, second_part_type()> without_c;
  qi::rule<Iterator, my_struct()> main;

  grammar2() : grammar2::base_type(main) {
    using qi::lit;
    using qi::char_;
    using qi::omit;
    using qi::space;
    using qi::attr;
    id = omit[ *space ] >> *char_("A-Za-z_") >> omit [ *space ];
    with_c = lit("c:") >> id >> lit("d:") >> id;
    without_c = attr("") >> lit("d-no-c:") >> id;
    main = lit("a:") >> id >> lit("b:") >> id >> (with_c  | without_c);
  }
};


template<typename Iterator>
class grammar3 : public qi::grammar<Iterator, my_struct()> {
public:
  qi::rule<Iterator, std::string()> id;
  qi::rule<Iterator, my_struct()> with_c;
  qi::rule<Iterator, my_struct()> without_c;
  qi::rule<Iterator, my_struct()> main;

  grammar3() : grammar3::base_type(main) {
    using qi::lit;
    using qi::char_;
    using qi::omit;
    using qi::space;
    using qi::attr;
    id = omit[ *space ] >> *char_("A-Za-z_") >> omit [ *space ];
    with_c = lit("a:") >> id >> lit("b:") >> id >> lit("c:") >> id >> lit("d:") >> id;
    without_c = lit("a:") >> id >> lit("b:") >> id >> attr("") >> lit("d-no-c:") >> id;
    main = with_c | without_c;
  }
};

/***
 * Alternate approach
 */
typedef std::pair<std::string, std::string> spair;

BOOST_FUSION_DEFINE_STRUCT(
 /**/
 ,
 my_struct2,
 (std::string, a)
 (std::string, b)
 (spair, cd))

template<typename Iterator>
class grammar4 : public qi::grammar<Iterator, my_struct2()> {
public:
  qi::rule<Iterator, std::string()> id;
  qi::rule<Iterator, spair()> with_c;
  qi::rule<Iterator, spair()> without_c;
  qi::rule<Iterator, my_struct2()> main;

  grammar4() : grammar4::base_type(main) {
    using qi::lit;
    using qi::char_;
    using qi::omit;
    using qi::space;
    using qi::attr;
    id = omit[ *space ] >> *char_("A-Za-z_") >> omit [ *space ];
    with_c = lit("c:") >> id >> lit("d:") >> id;
    without_c = attr("") >> lit("d-no-c:") >> id;
    main = lit("a:") >> id >> lit("b:") >> id >> (with_c  | without_c);
  }
};

my_struct convert_struct(my_struct2 && s) {
  return { std::move(s.a), std::move(s.b), std::move(s.cd.first), std::move(s.cd.second) };
}

/***
 * Testing
 */
void check_strings_eq(const std::string & a, const std::string & b, const char * label, int line = 0) {
  if (a != b) {
    std::cerr << "Mismatch '" << label << "' ";
    if (line) { std::cerr << "at line " << line << " "; }
    std::cerr << "\"" << a << "\" != \"" << b << "\"\n";
  }
}

void check_eq(const my_struct & s, const my_struct & t, int line = 0) {
  check_strings_eq(s.a, t.a, "a", line);
  check_strings_eq(s.b, t.b, "b", line);
  check_strings_eq(s.c, t.c, "c", line);
  check_strings_eq(s.d, t.d, "d", line);
}

template<template<typename> class Grammar>
void test_grammar(const std::string & input, const my_struct & expected, int line = 0) {
  auto it = input.begin();
  auto end = input.end();
  Grammar<decltype(it)> grammar;
  my_struct result;
  if (!qi::parse(it, end, grammar, result)) {
    std::cerr << "Failed to parse! ";
    if (line) { std::cerr << "line = " << line; }
    std::cerr << "\n";
    std::cerr << "Stopped at:\n" << input << "\n";
    for (auto temp = input.begin(); temp != it; ++temp) { std::cerr << " "; }
    std::cerr << "^\n";
  } else {
    check_eq(result, expected, line);
  }
}

int main() {
  test_grammar<grammar1> ( "a: x    b: y   c: z   d: w",   my_struct{ "x",    "y",   "z",   "w" }, __LINE__);
  test_grammar<grammar1> ( "a: asdf b: jkl c: foo d: bar", my_struct{ "asdf", "jkl", "foo", "bar" }, __LINE__ );
  //test_grammar<grammar2> ( "a: asdf b: jkl c: foo d: bar", my_struct{ "asdf", "jkl", "foo", "bar" }, __LINE__ );
  //test_grammar<grammar2> ( "a: asdf b: jkl d-no-c: bar",   my_struct{ "asdf", "jkl", "", "bar" }, __LINE__ );
  test_grammar<grammar3> ( "a: asdf b: jkl c: foo d: bar", my_struct{ "asdf", "jkl", "foo", "bar" }, __LINE__);
  test_grammar<grammar3> ( "a: asdf b: jkl d-no-c: bar",   my_struct{ "asdf", "jkl", "", "bar" }, __LINE__ );

  // Test 4th grammar
  {
    std::string input = "a: asdf b: jkl c: foo d: bar";
    auto it = input.begin();
    auto end = input.end();
    grammar4<decltype(it)> grammar;
    my_struct2 result;
    if (!qi::parse(it, end, grammar, result)) {
      std::cerr << "Failed to parse! Line = " << __LINE__ << std::endl;
    } else {
      check_eq(convert_struct(std::move(result)),  my_struct{ "asdf", "jkl", "foo", "bar" }, __LINE__);
    }
  }
  {
    std::string input = "a: asdf b: jkl d-no-c: bar";
    auto it = input.begin();
    auto end = input.end();
    grammar4<decltype(it)> grammar;
    my_struct2 result;
    if (!qi::parse(it, end, grammar, result)) {
      std::cerr << "Failed to parse! Line = " << __LINE__ << std::endl;
    } else {
      check_eq(convert_struct(std::move(result)),  my_struct{ "asdf", "jkl", "", "bar" }, __LINE__);
    }
  }
}

最佳答案

我的建议是确实使用置换解析器。

虽然它更加灵活，因此您可能希望在语义操作中添加验证约束:

Live On Coliru

//#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/tuple/tuple_comparison.hpp>

#include <iostream>
#include <string>

namespace qi = boost::spirit::qi;

struct my_struct {
    std::string a,b,c,d;
};

BOOST_FUSION_ADAPT_STRUCT(my_struct, a, b, c, d)

template<typename Iterator>
class grammar : public qi::grammar<Iterator, my_struct()> {
    public:
        grammar() : grammar::base_type(start) {
            using namespace qi;

            id    = +char_("A-Za-z_");
            part  = lexeme[lit(_r1) >> ':'] >> id;

            main  = part(+"a")
                  ^ part(+"b")
                  ^ part(+"c")
                  ^ (part(+"d") | part(+"d-no-c"));
                  ;

            start = skip(space) [ main ];

            BOOST_SPIRIT_DEBUG_NODES((main)(part))
        }
    private:
        qi::rule<Iterator, std::string()>                            id;
        qi::rule<Iterator, std::string(const char*), qi::space_type> part;
        qi::rule<Iterator, my_struct(), qi::space_type>              main;
        //
        qi::rule<Iterator, my_struct()> start;
};

/***
 * Testing
 */
void check_strings_eq(const std::string & a, const std::string & b, const char * label) {
    if (a != b) {
        std::cerr << "Mismatch '" << label << "' \"" << a << "\" != \"" << b << "\"\n";
    }
}

void check_eq(const my_struct & s, const my_struct & t) {
    check_strings_eq(s.a, t.a, "a");
    check_strings_eq(s.b, t.b, "b");
    check_strings_eq(s.c, t.c, "c");
    check_strings_eq(s.d, t.d, "d");
    if (boost::tie(s.a,s.b,s.c,s.d) == boost::tie(t.a,t.b,t.c,t.d))
        std::cerr << "struct data matches\n";
}

template<template<typename> class Grammar>
void test_grammar(const std::string &input, const my_struct &expected) {
    auto it  = input.begin();
    auto end = input.end();

    Grammar<decltype(it)> grammar;
    my_struct result;

    if (!qi::parse(it, end, grammar, result)) {
        std::cerr << "Failed to parse!\n";
        std::cerr << "Stopped at:\n" << input << "\n";

        for (auto temp = input.begin(); temp != it; ++temp) {
            std::cerr << " ";
        }

        std::cerr << "^\n";
    } else {
        check_eq(result, expected);
    }
}

int main() {
    for (auto&& p : std::vector<std::pair<std::string, my_struct> > {
            {"a: x b: y c: z d: w", my_struct{ "x", "y", "z", "w" }},
            {"a: x      c: z d: w", my_struct{ "x", "" , "z", "w" }},
            {"a: x      c: z"     , my_struct{ "x", "" , "z", ""  }},
            {"     b: y c: z d: w", my_struct{ "" , "y", "z", "w" }},
            {"b: y c: z a: x d: w", my_struct{ "x", "y", "z", "w" }},
            // if you really need:
            {"a: x b: y d-no-c: w", my_struct{ "x", "y", "" , "w" }},
        })
    {
        auto const& input    = p.first;
        auto const& expected = p.second;
        std::cout << "----\nParsing '" << input << "'\n";
        test_grammar<grammar> (input, expected);
    }
}

打印

----
Parsing 'a: x b: y c: z d: w'
struct data matches
----
Parsing 'a: x      c: z d: w'
struct data matches
----
Parsing 'a: x      c: z'
struct data matches
----
Parsing '     b: y c: z d: w'
struct data matches
----
Parsing 'b: y c: z a: x d: w'
struct data matches
----
Parsing 'a: x b: y d-no-c: w'
struct data matches

关于c++ - 使用精神以替代方式解析结构时混淆输出，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33337623/