如何使用boost spirit？； #包括 #包括 #包括 #包括 #包括 #包括 #包括 #定义代码\u CPP\u关键字\u枚举“枚举” 哈哈 { //简单表示C++的枚举的类（一种简单描述C++枚举的结构） 结构CPPCodeEnum { //枚举的名称（枚举名称） ：：std：：字符串枚举名； //成员的名称（枚举成员姓名） ：：std：：列出枚举成员； }; } 哈哈 { 名称空间融合=boost:：fusion； 名称空间phoenix=boost:：phoenix； 名称空间qi=boost:：spirit:：qi； 名称空间ascii=boost:：spirit:：ascii； //枚举的简单解析器 模板 结构CPPCodeEnumGrammar ：qi：：语法 { CPPCodeEnumGrammar（） ：CPPCodeEnumGrammar:：基本类型（开始） { 使用qi:(u val)； 使用气：：_1； 使用qi：：lit； 使用气：词素； 用气：生的； 使用气：空间； 使用ascii:：char； 使用ascii：：字符串； 使用phoenix:：推回； //解析一个变量名（他不符合C++的命名规范，暂时只是个替代品） quoted_string=lexeme[+（qi:：alpha | qi:：digit | char(‘’）]； 开始= //解析“枚举” lit（代码\u CPP\u关键字\u枚举）>> //取得枚举名 *quoted_字符串[phoenix:：bind（&CPPCodeEnum:：enumName，_val）=_1]>> 字符（“{”）>> //解析枚举的成员 *（引用的字符串[向后推（phoenix:：bind（&CPPCodeEnum:：enumMembers，_val），_1）]%，”）> //可有可无的逗号小尾巴 -字符（“，”>> 字符（“}”）； } qi:：规则引用的字符串； qi：：规则开始； }; } int main（int argc，char*argv[]） { qcorea应用程序（argc、argv）； //模拟C++的一段代码（测试字符串模拟C++代码的一部分） ：：std：：string teststr=“enum myename{m1，m2，m3，m4，}”； 使用boost:：spirit:：ascii:：space； std:：string:：const_迭代器iter=teststr.begin（）； std:：string:：const_迭代器end=teststr.end（）； 哈哈：：CPPCodeEnumGrammar myCPPCodeEnumGrammar； 哈哈：：CPPCodeEnum数据； bool r=短语解析（iter，end，mycppcodeneumgrammar，space，data）； 返回a.exec（）； }

我上面的代码工作正常，但是，它太简单了，不能像这样解析代码：（enum myename{m1=1，m2=44，m3=89，m4=0，}）。我需要enum成员的名称和值。现在我决定使用

 #include <QtCore/QCoreApplication>

 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 #include <iostream>
 #include <string>
 #include <list>
 #include <map>

 #define CODE_CPP_KEYWORD_ENUM "enum"

namespace haha
{
    //简单表示c++的enum的类（A structure use to simply description C++ enum）
    struct CPPCodeEnum
    {
        //enum的名称（enum Name）
        ::std::string enumName;
        //成员的名称（enum Members‘name）
        ::std::list<::std::string> enumMembers;
    };
}

namespace haha
{
    namespace fusion = boost::fusion;
    namespace phoenix = boost::phoenix;
    namespace qi = boost::spirit::qi;
    namespace ascii = boost::spirit::ascii;

    //enum的简单解析器
    template <typename Iterator>
    struct CPPCodeEnumGrammar 
        : qi::grammar<Iterator, CPPCodeEnum(),ascii::space_type >
    {
        CPPCodeEnumGrammar() 
            : CPPCodeEnumGrammar::base_type(start)
        {

            using qi::_val;
            using qi::_1;
            using qi::lit;
            using qi::lexeme;
            using qi::raw;
            using qi::space;
            using ascii::char_;
            using ascii::string;
            using phoenix::push_back;
            //解析一个变量名（他不符合C++的命名规范，暂时只是个替代品）
            quoted_string = lexeme[+(qi::alpha|qi::digit | char_('_'))];

            start =
                //解析“enum”
                lit(CODE_CPP_KEYWORD_ENUM)>>
                //取得enum名
                *quoted_string[ phoenix::bind(&CPPCodeEnum::enumName, _val)= _1]>>
                char_("{")>>
                //解析enum的成员
                *(quoted_string[push_back(phoenix::bind(&CPPCodeEnum::enumMembers, _val), _1)]%',')>>
                //可有可无的逗号小尾巴
                -char_(",")>>
                char_("}");

        }

        qi::rule<Iterator, std::string(),ascii::space_type > quoted_string;
        qi::rule<Iterator, CPPCodeEnum(), ascii::space_type > start;
    };
}



