文法构造二

最新推荐文章于 2024-05-31 14:42:05 发布
最新推荐文章于 2024-05-31 14:42:05 发布
阅读量488 收藏 9
点赞数 9
分类专栏： 编译原理 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51963455/article/details/135006278
版权

一、实验目的

        在实验《文法构造一》的基础上，改进文法数据结构的设计，实现First集、Follow集和Select集的计算，进一步加深对文法的理解。

二、实验内容

需要实现的功能：

1）实现First集、Follow集和Select集的计算；

2）输入文法：文法描述存储在文本文件中，文件名作为命令行参数输入；

3）输出每个非终结符的First集到标准输出设备；

4）输出每个非终结符的Follow集到标准输出设备；

5）输出每个产生式的Select集到标准输出设备；

附件：样例

描述：

算术表达式文法G =（VN，VT，P，S）其中：

   VN = { S, T, T’ }

   VT = { a, ^, (, ) ，}

   P = { S → a | ^ |(T)

   T → ST’

   T’ → ,ST’ | e }

   S = S

输入（文法描述文件）：

3

S T T'

5

a ^ ( ) ,

6

S -> a

S -> ^

S -> ( T )

T -> S T'

T' -> , S T'

T' -> ε

S

输出（标准输出设备）：

CFG=(VN,VT,P,S)

  VN: S T T'

  VT: a ^ ( ) ,

  Production:

     0: S -> a

     1: S -> ^

     2: S -> ( T )

     3: T -> S T'

     4: T' -> , S T'

     5: T' -> ε

  StartSymbol: S

