当使用spirit以其他方式解析结构时，会导致输出混乱

这是我试图以最好的方式做的事情的一个大大减少的情况。(当然，这个问题也是关于，我试图理解如何最好地利用精神。)

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

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

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

and 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"answers"b"，然后根据"c"是否存在在两个备选方案之间进行选择。作为一种语法，这很容易解决，但是当我们试图为它的属性语法部分获得正确的数据类型时，我似乎无法让它工作。我尝试使用std::pair<std::string, std::string>和fusion::vector作为替代类型，但这显然不能使用qi操作符<<流到我的结构中。(grammar2测试被注释掉，因为它不能编译。)

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

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

问题是:

• grammar4工作，但是有没有一种方法可以沿着grammar2的路线做一些可能更有效的事情?
• 为什么grammar3测试失败?

完整清单:

#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__);
    }
  }
}