编译原理项集规范族（初步）

最新推荐文章于 2024-04-02 11:07:25 发布
原创 最新推荐文章于 2024-04-02 11:07:25 发布 · 1.2k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个使用C++实现的LR语法分析器程序，该程序能够接收用户输入的文法并构建LR项集规范族。通过对输入文法的处理，程序能够识别文法中的终结符和非终结符，并通过闭包运算生成相应的项集。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#include<bits/stdc++.h>
using namespace std;
int Norterminal(char c)
{
    if(c>='A'&&c<='Z') 
        return 1;
    else if(c!=':'&&c!='='&&c!='<'&&c!='>'&&c!=' '&&c!='|') 
        return 0; 

} 
struct LR
{
    string  nape;//项
    vector<string> str;
    string later;//后继关系 
};
int main()
{
    cout<<"请输入文法（以#结束）"<<endl;
    vector<string> strN; //保存文法 
    LR Lr[100]; 
    //输入文法 
    string grammer;
    cin>>grammer;
    string nonterm="";
    strN.push_back(grammer);  
    for(int i=0;grammer!="#";i++)
    {
        cin>>grammer;
        strN.push_back(grammer); 

    }
    //变为增广文法 
    string s="Z::=";
    s+=strN[0][0];
    s+='#';
    strN.insert(strN.begin(),s);
    for(int i=0;i<strN.size();i++)
    {
        if(Norterminal(strN[i][0]))
            nonterm+=strN[i][0];
        string ustr(nonterm);
        sort(ustr.begin(), ustr.end());
        ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
        nonterm=ustr;

    } 
    nonterm.erase(nonterm.end() - 1);
//  cout<<nonterm<<endl; 
    //求解初始项集的闭包 
//  cout<<"初始项集"<<endl; 
    Lr[0].str.push_back(strN[0]);  
    char non; 
    //找第一个终结符   
    if(Norterminal(strN[0][4]))
    {
        Lr[0].nape=s[0];
        non=strN[0][4]; 
        Lr[0].str[0][3]='.';
        Lr[0].str[0][2]='>';
        Lr[0].str[0][1]='-'; 
    }
    for(int j=1;j<strN.size();j++)
    {
            if(non==strN[j][0])
            {
                Lr[0].str.push_back(strN[j]);  
                int h=Lr[0].str.size(); 
                Lr[0].str[h-1][3]='.';
                Lr[0].str[h-1][2]='>';
                Lr[0].str[h-1][1]='-'; 
                if(Norterminal(strN[j][4])&&strN[j][4]!=non)
                {

                    for(int g=1;g<strN.size();g++) 
                    {

                        if(strN[g][4]==non&&j!=g)
                        {
                            Lr[0].str.push_back(strN[g]);  
                            int h1=Lr[0].str.size(); 
                            Lr[0].str[h1-1][3]='.';
                            Lr[0].str[h1-1][2]='>';
                            Lr[0].str[h1-1][1]='-';
                        } 


                     }
                     non=strN[j][4];
                }

            } 

    } 
/*  for(int i=0;i<Lr[0].str.size();i++)
    {
        for(int j=0;j<Lr[0].str.size();j++)
        {
            if(Lr[0].str[i].compare(Lr[0].str[j])==0&&i!=j)
                Lr[0].str.erase(Lr[0].str.begin()+j);
        }
        cout<<Lr[0].str[i]<<endl; 
    }  */
    /*求解项集规范族 */
    //求解当前项集中的终结符与非终结符以便于后续的存放。 
    string nont;//存放当前闭包$后边遇到的字母 
    int totalnum=1;
   //偶数遍历 
    for(int r=0;r<totalnum;r++)
    {
            nont="";
            for(int i=0;i<Lr[r].str.size();i++)
            {
                for(int j=0;j<Lr[r].str[i].length();j++)
                {
                    if(Lr[r].str[i][j]=='.'&&j+1!=Lr[r].str[i].length())
                    {
                        nont+=Lr[r].str[i][j+1];
                    }
                }
                string ustr(nont);
                sort(ustr.begin(), ustr.end());
                ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                nont=ustr;
                //Lr[r].later=nont;
            }   
        //  now=r;
            //cout<<nont<<":"<<r<<endl;
            for(int i=0;i<nont.length();i++)
            {
                Lr[totalnum+i].nape=nont[i];

             } 

             //将.后移 
            for(int i=0;i<Lr[r].str.size();i++)
            {
                for(int j=0;j<Lr[r].str[i].length();j++)
                {
                    if(Lr[r].str[i][j]=='.')
                    {
                        for(int l=0;l<nont.length();l++)
                        {
                            if(Lr[r].str[i][j+1]==Lr[totalnum+l].nape[0])
                            {
                                Lr[r].str[i].erase(Lr[r].str[i].begin()+j);
                                Lr[r].str[i].insert(Lr[r].str[i].begin()+j+1,'.');
                                Lr[totalnum+l].str.push_back(Lr[r].str[i]);
                                Lr[r].str[i].erase(Lr[r].str[i].begin()+j+1);
                                Lr[r].str[i].insert(Lr[r].str[i].begin()+j,'.');
                            }
                         } 

                    }
                }
            }
           //若遇到终结符进行闭包运算 
            for(int i=0;i<nont.length();i++)
           {

                for(int k=0;k<Lr[totalnum+i].str.size();k++)
                {

                    for(int g=0;g<Lr[totalnum+i].str[k].length();g++)
                    {
                        if(Lr[totalnum+i].str[k][g]=='.'&&g+1!=Lr[totalnum+i].str[k].length())
                        {

                            if(Norterminal(Lr[totalnum+i].str[k][g+1]))
                            {
                                non=Lr[totalnum+i].str[k][g+1];
                                for(int j1=1;j1<strN.size();j1++)
                                { 
                                    if(non==strN[j1][0])
                                    {
                                        Lr[totalnum+i].str.push_back(strN[j1]);  
                                        int h=Lr[totalnum+i].str.size(); 
                                        Lr[totalnum+i].str[h-1][3]='.';
                                        Lr[totalnum+i].str[h-1][2]='>';
                                        Lr[totalnum+i].str[h-1][1]='-'; 
                                        if(Norterminal(strN[j1][4]))
                                        {

                                            for(int g1=1;g1<strN.size();g1++) 
                                            {

                                                if(strN[g1][4]==non&&j1!=g1&&strN[g][0]==strN[g1][4])
                                                {
                                                    Lr[totalnum+i].str.push_back(strN[g1]);  
                                                    int h1=Lr[totalnum+i].str.size(); 
                                                    Lr[totalnum+i].str[h1-1][3]='.';
                                                    Lr[totalnum+i].str[h1-1][2]='>';
                                                    Lr[totalnum+i].str[h1-1][1]='-';
                                                } 


                                             }
                                             non=strN[j1][4];
                                        }

                                    } 

                                }
                                break;
                           }
                       }

                    }
                    break;

                }
           }
          r+=1;
          if(nont.length()!=0)
            totalnum+=nont.length();

    }  
    //奇数遍历 
    for(int r=1;r<totalnum;r++)
    {
            nont="";
            for(int i=0;i<Lr[r].str.size();i++)
            {
                for(int j=0;j<Lr[r].str[i].length();j++)
                {
                    if(Lr[r].str[i][j]=='.'&&j+1!=Lr[r].str[i].length())
                    {
                        nont+=Lr[r].str[i][j+1];
                    }
                }
                string ustr(nont);
                sort(ustr.begin(), ustr.end());
                ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                nont=ustr;
            //  Lr[r].later=nont;
            }   
        //  now=r;
            //cout<<nont<<":"<<r<<endl;
            for(int i=0;i<nont.length();i++)
            {
                Lr[totalnum+i].nape=nont[i];

             } 

             //将.后移 
            for(int i=0;i<Lr[r].str.size();i++)
            {
                for(int j=0;j<Lr[r].str[i].length();j++)
                {
                    if(Lr[r].str[i][j]=='.')
                    {
                        for(int l=0;l<nont.length();l++)
                        {
                            if(Lr[r].str[i][j+1]==Lr[totalnum+l].nape[0])
                            {
                                Lr[r].str[i].erase(Lr[r].str[i].begin()+j);
                                Lr[r].str[i].insert(Lr[r].str[i].begin()+j+1,'.');
                                Lr[totalnum+l].str.push_back(Lr[r].str[i]);
                                Lr[r].str[i].erase(Lr[r].str[i].begin()+j+1);
                                Lr[r].str[i].insert(Lr[r].str[i].begin()+j,'.');
                            }
                         } 

                    }
                }
            }
    //若遇到终结符进行闭包运算 
            for(int i=0;i<nont.length();i++)
           {

                for(int k=0;k<Lr[totalnum+i].str.size();k++)
                {

                    for(int g=0;g<Lr[totalnum+i].str[k].length();g++)
                    {
                        if(Lr[totalnum+i].str[k][g]=='.'&&g+1!=Lr[totalnum+i].str[k].length())
                        {

                            if(Norterminal(Lr[totalnum+i].str[k][g+1]))
                            {
                                non=Lr[totalnum+i].str[k][g+1];
                                for(int j1=1;j1<strN.size();j1++)
                                { 
                                    if(non==strN[j1][0])
                                    {
                                        Lr[totalnum+i].str.push_back(strN[j1]);  
                                        int h=Lr[totalnum+i].str.size(); 
                                        Lr[totalnum+i].str[h-1][3]='.';
                                        Lr[totalnum+i].str[h-1][2]='>';
                                        Lr[totalnum+i].str[h-1][1]='-'; 
                                        if(Norterminal(strN[j1][4]))
                                        {

                                            for(int g1=1;g1<strN.size();g1++) 
                                            {

                                                if(strN[g1][4]==non&&j1!=g1&&strN[g][0]==strN[g1][4])
                                                {
                                                    Lr[totalnum+i].str.push_back(strN[g1]);  
                                                    int h1=Lr[totalnum+i].str.size(); 
                                                    Lr[totalnum+i].str[h1-1][3]='.';
                                                    Lr[totalnum+i].str[h1-1][2]='>';
                                                    Lr[totalnum+i].str[h1-1][1]='-';
                                                } 


                                             }
                                             non=strN[j1][4];
                                        }

                                    } 

                                }
                                break;
                           }
                       }

                    }
                    break;

                }
           }
          r+=1;
          if(nont.length()!=0)
            totalnum+=nont.length();

    }
   cout<<totalnum<<endl;
   for(int i=0;i<totalnum;i++)
   {
        if(Lr[i].str.size()>0)
        { 
            cout<<Lr[i].nape<<"后继项集"<<i<<Lr[i].later<<endl; 
            for(int p=0;p<Lr[i].str.size();p++)
            {
             sort(Lr[i].str.begin(),Lr[i].str.end());
             Lr[i].str.erase(unique(Lr[i].str.begin(), Lr[i].str.end()), Lr[i].str.end());
             cout<<Lr[i].str[p]<<endl;

            }
        }       
    }
    /*清除相同的项*/
    //cout<<"相同的vector"<<endl;
    for(int i=0;i<totalnum;i++)
    {
        for(int j=0;j!=i,j<totalnum;j++)
        {
            if(j!=i&&Lr[i].str==Lr[j].str)
            {
            /*  cout<<Lr[j].nape<<"后继项集"<<j+1<<endl; 
                //打印相同的项 
            /*  for(int p=0;p<Lr[j].str.size();p++)
                {

                 cout<<Lr[j].str[p]<<endl;

                }*/
                Lr[j].str.clear();
                //totalnum--;
                break;
            }

        }
    } 
    int termnum=0;
    for(int i=0;i<totalnum;i++)
   {
        if(Lr[i].str.size()>0)
        { 
            termnum++;
        }
    }
//  cout<<"项的个数为"<<termnum<<endl;
   /* cout<<"清除相同的vector后的结果:"<<endl; */ 
    //cout<<totalnum<<endl;

    cout<<"项集规范族为："<<endl; 
    int termID=0;//项的编号
    for(int i=0;i<totalnum;i++)
   {
        bool flag=false;
        if(Lr[i].str.size()>0)
        { 

            //求解后继项 
            nont="";
            for(int l=0;l<Lr[i].str.size();l++)
            {
                for(int j=0;j<Lr[i].str[l].length();j++)
                {
                    if(Lr[i].str[l][j]=='.'&&j+1!=Lr[i].str[l].length())
                    {
                        nont+=Lr[i].str[l][j+1];
                    }
                }
                string ustr(nont);
                sort(ustr.begin(), ustr.end());
                ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                nont=ustr;
                Lr[i].later=nont;
            }

            if(Lr[i].nape[0]=='#')
            {
                flag=true;
                cout<<termnum-1<<"\t"<<Lr[i].nape<<"后继项集"<<endl;
            }

            if(flag==false)
            {
                cout<<termID++<<"\t";
                cout<<Lr[i].nape<<"后继项集"<<endl;//<<"具体为："<<Lr[i].later<<endl; 
            }

            for(int p=0;p<Lr[i].str.size();p++)
            {

             cout<<"\t"<<Lr[i].str[p]<<endl;

            }
        }       
    }
}

