当某些结构字段被省略或与结构声明中的顺序不同时，如何实现正确的解析？

使用Spirit^[1]完成任何事情的方法是使用小步骤，在此过程中严格简化。

不要忍受"拐杖"（比如随机重复的子表达式）。此外，明确是好的。在这种情况下，我将从提取重复的子表达式并重新格式化以提高可读性开始：

    name_rule   = '[' >> qi::lexeme[alpha >> *alnum] >> ']';
    factor_rule = qi::float_;
    summand_rule %= 
          (factor_rule >> -qi::lit('*') >> name_rule)
        | (name_rule   >> -qi::lit('*') >> factor_rule)
        | (factor_rule)
        | (name_rule)
        ;

在那里，已经好多了，我什么都没改变。但是等等！它不再编译

    qi::rule<Iterator, std::string(), ascii::space_type> name_rule;
    qi::rule<Iterator, float(),       ascii::space_type> factor_rule;

事实证明，语法只是"碰巧"编译，因为 Spirit 的属性兼容性规则非常宽松/宽松，以至于与名称匹配的字符只是被分配给因子部分（这就是115的来源：0x73 是 ASCII 表示来自 someAlphanumStr 的s）。

哎呀/TL;DW 我在这里写了相当多的分析文章，有一次，但我通过关闭浏览器来破坏它，所以只有一个旧的草稿缓存服务器端:(我现在把它归结为底线：

指南 使用构造函数重载分配给公开的属性类型，或使用融合序列适应，但不要将两者混合使用：它们会以令人惊讶/烦人的方式进行干扰。

别担心，我当然不会让你空手而归的。我只是"手动"引导factor，并将组件name在各自的"插槽"（成员）[^2]中。

继承的属性是保持这种清晰和方便的甜蜜方式：

// assuming the above rules redefined to take ("inherit") a summand& attribute:
qi::rule<Iterator, void(summand&), ascii::space_type> name_rule, factor_rule;

只需在语义操作中添加一个简单的赋值：

name_rule   = as_string [ '[' >> lexeme[alpha >> *alnum] >> ']' ] 
                        [ _name   = _1 ];
factor_rule = double_   [ _factor = _1 ];

现在，"魔尘"当然在于如何定义_name和_factor演员。由于维护成本，我更喜欢使用绑定，超过 phx::at_c<N>：

static const auto _factor = phx::bind(&summand::factor, qi::_r1);
static const auto _name   = phx::bind(&summand::name,   qi::_r1);

看？这非常简洁，清楚地显示了正在发生的事情。此外，这里实际上没有必要对summand进行 Fusion 改编。

现在，最后，我们也可以简化主要规则：

    summand_rule = 
              factor_rule (_val) >> - ( -lit('*') >> name_rule   (_val) )
            | name_rule   (_val) >> - ( -lit('*') >> factor_rule (_val) )
        ;

这样做的作用是通过使尾随部分可选，简单地将单组件分支组合到双组件分支中。

请注意 summand 默认构造函数如何处理默认值：

struct summand {
    float factor;
    std::string name;
    summand() : factor(1.f), name("") {}
};

请注意，这如何消除了那里的相当多的复杂性。

查看完全改编的示例，该示例在Coliru上运行，其中打印：

7.5*[someAlphanumStr] -> (7.5 someAlphanumStr)
7.5[someAlphanumStr] -> (7.5 someAlphanumStr)
[someAlphanumStr]*7.4 -> (7.4 someAlphanumStr)
[someAlphanumStr]5 -> (5 someAlphanumStr)
7.4 -> (7.4 )
[someAlphanumStr] -> (1 someAlphanumStr)

完整代码清单

#define BOOST_SPIRIT_USE_PHOENIX_V3
//#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace client {
    namespace qi     = boost::spirit::qi;
    namespace phx    = boost::phoenix;
    namespace ascii  = boost::spirit::ascii;
    struct summand {
        float factor;
        std::string name;
        summand() : factor(1.f), name("") {}
    };
}
namespace client {
    template <typename Iterator>
    struct summand_parser : qi::grammar<Iterator, summand(), ascii::space_type>
    {
        summand_parser() : summand_parser::base_type(summand_rule)
        {
            using namespace ascii;
            static const auto _factor = phx::bind(&summand::factor, qi::_r1);
            static const auto _name   = phx::bind(&summand::name,   qi::_r1);
            name_rule   = qi::as_string [ '[' >> qi::lexeme[alpha >> *alnum] >> ']' ] 
                                          [ _name   = qi::_1 ] ;
            factor_rule = qi::double_     [ _factor = qi::_1 ] ;
            summand_rule = 
                      factor_rule (qi::_val) >> - ( -qi::lit('*') >> name_rule   (qi::_val) )
                    | name_rule   (qi::_val) >> - ( -qi::lit('*') >> factor_rule (qi::_val) )
                ;
            BOOST_SPIRIT_DEBUG_NODES((summand_rule)(name_rule)(factor_rule))
        }
        qi::rule<Iterator, void(summand&), ascii::space_type> name_rule, factor_rule;
        qi::rule<Iterator, summand(),      ascii::space_type> summand_rule;
    };
}
bool parseSummandsInto(std::string const& str, client::summand& summand)
{
    typedef std::string::const_iterator It;
    static const client::summand_parser<It> g;
    It iter(str.begin()), end(str.end());
    bool r = phrase_parse(iter, end, g, boost::spirit::ascii::space, summand);
    return (r && iter == end);
}
int main()
{
    std::vector<std::string> inputStrings = {
        "7.5*[someAlphanumStr]",
        "7.5[someAlphanumStr]",
        "[someAlphanumStr]*7.4",
        "[someAlphanumStr]5",
        "7.4",
        "[someAlphanumStr]",
    };
    std::for_each(inputStrings.begin(), inputStrings.end(), [&inputStrings](std::string const& inputStr) {
        client::summand parsed;
        if (parseSummandsInto(inputStr, parsed))
            std::cout << inputStr << " -> (" << parsed.factor << " " << parsed.name << ")n";
        else
            std::cout << inputStr << " -> FAILEDn";
    });
}

^[1] 可以说，技术中的其他任何东西

^[2] 您可以保留FUSION_ADAPT_STRUCT但不再需要它，如您所见

我不确定这是否是最佳解决方案，但我会通过提供融合序列的初始值来解决这个问题，而不是稍后使用 Phoenix 修改它们：

summand_rule %=
    (qi::float_ >> -(-qi::lit('*') >> '[' >> qi::lexeme[alpha >> *alnum] >> ']'))
  | (qi::attr(0.) >> '[' >> qi::lexeme[alpha >> *alnum] >> ']' >> -(-qi::lit('*') >> qi::float_[ph::at_c<0>(qi::_val) = qi::_1]));

也就是说，我们为融合序列中的第一项提供初始值 0.，该值被分配给 factor ，然后返回并稍后对其进行修改。

如果我们在相反的情况下omit因子，则规则的属性类型将完全建模summand，我们可以使用=赋值而不是%=：

summand_rule =
    (qi::float_ >> -(-qi::lit('*') >> '[' >> qi::lexeme[alpha >> *alnum] >> ']'))
  | (qi::attr(0.) >> '[' >> qi::lexeme[alpha >> *alnum] >> ']' >> -(-qi::lit('*') >> qi::omit[qi::float_[ph::at_c<0>(qi::_val) = qi::_1]]));

演示：http://coliru.stacked-crooked.com/a/46e3e8101a9c10ea