所以我有一個(gè)解析器,它將7.5 * [someAlphanumStr]或7.5 [someAlphanumStr]等字符串解析為此結(jié)構(gòu)：

struct summand {
    float factor;
    std::string name;
    summand(const float & f):factor(f), name(""){}
    summand(const std::string & n):factor(1.0f), name(n){}
    summand(const float & f, const std::string & n):factor(f), name(n){}
    summand():factor(0.0f), name(""){}
};

但另外我需要能夠解析像[someAlphanumStr] * 7.4,[someAlphanumStr] 5,7.4和[someAlphanumStr]這樣的字符串.在最后兩種情況下(7.4和[someAlphanumStr])我想設(shè)置被省略為默認(rèn)值的字段的值,為此我已經(jīng)為我的struct summand構(gòu)造函數(shù)編寫(xiě)了一個(gè)參數(shù).

下面是我生成的代碼和結(jié)果：

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/io.hpp>

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

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

    struct summand {
        float factor;
        std::string name;
        summand(const float & f):factor(f), name(""){}
        summand(const std::string & n):factor(1.0f), name(n){}
        summand(const float & f, const std::string & n):factor(f), name(n){}
        summand():factor(0.0f), name(""){}
    };
}

BOOST_FUSION_ADAPT_STRUCT(client::summand,
                      (float, factor)
                      (std::string, 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;

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

        }

        qi::rule<Iterator, summand(), ascii::space_type> summand_rule;
    };
}

void parseSummandsInto(std::string const& str, client::summand& summands)
{
    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, summands);

    if (r && iter == end)
        return;
    else
        throw "Parse failed";
}

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 & inputStr) {
        client::summand parsed;
        parseSummandsInto(inputStr, parsed);
        std::cout << inputStr << " -> " << boost::fusion::as_vector(parsed) << std::endl;
    });
}

結(jié)果(Coliru)：

  clang   -std=c  11 -O0 -Wall -pedantic main.cpp
  ./a.out
  c  filt -t
7.5*[someAlphanumStr] -> (7.5 someAlphanumStr)
7.5[someAlphanumStr] -> (7.5 someAlphanumStr)
[someAlphanumStr]*7.4 -> (115 )
[someAlphanumStr]5 -> (115 )
7.4 -> (7.4 )
[someAlphanumStr] -> (115 omeAlphanumStr)

感謝所有人的明確答案和建議,特別是我很感謝@sehe.

解決方法:

使用Spirit [1]完成任何事情的方法是使用小步驟,沿途嚴(yán)格簡(jiǎn)化.

不要忍受“殘酷”(就像隨機(jī)重復(fù)的子表達(dá)式).而且,明確是好的.在這種情況下,我首先提取重復(fù)的子表達(dá)式并重新格式化以便易讀：

    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)
        ;

在那里,已經(jīng)好多了,我沒(méi)有改變一件事.可是等等！它不再編譯

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

事實(shí)證明,語(yǔ)法只是“發(fā)生”才能編譯,因?yàn)镾pirit的屬性兼容性規(guī)則是如此寬松/寬松,以至于匹配名稱(chēng)的字符只被分配給因子部分(115來(lái)自哪里：0x73是來(lái)自s的ASCII) someAlphanumStr).

OOPS / TL; DW我在這里寫(xiě)了一篇很長(zhǎng)的分析,曾經(jīng),但是我通過(guò)關(guān)閉我的瀏覽器來(lái)破壞它,所以只有一個(gè)舊的草案緩存服務(wù)器端:(我現(xiàn)在將它歸結(jié)為底線(xiàn)：

Guideline Use either constructor overloads to assign to your exposed attribute type, or use Fusion Sequence adaptation, but don’t mix the two: they will interfere in surprising/annoying ways.

別擔(dān)心,我當(dāng)然不會(huì)讓你空手而歸.我只是“手動(dòng)”指導(dǎo)因素并在各自的“插槽”(成員)中命名組件[2].

繼承屬性是一種保持這種清晰易用的甜蜜方式：

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

只需在語(yǔ)義操作中添加一個(gè)簡(jiǎn)單的賦值：

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

現(xiàn)在,“魔法塵?！碑?dāng)然是如何定義_name和_factor的.我更喜歡使用綁定,而不是phx :: at_c< N>由于維護(hù)費(fèi)用：

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

看到？這非常簡(jiǎn)潔,清楚地顯示了正在發(fā)生的事情.此外,這里沒(méi)有實(shí)際需要使用Fusion適配進(jìn)行加法.

現(xiàn)在,最后,我們也可以簡(jiǎn)化主要規(guī)則：

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

這樣做,只需通過(guò)使尾隨部分可選,將單分支分支組合成雙分支分支.

請(qǐng)注意summand默認(rèn)構(gòu)造函數(shù)如何處理默認(rèn)值：

struct summand {
    float factor;
    std::string name;

    summand() : factor(1.f), name("") {}
};

注意這是如何消除了相當(dāng)復(fù)雜的.

查看運(yùn)行Live on Coliru的完全適應(yīng)的樣本打?。?/p>

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 << " -> FAILED\n";
    });
}

[1]可以說(shuō),技術(shù)上還有其他任何東西

[2]您可以保留FUSION_ADAPT_STRUCT但不再需要它,如您所見(jiàn)