[First Set]

  S               : ^  (  a 

  T               : ^  (  a 

  T'              : ε  , 

[Follow Set]

  S               : #  ,  ) 

  T               : ) 

  T'              : ) 

[Select Set]

   0:S -> a                         : a 

   1:S -> ^                         : ^ 

   2:S -> ( T )                     : ( 

   3:T -> S T'                      : ^  (  a 

   4:T' -> , S T'                   : , 

   5:T' -> ε                       : ) 

三、代码

#include <fstream>
#include <sstream>
#include "iostream"
#include "set"
#include "string"
#include "map"
#include "vector"
using namespace std;
#ifndef BIANYI_WENFA_H
#define BIANYI_WENFA_H

class VN{   //非终结符集
private:
    int n;
    set<string> vn;
public:
    int getN() const {
        return n;
    }

    const set<string> &getVn() const {
        return vn;
    }

    void setVn(const set<string> &vn) {
        VN::vn = vn;
    }

    void setN(int n) {
        VN::n = n;
    }

};

class VT{   //终结符集
private:
    int n;
    set<string> vt;
public:
    int getN() const {
        return n;
    }

    void setN(int n) {
        VT::n = n;
    }

    const set<string> &getVt() const {
        return vt;
    }

    void setVt(const set<string> &vt) {
        VT::vt = vt;
    }
};

class P{    //产生式
private:
    int n;
    vector<string> p1;  //存放左部
    vector<vector<string>> p2;  //存放右部
public:
    const vector<vector<string>> &getP2() const {
        return p2;
    }

    void setP2(const vector<vector<string>> &p2) {
        P::p2 = p2;
    }

    const vector<string> &getP1() const {
        return p1;
    }

    void setP1(const vector<string> &p1) {
        P::p1 = p1;
    }

    int getN() const {
        return n;
    }

    void setN(int n) {
        P::n = n;
    }

};

class S{    //开始符号
private:
    string s;
public:
    const string &getS() const {
        return s;
    }

    void setS(const string &s) {
        S::s = s;
    }
};

class CFG{
private:
    string filename;
    VN vn;
    VT vt;
    P p;
    S s;
public:
    void setFilename(const string &filename) {
        CFG::filename = filename;
    }

    void fileop() {     //读文件
        string fileline;
        string str;
        set<string> middle;
        vector<string> p1;
        vector<string> mid;
        vector<vector<string>> p2;
        ifstream fout(filename);
        for (int i = 1; getline(fout, fileline); i++) {
            if (i == 1) {
                vn.setN(atoi(fileline.c_str()));//非终结符个数
            } else if (i == 2) {  //非终结符集合
                istringstream is(fileline);
                while (is >> str) {
                    middle.insert(str);
                }
                vn.setVn(middle);
                middle.clear();
            } else if (i == 3) {  //终结符个数
                vt.setN(atoi(fileline.c_str()));
            } else if (i == 4) {  //终结符集合
                istringstream is(fileline);
                while (is >> str) {
                    middle.insert(str);
                }
                vt.setVt(middle);
                middle.clear();
            } else if (i == 5) {  //规则个数
                p.setN(atoi(fileline.c_str()));
            } else if (i == p.getN() + 6) { //指定开始符
                s.setS(fileline.c_str());
            } else{
                istringstream is(fileline);
                for(int j=0;is>>str;j++){
                    if(j==0){
                        p1.push_back(str);
                    } else if(j==1);
                    else {
                        mid.push_back(str);
                    }
                }
                p2.push_back(mid);
                mid.clear();
            }
        }
        p.setP1(p1);
        p.setP2(p2);
    }

    void output(){  //输出CFG
        cout<<"CFG=(VN,VT,P,S)"<<endl;
        cout<<"VN: ";
        for(set<string>::iterator it=vn.getVn().begin();it!=vn.getVn().end();it++){
            cout<<*it<<" ";
        }
        cout<<endl<<"VT: ";
        for(set<string>::iterator it=vt.getVt().begin();it!=vt.getVt().end();it++){
            cout<<*it<<" ";
        }
        cout<<endl<<"Production:"<<endl;
        for(int i=0;i<p.getP1().size();i++){
            cout<<"     "<<i<<":"<<p.getP1()[i]<<" -> ";
            for(int j=0;j<p.getP2()[i].size();j++){
                cout<<p.getP2()[i][j];
            }
            cout<<endl;
        }
        cout<<"StartSymbol: ";
        cout<<s.getS()<<endl;
    }
    set<string> First1(string str){ //求单个非终结符First集
        set<string> first;
        set<string> second; //中间集合
        if(vt.getVt().count(str)==1){   //终结符本身即为其First集
            first.insert(str);
            return first;
        }
        for(int i=0;i<p.getP1().size();i++){
            if(str==p.getP1()[i]){  //在左部集找到该非终结符
                if(vt.getVt().count(p.getP2()[i][0])==1 || p.getP2()[i][0]=="ε"){   //如果产生式右部第一个字符为终结符或ε，则直接加入其First集
                    first.insert(p.getP2()[i][0]);
                }
                else if(vn.getVn().count(p.getP2()[i][0])==1){  //右部第一个为非终结符
                    for(int j=0;j<p.getP2()[i].size();j++){ //产生式右部遍历
                        if(vt.getVt().count(p.getP2()[i][j])==1){   //如果是终结符，加入first集，结束遍历
                            first.insert(p.getP2()[i][j]);
                            break;
                        }else if(vn.getVn().count(p.getP2()[i][j])==1 && j!=p.getP2()[i].size()-1){ //如果是非终结符
                            second =First1(p.getP2()[i][j]);    //递归调用
                            if(second.count("ε")==0){
                                first.insert(second.begin(),second.end());
                                second.clear();
                                break;
                            }
                            else{
                                second.erase("ε");
                                first.insert(second.begin(),second.end());
                                second.clear();
                            }
                        } else if(vn.getVn().count(p.getP2()[i][j])==1 && j==p.getP2()[i].size()-1){
                            second =First1(p.getP2()[i][j]);
                            first.insert(second.begin(),second.end());
                            second.clear();
                        }
                    }
                }
            }
        }
        return first;
    }

    void First(){   //求每一个非终结符First集
        map<string,set<string>> first;
        for(set<string>::iterator it=vn.getVn().begin();it!=vn.getVn().end();it++){
            first.emplace(*it, First1(*it));
        }
        cout<<"[First Set]"<<endl;  //输出First集
        for(map<string,set<string>>::iterator it=first.begin();it!=first.end();it++){
            cout<<it->first<<"  :";
            for(set<string>::iterator jj=it->second.begin();jj!=it->second.end();jj++){
                cout<<*jj<<" ";
            }
            cout<<endl;
        }
    }

    set<string> Follow1(string str) {   //求单个非终结符的Follow集
        set<string> follow;
        set<string> second;
        if (str == s.getS()) {
            follow.insert("#");     //若是开始符，则将#加入
        }
        for (int i = 0; i < p.getP2().size(); i++) {    //遍历产生式右部
            for (int j = 0; j < p.getP2()[i].size(); j++) {
                if (str == p.getP2()[i][j]) {
                    if (j == p.getP2()[i].size()-1) {   //若其后无元素，则将产生式左部follow集加入
                        if(p.getP1()[i]!=str){
                            second = Follow1(p.getP1()[i]); //递归调用
                            follow.insert(second.begin(), second.end());
                            second.clear();
                        }

                    }
                else{
                        if(vn.getVn().count(p.getP2()[i][j+1])==1){
                            for(int k=j+1;k<p.getP2()[i].size();k++){
                                second =First1(p.getP2()[i][k]);
                                if(second.count("ε")==0){
                                    follow.insert(second.begin(),second.end());
                                    second.clear();
                                    break;
                                } else {
                                    if(k==p.getP2()[i].size()-1){
                                        second.erase("ε");
                                        follow.insert(second.begin(),second.end());
                                        second.clear();
                                        if(p.getP1()[i]!=p.getP2()[i][k]){
                                            second = Follow1(p.getP1()[i]); //递归调用
                                            follow.insert(second.begin(), second.end());
                                            second.clear();
                                        }
                                    } else{
                                        second.erase("ε");
                                        follow.insert(second.begin(),second.end());
                                        second.clear();
                                    }

                                }
                            }
                        } else if(vt.getVt().count(p.getP2()[i][j+1])){
                            follow.insert(p.getP2()[i][j+1]);
                            break;
                        }
                }
               }
            }
        }
            return follow;
    }

    void Follow(){  //求所有非终结符的follow
        map<string,set<string>> follow;
        for(set<string>::iterator it=vn.getVn().begin();it!=vn.getVn().end();it++){
            follow.emplace(*it, Follow1(*it));
        }
        cout<<"[Follow Set]"<<endl;
        for(map<string,set<string>>::iterator it=follow.begin();it!=follow.end();it++){
            cout<<it->first<<"  : ";
            for(set<string>::iterator jj=it->second.begin();jj!=it->second.end();jj++){
                cout<<*jj<<" ";
            }
            cout<<endl;
        }
    }
    void Select(){  //Select集
        map<int,set<string>> select;
        set<string> second;
        set<string> sle;
        for(int i=0;i<p.getP2().size();i++){    //遍历产生式右部
            if(p.getP2()[i][0]=="ε"){   //若为空串，则将左部follow加入
                second= Follow1(p.getP1()[i]);
                sle.insert(second.begin(), second.end());
                second.clear();
                select.emplace(i,sle);
                sle.clear();
                continue;
            }
            for(int j=0;j<p.getP2()[i].size();j++){ //  计算产生式右部first集

                second=First1(p.getP2()[i][j]);
                if(second.count("ε")==0){
                    sle.insert(second.begin(),second.end());
                    second.clear();
                    break;
                } else{
                    if(j==p.getP2()[i].size()-1){
                        sle.insert(Follow1(p.getP1()[i]).begin(), Follow1(p.getP1()[i]).end());
                    }
                    second.erase("ε");
                    sle.insert(second.begin(),second.end());
                    second.clear();
                }
            }
            select.emplace(i,sle);
            sle.clear();
        }
        cout<<"[Select Set]"<<endl; //输出select集
        for(int i=0;i<p.getP1().size();i++){
            cout<<i<<" : "<<p.getP1()[i]<<"->";
            for(int k=0;k<p.getP2()[i].size();k++){
                cout<<p.getP2()[i][k]<<" ";
            }
            cout<<" : ";
            for(set<string>::iterator j=select[i].begin();j!=select[i].end();j++){
                cout<<*j<<" ";
            }
            cout<<endl;
        }
    }
};
#endif //BIANYI_WENFA_H
int main(){
    string filename;
    CFG cfg;
    cout<<"Please input file(absolute path; eg: D://filename.txt):"<<endl;  //E://by//exp5.txt
    cin>>filename;
    cfg.setFilename(filename);
    cfg.fileop();
    cfg.output();
    cfg.First();
    cfg.Follow();
    cfg.Select();
    return 0;
}

zz7_up
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
从正则文法构造有穷状态自动机
sinat_40767922的博客
05-14 2357
#include&lt;iostream&gt;#include&lt;string&gt; #include&lt;vector&gt; using namespace std; #define max 100    struct edge{     string first;//边的初始结点  string change;//边的条件  string last;//边的终点  };  int ...
由正规文法构造正规式
11-25
编译原理实验 输入任意的正规文法,输出相应的正规式
文法构造习题
P_c
03-04 2036
1、{ an | n >= 0 } G[S]:S -> aaaS | ε\varepsilonε 考虑边界，ε\varepsilonε为空（即n=0时） 2、{ anb2m-1 | m,n >=1 } 2m-1：b的个数为奇数个 G[S]:S -> AB A -> aA | a B -> b | bbB B -> b | bbB 使以一个b开头，两...
右线性文法构造有穷自动机
m0_37840214的博客
05-27 3346
1若干概念 右线性文法生成的语言是右线性语言，有限自动机识别和接受的语言是正则语言。而正则文法是左线性文法和右线性文法的统称，所以右线性语言类与正则语言类是同一语言类。 定义1 设G[S]=(VN，VT，P，S)为CFG，若P中的产生或均有如下的形式:A→aB或A→a(A∈VN，a∈VT）则称G为右线性文法。例如，文法G1[S]=({S,A,B}，{a,b}，P1,S)其中P1={S→a...
2.3 文法的构造
tang7mj的博客
03-04 1135
理解形式语言与自动机的基础之一是掌握如何构造文法。文法不仅定义了语言的结构，还提供了分析和生成语言句子的方法。本节将探讨构造文法的过程，通过具体语言的例子，展示不同的文法构造方法。构造文法的过程是多样的，依赖于语言的特性以及构造者的经验。我们通过几个例子来具体理解这一过程。考虑构造文法 G 以生成语言 L(G)={0,1,00,11}。这个语言很简单，包含四个句子。最直接的方法是定义开始符号为这四个句子。例如： 这种方法简单直观，但随着语言句子数量的增加，可能不是最有效的。另一种方法是引入变量以表示单个
java文法构造_(1)构造文法G的LR(0)项目 (2)构造文法G的LR(0)项目集规范族及识别活前缀的DFA...
weixin_36018494的博客
02-28 2186
(1)构造文法G的LR(0)项目(2)构造文法G的LR(0)项目集规范族及识别活前缀的DFA 2016-08-23 0 0 0 4.0分 其他 1积分下载 如何获取积分？(1)构造文法G的LR(0)项目(2)构造文法G的LR(0)项目集规范族及识别活前缀的DFA(3)证明文法G不是LR(0)文法而是SLR(1)文法，并构造SLR(1)分析表(4)设计LR语法分析程序，且能输出分析过程(5)...
正规文法构造状态转换图，状态转换图构造正规文法---编译原理
Cenhelm的博客
04-25 8496
从左线性正规文法出发，构造状态图 注意：增设初态S，单圆圈表示 例子 从右线性正规文法出发，构造状态图 注意：增设终态Z，双圆圈表示 例子 状态转换图构造左线性正规文法 注意：写左线性正规文法时从终态开始 例子 状态转换图构造右线性正规文法 注意：写右线性正规文法时从初态开始 例子 ...
编译原理 | 由正规文法构造状态转换图
热门推荐
Wonz
04-16 1万+
词法分析 ：由正规文法构造状态转换图 解题方法 1. 由左线性文法构造状态转换图 左线性文法G=(VN,VT,P,Z)(1)G中形如U::=Ba,则可化成：B—(a)—&gt;U（表示状态B向状态U引一条箭弧线并标记符号a，不方便画图，就直接这样表示了，你们懂就行）(2)G中形如U::=a,则可化成：S—(a)—&gt;U（表示初始状态S向状态U引一条箭弧线并标记符号a）(3...
【编译原理】2—语言构造文法的方法⭐
一棵灬大树的博客
11-27 4379
语言构造文法的四种方法- 对称法、逐步求精法（分解法）、等价法、电路状态转换法
右线性文法构造有穷自动机.zip
05-27
右线性文法生成的语言是右线性语言，有限自动机识别和接受的语言是正则语言。而正则文法是左线性文法和右线性文法的统称，所以右线性语言类与正则语言类是同一语言类。
[典例]编译原理学习笔记·文法的构造
10-11
对于文章里有举的一些例子来讲关于构造文法的补充！ 不同于网上的一些讲义没有详细过程，只有一些枯燥、乏味的文字。这里提供了部分推导过程的动画演示，更加直观易懂。
编译原理文法构造first,select,follow实验源代码
03-30
C语音代码。实现功能：1....2.求每个非终结符FIRST 集FOLLOW集和SELECT集模块。3.预测分析表的构建模块。4.文法的检验及消除左公因子和左递归模块。5.对输入终结符串的判断，是否为LL1文法，并进一步分析。
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 895
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
【最新区块链论文录用资讯】CCF A—INFOCOM 2024 共17篇
软件工程小施同学 的专栏
05-28 1469
详情：https://infocom2024.ieee-infocom.org/program/accepted-paper-list-main-conference。BR-DeFedRL：具有快速收敛和通信效率的拜占庭式鲁棒去中心化联邦强化学习。FileDES：一个安全、可扩展、简洁的基于区块链的去中心化加密存储网络。CRACKLE：具有次线性通信复杂性的基于扇区的快速 BFT 共识。通过可逆 GAN 实现高容量的基于区块链的通用隐写术框架。通过树图区块链的半异步去中心化联邦学习框架。
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 848
string类各函数接口。
C语言 指针——指针变量的定义、初始化及解引用
hangweijie的博客
05-29 1225
目录指针内存如何编址？如何对变量进行寻址？用什么类型的变量来存放变量的地址?如何显示变量的地址?​编辑使用未初始化的指针会怎样？NULL是什么？如何访问指针变量指向的存储单元中的数据？指针变量的定义和初始化
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 347
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
C++ 多重继承的内存布局和指针偏移
Damon_X的博客
05-30 307
在 C++ 程序里，在有多重继承的类里面。偏移的大小，等于派生类的继承顺序表里面，排在该类前面的所有的类的数据成员（含虚表指针）所占的空间大小总和。注意：在 D 的继承关系链里面，只有基类 B 有虚函数，因此对于 D 对象而言，总体只有一个虚表指针，也就是（B）基类对象中的虚表指针。D 继承自A, B, C，它的大小等于 A, B, C 的所有数据成员的大小，加上其自身的数据成员和虚表指针的总的大小：4(b) + 4(c) + 4(d) + 8(vptr) = 20 字节。我们首先来分析这四个类的大小。
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
weixin_73886306的博客
05-30 381
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
为正规文法构造最小DFA
03-27
2. 对每个非终结符号构造一个DFA状态。 3. 对于每个产生式A->aB，构造一条由状态A到状态B的标记为a的转移边。 4. 对于每个产生式A->a，构造一条由状态A到一个终结符号节点的标记为a的转移边。 5. 然后将每个非...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值