输入文法：
E::=aA
E::=bB
A::=d
A::=cA
B::=cB
B::=d
#
运行结果：
这里写图片描述

大学编译原理试卷考试题
张晨光老师的播客
07-06 8755
《编译原理》期末试题（一） 一、是非题（请在括号内，正确的划√，错误的划×）（每个2分，共20分） 1．编译程序是对高级语言程序的解释执行。(× ) 2．一个有限状态自动机中，有且仅有一个唯一的终态。(×) 3．一个算符优先文法可能不存在算符优先函数与之对应。 (√ ) 4．语法分析时必须先消除文法中的左递归 。 (×) 5．LR分析法在自左至右扫描输入串时就能发现错误，但不能准确地指出出错地点。 (√) 6．逆波兰表示法表示表达式时无须使用括号。 (√ ) 7．静态数组的存储空间可以在编译时确定。 (×)
什么是编译原理
Lvorie的博客
05-11 511
编译原理是介绍如何将高级程序设计语言转换成计算机硬件能识别的机器语言，以便计算机进行处理。
编译原理 LR（0）项目集规范族的构造 LR(0)分析表+分析串的代码实现
12-06
编译原理作业：输出LR（0）分析表，并且可以判断一个语句是否符合文法。整个过程我是使用codeblocks的c++编写的，其中用了一下STL标准库中的队列、映射。这是实现功能的详细代码，有注释的伪代码以及测试用的相关样例数据。
编译原理与技术大纲
Jinyao的博客
08-20 322
编译原理与技术大纲 第一章 引论 1.1 编译器概述 1.1.1 词法分析 它分析扫描构成源程序的字符流，按编程语言的词法规则把它们组成词法记号流。 对于一个词法单元，词法分析产生的记号是 &lt;记号名，属性值&gt; 1.1.2 语法分析 它按编程语言的语法规则检查词法分析出的记号流是否符合这些规则 1.1.3 语义分析 把各...
LR(1)语法分析 编译器 项目集构造课程设计
05-31
LR(1)语法分析 编译器 项目集构造……不错的程序，可以实现的语法分析……
项目集规范族
04-09
生成文法的项目集规范族，生成状态集和状态集之间的迁移表，产生确定有限状态机
编译原理学习笔记
someng的博客
12-11 2711
第一章 总论 编译程序功能 从基本功能上看，编译程序是一种翻译程序。将高级语言程序（源程序）翻译至低级语言程序（目标程序）。 编译程序的组成 前端：词法分析，语法分析，语义分析（分析） 中端：中间代码生成和优化（综合） 后端：目标代码生成和优化（综合） 词法分析（扫描程序） 从左到右一个字符一个字符地扫描源程序字符，根据词法规则识别出具有独立意义的最小语单位-单词。并把它们转换成通常是等长的...
《编译原理》——期末复习.docx
06-10
通过本章的学习，学生可以对编译原理有一个初步的认识，并了解该课程的学习目标和预期成果。 - **编译过程**：此部分详细阐述了编译过程的基本步骤，包括词法分析、语法分析、语义分析、中间代码生成、代码优化以及...
编译原理期末作业词法分析器.docx
12-04
词法分析是编译原理中的一个重要环节，它的主要任务是对源程序进行初步处理，将源代码分解成一个个具有独立意义的单词（tokens），这些单词包括保留字、标识符、常数、运算符和分界符等。在这个实验中，学生需要设计...
编译原理课后答案
12-05
编译原理是计算机科学中的一个重要领域，涉及到将...通过以上总结，我们对编译原理的基本概念、编译程序的组成和功能、以及不同类型的翻译程序有了全面的理解，同时也对常见的编译错误及其可能的来源有了初步的认识。
编译原理实验（词法分析、LL1分析、LR1分析）
09-04
大三上学期的编译原理实验，自己用C#写的代码。有词法分析、LL1分析、LR1分析这三次实验。
LR(0)项目集规范族构造
12-17
LR(0)项目集规范族的构造，按照编译原理相应的算法
LR(1)项目集族的构造：如何确定前向搜索符（旧版）
热门推荐
hhhhhhhhhhkkkkkkkkkk的专栏
02-26 2万+
已经按照markdown格式重新改写和发布，链接 https://blog.youkuaiyun.com/hhhhhhhhhhkkkkkkkkkk/article/details/85680859     按照这个标题搜进来的各位是不是以为这也是和课本一样的内容呢，其实这是我看了两天课本才理解出来的内容啊，绝对和课本不一样。     课本上LR(1)项目集族的构造内容如下：     以S′→·S，#属于...
LR(1)分析法
qq_55168827的博客
04-28 1万+
1.LR(1)分析表和LR(1)文法 （1）按上述算法构造的分析表，若不存在多重定义的入口(即，动作冲突)的情形，则称它是 文法G的一张规范的LR(1)分析表。 （2）具有规范的LR(1)分析表的文法称为一个LR(1)文法。 （3）使用LR(1)分析表的分析器叫做一个规范的LR分析器。 （4）LR(1)状态比SLR(1)多。 （5）LR(O)∈ SLR(1)∈ LR(1)∈无二义文法。 2.SLR冲突消解存在的问题 （1）LR(1)和SLR(1)分析表构造方法的对比 ...
编译原理第五章——自下而上分析——LR(1)超详细分析！
最新发布
woshihlf的博客
04-02 4160
编译原理第五章——自下而上分析——LR(1)超详细分析！
编译原理12：活前缀、项目集规范族、LR（0）分析表
weixin_51633776的博客
11-24 8319
编译原理12：活前缀、项目集规范族、LR（0）分析表
编译原理结构框架5自底向上的语法分析
〓星★愿〓
12-02 4366
第五章 自底向上的语法分析       重点：自底向上分析的基本思想，算符优先分析法的基本思想，简单算符优先分析法。LR分析器的基本构造思想，LR分析算法，规范句型活前缀及其识别器——DFA，LR(0)分析表的构造，SLR(1)分析表的构造,LR(1)分析表的构造。 难点：求FIRSTOP和LASTOP，算符优先关系的确定，算符优先分析表的构造，素短语与最左素短语的概念。规范句
【编译原理笔记07】语法分析：SLR、LR(1)、LALR、二义性分析与错误处理
记录学习痕迹的公众号：Piper蛋窝
07-28 1万+
上节课的内容中，LR(0)存在冲突。这节课首先提出SLR进行解决。SLR的改进很简单，但还存在冲突。因此又引出LR(1)。 但是，LR(1)的状态过多，于是引出LALR化简、合并其状态。 最后，介绍了二义性与错误处理。
【期末总结】编译原理
cleanlii的博客
01-11 694
编译原理期末复习大纲
华中科技大学编译原理实验课程代码分享
华中科技大学编译原理实验的知识点涉及到编译原理课程的核心内容和实验操作，通常这部分课程是计算机科学与技术专业的重要组成部分，旨在让学生了解和掌握从高级语言到机器语言的整个翻译过程。以下是对给定文件中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值