int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    //模拟C++的一段代码（test string simulate a section of C++ code）
    ::std::string teststr="enum myename {m1,m2  ,m3 ,m4 ,}";

    using boost::spirit::ascii::space;

    std::string::const_iterator iter = teststr.begin();
    std::string::const_iterator end = teststr.end();

    haha::CPPCodeEnumGrammar<std::string::const_iterator> myCPPCodeEnumGrammar;
    haha::CPPCodeEnum data;

    bool r = phrase_parse(iter, end, myCPPCodeEnumGrammar,  space, data);

    return a.exec();
}

---

映射。但我不知道如何使用boost spirit将结果放入STL映射？

您可以在地图上使用phoenix

insert

，如列表上的

push\u

。 STL容器的phoenix惰性函数列表：

请看一看，它准确地描述了您试图实现的目标。要点是Spirit.Qi允许直接将键/值对解析为一个映射，而无需任何附加代码。

在此处输入代码
map < std::string::string,int>
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义代码\u CPP\u关键字\u枚举“枚举”
哈哈
{
//简单表示C++的枚举的类
结构CPPCodeEnum
{
//枚举的名称 （eunm名称）
：：std：：字符串枚举名；
//成员的名称 （枚举成员名称值）
：：std：：映射枚举成员；
};
}
哈哈
{
名称空间融合=boost:：fusion；
名称空间phoenix=boost:：phoenix；
名称空间qi=boost:：spirit:：qi；
名称空间ascii=boost:：spirit:：ascii；
//枚举的简单解析器 （eunm解析器）
模板
结构CPPCodeEnumGrammar
：qi：：语法
{
CPPCodeEnumGrammar（）
：CPPCodeEnumGrammar:：基本类型（mRuleEntrence）
{
使用qi:(u val)；
使用气：：_1；
使用气：：_2；
使用qi：：lit；
使用气：词素；
使用气：空间；
使用ascii:：char；
使用ascii：：字符串；
//解析一个变量名（符合C++的变量命名规范，只能由数字、字母、下划线且一个字符不能是数字）
//C++值名称规则，第一个字符仅为“u”或“alpha”
mRuleCPPValueName%=lexeme[+（qi:：alpha | char(‘’）>>*（qi:：alpha | char(‘’）| qi:：digit）]；
//有赋值的成员 （值成员规则解析“m1=xx”）
mRuleMemberValue=（mRuleCpValueName>>qi:：省略[char_U8;（“=”）>>qi:：int_U8;）
[
phoenix:：bind（&:：std:：pair:：first，_val）=u 1，
phoenix:：bind（&:：std:：pair:：second，_val）=u 2，
//mTempValue=+1
凤凰城：：ref（mTempValue）=_2+1
];
//缺省赋值的成员（默认值成员）
mRuleMemberDefaultValue=mRuleCPPValueName
[
phoenix:：bind（&:：std:：pair:：first，_val）=u 1，
phoenix:：bind（&:：std:：pair:：second，_val）=phoenix:：ref（mTempValue），
凤凰城：：参考（mTempValue）++
];
恳求=
//解析“枚举”初始化mTempValue=0每次调用都会使mTempValue=0
//在每次调用中初始化mTempValue=0
lexeme[lit（CODE_CPP_KEYWORD_ENUM）[phoenix:：ref（mTempValue）=0]>>+空格]>>
//取得枚举名
*mRuleCPPValueName[phoenix:：bind（&CPPCodeEnum:：enumName，\u val）=\u 1]>>
字符（“{”）>>
//解析枚举的成员
*（（mRuleMemberValue[phoenix:：insert（phoenix:：bind（&CPPCodeEnum:：enumMembers，_val），_1）]）|
mRuleMemberDefaultValue[phoenix:：insert（phoenix:：bind（&CPPCodeEnum:：enumMembers，_val），_1）]）
%',')>>
//可有可无的逗号小尾巴
-字符（“，”>>
字符（“}”）；
}
//成员值的计数器
int MTEMP值；
qi：：规则mRuleMemberValue；
规则规则
map < std::string::string,int>
enter code here

#include <QtCore/QCoreApplication>

#include <boost/tuple/tuple.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <iostream>
#include <string>
#include <list>
#include <map>

#define CODE_CPP_KEYWORD_ENUM "enum"



namespace haha
{
//简单表示c++的enum的类
struct CPPCodeEnum
{
    //enum的名称 (eunm name)
    ::std::string enumName;
    //成员的名称 (enum members name-value)
    ::std::map<::std::string,int> enumMembers;
};
}




namespace haha
{
namespace fusion = boost::fusion;
namespace phoenix = boost::phoenix;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

//enum的简单解析器 (eunm parser)
template <typename Iterator>
struct CPPCodeEnumGrammar 
    : qi::grammar<Iterator,CPPCodeEnum(),ascii::space_type >
{
    CPPCodeEnumGrammar() 
        : CPPCodeEnumGrammar::base_type(mRuleEntrence)
    {

        using qi::_val;
        using qi::_1;
        using qi::_2;
        using qi::lit;
        using qi::lexeme;
        using qi::space;
        using ascii::char_;
        using ascii::string;

        //解析一个变量名（符合C++的变量命名规范，只能由数字、字母、下划线且一个字符不能是数字）
                    //C++ value name rule with only "_"or"alpha" as 1st char
        mRuleCPPValueName %= lexeme[+(qi::alpha|char_('_'))>>*(qi::alpha|char_('_')|qi::digit) ];

        //有赋值的成员 (value-member rule parse "m1=xx")
        mRuleMemberValue =(mRuleCPPValueName>>qi::omit[char_("=")]>>qi::int_)
            [
                phoenix::bind(&::std::pair<::std::string,int>::first, _val)=_1,
                phoenix::bind(&::std::pair<::std::string,int>::second, _val)=_2,
                                   //mTempValue=+1
                phoenix::ref(mTempValue)=_2+1                   
            ];

        //缺省赋值的成员(defult value member)
        mRuleMemberDefaultValue = mRuleCPPValueName
            [
                phoenix::bind(&::std::pair<::std::string,int>::first, _val)=_1,
                phoenix::bind(&::std::pair<::std::string,int>::second, _val)=phoenix::ref(mTempValue),
                phoenix::ref(mTempValue)++
            ];


        mRuleEntrence =
            //解析“enum”初始化mTempValue=0，每次调用都会使mTempValue=0
                                                              //Initialize mTempValue=0 in ever call
            lexeme[lit(CODE_CPP_KEYWORD_ENUM)[phoenix::ref(mTempValue)=0]>>+space]>>
            //取得enum名
            *mRuleCPPValueName[phoenix::bind(&CPPCodeEnum::enumName, _val)= _1]>>
            char_("{")>>
            //解析enum的成员
            *(((mRuleMemberValue[phoenix::insert(phoenix::bind(&CPPCodeEnum::enumMembers, _val), _1)])|
            mRuleMemberDefaultValue[phoenix::insert(phoenix::bind(&CPPCodeEnum::enumMembers, _val), _1)])
            %',')>>
            //可有可无的逗号小尾巴
            -char_(",")>>
            char_("}");
    }
    //成员值的计数器
    int mTempValue;

    qi::rule<Iterator,::std::pair<::std::string,int>(),ascii::space_type> mRuleMemberValue;
    qi::rule<Iterator,::std::pair<::std::string,int>(),ascii::space_type> mRuleMemberDefaultValue;
    qi::rule<Iterator, std::string(),ascii::space_type> mRuleCPPValueName;
    qi::rule<Iterator, CPPCodeEnum(),ascii::space_type> mRuleEntrence;
};
}


int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);

//模拟C++的一段代码
    //simulate C++ code
::std::string teststr="enum _0_my_e_name_1233 {m1,m2,m3  ,m4 =5 ,m5 =90,m6}";


using boost::spirit::ascii::space;

std::string::const_iterator iter = teststr.begin();
std::string::const_iterator end = teststr.end();

haha::CPPCodeEnumGrammar<std::string::const_iterator> myCPPCodeEnumGrammar;
haha::CPPCodeEnum data;

bool r = phrase_parse(iter, end, myCPPCodeEnumGrammar,  space, data);


return a.exec();
}