编译原理实验二——消除一切文法的左递归(c++实现)

已于 2023-05-12 20:51:43 修改
阅读量3.7k 收藏 73
点赞数 15
分类专栏： 编译原理 文章标签： c++
于 2023-05-12 20:33:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56067262/article/details/130649054
版权

编译原理实验二——消除文法的左递归(c++实现)

首先给出书中的算法截图：
在这里插入图片描述
第一步：处理产生式的输入

所有产生式使用一个结构体存储：

struct node
{
	string left;
	set<string>right;
};

可以看到，left代表产生式的左部，right代表产生式的右部，而且是一个集合。
例如S->Qc|c,在程序中，left=S,right=Qc,c
输入的结果保存在一个vector的数据结构中，并起名为v
输入函数为：

void getproduction()
{
	printf("若一个非终结符可推出多个结果，请直接以 | 分隔，不必分开输入\n");
	printf("输入产生式,以$为结束标志:\n");
	string str;
	while (cin >> str && str[0] != '$')
	{
		vector<node>ret = mysplit(str);
		v.push_back(ret[0]);
	}

}

由于输入是一整行字符串，所以我们需要根据字符将产生式的左部和右部的结果剥离出来，在这里调用mysplit()函数。下面是mysplit()函数的具体代码。

vector<node> mysplit(string str)
{
	string vleft;
	set<string>vright;
	string temp = "";
	for (int i = 0; i < str.size(); i++)
	{
		if (str[i] == '>')continue;
		if (str[i] == '-')
		{
			vleft=temp;
			temp = "";
			continue;
		}
		if (str[i] == '|')
		{
			vright.insert(temp);
			temp = "";
			continue;
		}
		temp += str[i];
	}
	if (temp != "")vright.insert(temp);
	vector<node>ret;
	struct node N = {vleft,vright};
	ret.push_back(N);
	return ret;
}

代码原理很简单，直接遍历字符串，遇到-，>,| 等特殊字符就对应插入left或right中。

第二步：获取所有非终结符，并排序

void getnotend()
{
	set<string>tempset;
	for (int i = 0; i < v.size(); i++)
	{
		tempset.insert(v[i].left);

	}

	set<string>::iterator it = tempset.begin();
	for (it; it != tempset.end(); it++)
	{
		notend.push_back(*it);
	}
	
}

getnotend()函数获取了所有的非终结符。直接遍历v中保存的所有产生式的左部，存入set中。
（v是保存了所有产生式的变量名，为vector类型）
所有的非终结符被保存在notend中，其定义为vector类型

第三步：两层for循环，在这里封装成了myoperate()函数。

void myoperate()
{
	for (int i = 0; i < notend.size(); i++)//FOR i:=1 TO N DO
	{
		for (int j = 0; j < i; j++)//FOR j:=1 TO i-1 DO
		{
			int posi=-1, posj=-1;			
			for (int k = 0; k < v.size(); k++)
			{
				if (v[k].left == notend[i])/*遍历所有产生式，找到第i个非终结符在所有产生式中的位置*/
				{
					posi = k;
					break;
				}
			}
			for (int k = 0; k < v.size(); k++)/*遍历所有产生式，找到第i个非终结符在所有产生式中的位置*/
			{
				if (v[k].left == notend[j])
				{
					posj = k;
					break;
				}
			}
			if (posi == -1 || posj == -1)continue;/*如果找不到，就不执行下面的代码。例如：非终结符S在v中是第3个，非终结符R在v中是第1个，则posi=3,posj=1*/

			set<string>::iterator it = v[posi].right.begin();
			set<string>::iterator it2 ;
			set<string>tempset;
			for (it; it != v[posi].right.end(); it++)
			{
				string tempstr = *it;
				string ss;
				if (tempstr.find(notend[j]) != -1)
				{
					for (it2 = v[posj].right.begin(); it2 !=v[posj].right.end(); it2++)
					{
						ss = tempstr;
						ss = myreplace(ss, notend[j], *it2);
						tempset.insert(ss);
					}
					
				}
			}
			vector<string>temv;
			for (it = v[posi].right.begin(); it != v[posi].right.end(); it++)
			{
				string str = *it;
				if (str.find(notend[j]) != -1)
					temv.push_back(str);
			}
			for (int x = 0; x < temv.size(); x++)
			{
				it = v[posi].right.find(temv[x]);
				if (it != v[posi].right.end())
					v[posi].right.erase(it);
			}
			for (it = tempset.begin(); it != tempset.end(); it++)
				v[posi].right.insert(*it);
			erasedirect(posi);

		}
	}
}

在这里给出此函数的解释，代码中使用了许多临时变量记录信息。但整体思路如下：
以书本中给出的例子，有一个文法：
（1）S->Qc|c
(2) Q->Rb|b
(3) R->Sa|a

求它消除左递归的最终文法。

由于代码中下标从0开始，当i=2,j=0时，我们看第（1），第（3）个产生式。我们拿出第（3）个产生式的所有右部，得到 Sa和a。对每一个右部，若它有第j个非终结符，就可以把第j个终结符可以推出的所有结果拿来替换。
比如，我们拿出Sa,发现它有第j个非终结符S，所以S可以推出的所有结果都可以换到Sa身上，Sa就可以变成Qca和ca. 然后，我们拿出a,发现它没有S，直接跳过。最后，R->Qca|ca|a,也就是书中的答案。

代码中已对一些细节做了考虑，具体参考代码。

第四步：消除Ai中的一切直接左递归

首先，直接左递归见书中的定义：

在这里插入图片描述
A->Aa1|Aa2|…|Aam|b1|b2|b3|b3

那么，我们就看产生式是不是满足这种形式

首先如何判断b1,b2,b3?
如果右部没有大写字母，就可以认为它是b1,b2,b3
因此，有了下面的函数：

bool allend(string str)
{
	for (int i = 0; i < str.size(); i++)
	{
		if (str[i] >= 'A' && str[i] <= 'Z')
			return false;
	}
	return true;
}

如何判断右部是与左部一样的字符串开头呢
首先给出c++字符串查找函数find(),rfind（）。
find()可以从前往后找，找到第一个匹配的字符串，返回下标，如果找不到，返回-1
rfind()可以从后往前找，找到第一个匹配的字符串，返回下标，如果找不到，返回-1

那么，我们可以从前往后找，再从后往前找，如果遇到的第一个匹配字符都是下标为0，说明符合
A->Aa这种形式。比如 A->AabcA, find（）的结果是0，rfing（）的结果是4。

下面给出消除一切直接左递归的代码

void erasedirect(int posi)
{
	set<string>::iterator it = v[posi].right.begin();

	bool flag = true;
	for (it; it != v[posi].right.end(); it++)
	{
		string str = *it;
		if ((str.find(v[posi].left) == str.rfind(v[posi].left) && str.find(v[posi].left) == 0) || allend(str))
			flag = true;
		else
		{
			flag = false;
			break;
		}

	}
	if (!flag)return;

	vector<string>va, vb;
	for (it = v[posi].right.begin(); it != v[posi].right.end(); it++)
	{
		string str = *it;
		if (str.find(v[posi].left) == -1)
		{
			vb.push_back(str);
		}
		else
		{
			str.erase(0, v[posi].left.size());
			va.push_back(str);
		}
	}
	v[posi].right.clear();
	for (int i = 0; i < vb.size(); i++)
	{
		v[posi].right.insert(vb[i] + v[posi].left+"'");
	}

	set<string>ans;
	for (int i = 0; i < va.size(); i++)
	{
		ans.insert(va[i] + v[posi].left + "'");
	}
	ans.insert("Σ");
	struct node N = { v[posi].left + "'",ans };
	v.push_back(N);
}

首先我们确定Ai的产生式是不是满足A->Aa|b这种形式，如果不是，flag=false,直接结束运行，否则，继续往下做。

当我们确定Ai推出的式子都是Aa或b后，我们可以遍历Ai的所有右部，把Aa的抠出来，存在va中，b抠出来，存在vb中，然后字符串拼接答案，给非终结符加上一撇，就可以了。

最后给出完整的可运行代码：

#include<iostream>
#include<cmath>
#include<algorithm>
#include<map>
#include<vector>
#include<unordered_map> 
#include<set>
using namespace std;


struct node
{
	string left;
	set<string>right;
};
vector<node>v;
vector<string>notend;


bool allend(string str)
{
	for (int i = 0; i < str.size(); i++)
	{
		if (str[i] >= 'A' && str[i] <= 'Z')
			return false;
	}
	return true;
}


void getnotend()
{
	set<string>tempset;
	for (int i = 0; i < v.size(); i++)
	{
		tempset.insert(v[i].left);

	}

	set<string>::iterator it = tempset.begin();
	for (it; it != tempset.end(); it++)
	{
		notend.push_back(*it);
	}
	
}



vector<node> mysplit(string str)
{
	string vleft;
	set<string>vright;
	string temp = "";
	for (int i = 0; i < str.size(); i++)
	{
		if (str[i] == '>')continue;
		if (str[i] == '-')
		{
			vleft=temp;
			temp = "";
			continue;
		}
		if (str[i] == '|')
		{
			vright.insert(temp);
			temp = "";
			continue;
		}
		temp += str[i];
	}
	if (temp != "")vright.insert(temp);
	vector<node>ret;
	struct node N = {vleft,vright};
	ret.push_back(N);
	return ret;
}



void getproduction()
{
	printf("若一个非终结符可推出多个结果，请直接以 | 分隔，不必分开输入\n");
	printf("输入产生式,以$为结束标志:\n");
	string str;
	while (cin >> str && str[0] != '$')
	{
		vector<node>ret = mysplit(str);
		v.push_back(ret[0]);
	}

}

string myreplace(string str, string s,string t)
{
	while (str.find(s) != -1)
	{
		int pos = str.find(s);
		str.replace(pos, s.size(), t);
	}
	return str;
}

void erasedirect(int posi)
{
	set<string>::iterator it = v[posi].right.begin();

	bool flag = true;
	for (it; it != v[posi].right.end(); it++)
	{
		string str = *it;
		if ((str.find(v[posi].left) == str.rfind(v[posi].left) && str.find(v[posi].left) == 0) || allend(str))
			flag = true;
		else
		{
			flag = false;
			break;
		}

	}
	if (!flag)return;

	vector<string>va, vb;
	for (it = v[posi].right.begin(); it != v[posi].right.end(); it++)
	{
		string str = *it;
		if (str.find(v[posi].left) == -1)
		{
			vb.push_back(str);
		}
		else
		{
			str.erase(0, v[posi].left.size());
			va.push_back(str);
		}
	}
	v[posi].right.clear();
	for (int i = 0; i < vb.size(); i++)
	{
		v[posi].right.insert(vb[i] + v[posi].left+"'");
	}

	set<string>ans;
	for (int i = 0; i < va.size(); i++)
	{
		ans.insert(va[i] + v[posi].left + "'");
	}
	ans.insert("Σ");
	struct node N = { v[posi].left + "'",ans };
	v.push_back(N);
}

void myoperate()
{
	for (int i = 0; i < notend.size(); i++)//FOR i:=1 TO N DO
	{
		for (int j = 0; j < i; j++)//FOR j:=1 TO i-1 DO
		{
			int posi=-1, posj=-1;			
			for (int k = 0; k < v.size(); k++)
			{
				if (v[k].left == notend[i])/*遍历所有产生式，找到第i个非终结符在所有产生式中的位置*/
				{
					posi = k;
					break;
				}
			}
			for (int k = 0; k < v.size(); k++)/*遍历所有产生式，找到第i个非终结符在所有产生式中的位置*/
			{
				if (v[k].left == notend[j])
				{
					posj = k;
					break;
				}
			}
			if (posi == -1 || posj == -1)continue;/*如果找不到，就不执行下面的代码。例如：非终结符S在v中是第3个，非终结符R在v中是第1个，则posi=3,posj=1*/

			set<string>::iterator it = v[posi].right.begin();
			set<string>::iterator it2 ;
			set<string>tempset;
			for (it; it != v[posi].right.end(); it++)
			{
				string tempstr = *it;
				string ss;
				if (tempstr.find(notend[j]) != -1)
				{
					for (it2 = v[posj].right.begin(); it2 !=v[posj].right.end(); it2++)
					{
						ss = tempstr;
						ss = myreplace(ss, notend[j], *it2);
						tempset.insert(ss);
					}
					
				}
			}
			vector<string>temv;
			for (it = v[posi].right.begin(); it != v[posi].right.end(); it++)
			{
				string str = *it;
				if (str.find(notend[j]) != -1)
					temv.push_back(str);
			}
			for (int x = 0; x < temv.size(); x++)
			{
				it = v[posi].right.find(temv[x]);
				if (it != v[posi].right.end())
					v[posi].right.erase(it);
			}
			for (it = tempset.begin(); it != tempset.end(); it++)
				v[posi].right.insert(*it);
			erasedirect(posi);

		}
	}
}










int main()
{

	getproduction();

	getnotend();
	/*notend.push_back("S");
	notend.push_back("Q");
	notend.push_back("R");*/

	myoperate();
	printf("消除一切左递归后的结果为:\n");

	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i].left << "->";
		set<string>::iterator it = v[i].right.begin();
		int cnt = 0;
		for (it; it != v[i].right.end(); it++)
		{
			cout << *it;
			cnt++;
			if (cnt != v[i].right.size())
				cout << '|';
		}
		cout << endl;
	}

	return 0;
}

测试用例是书中原题：
（1）S->Qc|c
(2) Q->Rb|b
(3) R->Sa|a
求它消除左递归的最终文法。

给出输入：

S->Qc|c
Q->Rb|b
R->Sa|a
$

运行结果：
在这里插入图片描述

这个答案和书中给出的不一样，这是因为notend（非终结符）中的排序结果是按字典序从小到大排的，结果是Q，R，S。
下面我们强制给notend输入顺序为S,Q,R，只需注释掉获取非终结符的函数getnotend（），手动给出顺序为S,Q,R即可。
在这里插入图片描述
结果和书中给出的一样！
在这里插入图片描述

书中也给出了R,Q,S的顺序，我们同样进行验证

在这里插入图片描述
答案仍然一样！

Forever18tome
关注
  • 15
    点赞
  • 踩
  • 73
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
消除文法左递归
12-23
编译原理，课程设计，消除文法的左递归。源代码，实验报告
消除文法的左递归和回溯
qq_55168827的博客
04-30 7770
1.自上而下分析 （1）面临的问题 文法左递归问题 回溯问题 （2）构造不带回溯的自上而下分析算法 消除文法的左递归性 消除回溯 （3）识别左递归 消除左递归分为消除直接左递归和间接左递归，间接左递归有的时候还要转化为直接左递归进行运算，我们如何去辨别他们是否为直接左递归或者是间接左递归呢 直接左递归：P->Pα|β(β不以P开头) 间接左递归：例如S→Qc｜c，Q→Rb｜b，R→Sa｜a 2.直接左递归的消除 3.直接左递归例题 根据左递归定义..
＜编译原理＞ 左递归消除算法
weixin_52435933的博客
05-17 111
本文介绍消除文法左递归的算法，并输出新文法产生式。 消除左递归在语法分析阶段是比较重要的一个过程，尤其在自顶向下的分析过程中，编译器会尝试各个推导式，如果存在左递归，那么推导过程将会用永无止境。 比较显式的左递归我们称之为直接左递归，比如说 其中表示非空的表达式，表示不以非终结符A开头的表达式。 那么我们知道对于非终结符A来说，最终只能以到来结束，否则依然会含有非终结符...
编译原理-LL1语法分析器（消除左递归+消除回溯）
Jamence的博客
11-25 2万+
编译原理-LL1语法分析器（消除左递归+消除回溯） 实验要求： 要求一 1、 给出文法如下： G[E]： E-&gt;T|E+T; T-&gt;F|T*F; F-&gt;i|(E); 2、 根据该文法构造相应的LL(1)文法及LL(1)分析表，并为该文法设计预测分析程序，利用C语言或C++语言或Java语言实现； 3、 利用预测分析程序完成下列功能： 1） 手工将测试的表达式写入文本文件，每个表达...
【编译原理】文法左递归的消除
Esperanto.的博客
07-08 1万+
文法左递归消除.
编译原理-消除一切左递归（C++实现）
PURSUE__LIFE的博客
06-11 956
消除间接左递归消除直接左递归去掉无用产生式。
c++消除左递归文法_谈递归时，我们在谈什么？
weixin_39862985的博客
11-29 109
在介绍栈这种数据结构的时候，我们就说过，栈就是一种容器。这种容器的特性是先入栈的数据后出栈，(First In Last Out, FILO)。我们结合二叉树的前序遍历，来看一下，递归程序在执行的时候，它的背后到底发生了什么。先上代码。代码是用C语言描述的，对于C++和Java，栈的规律是相同的。pre_order(Node * p) { visit(p); if (p->left) ...
消除左递归
qq2071114140的博客
10-28 3万+
消除左递归 为什么要消除左递归? 在自顶向下的分析中，如果不消除左递归，就会陷入死循环。例如，在后面要说到的递归向下的分析中，就是一个“从前有座山，山里有个庙…”这样，一直递归下去；使用非递归的时候也是一样，需要计算一个FIRST集合，这个集合本身也是一个递归的计算方式，如果有左递归，同样会无限的递归下去。 消除左递归，就是为了可以进行自顶向下的语法分析 1.消除直接左递归 有如下文法： A→...
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++）
05-11
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++） 【问题描述】 1．设计简单算数表达式语法分析器算法；（用递归下降分析来实现） 2．编写代码并上机调试运行通过。 【输入形式】 简单算数表达式 ...
编译原理实验二——算符优先分析法设计与实现
08-29
编译原理是计算机科学中的核心课程，它涉及将高级编程语言转换为机器可执行代码的过程。算符优先分析法是一种常用的语法分析方法，用于解决编译器的语法分析阶段问题。本实验旨在通过实际操作加深学生对算符优先分析...
南昌大学编译原理的C++实现
01-22
《南昌大学编译原理的C++实现》 在计算机科学领域，编译原理是一门深奥而关键的学科，它探讨了如何将高级编程语言转化为机器可执行的指令。本实验报告聚焦于利用C++这一强大且灵活的编程语言来实现编译器的基本组成...
daw.zip_消除左递归
09-22
总结来说，"daw.zip_消除左递归"这个实验代码主要关注编译原理中的一个重要概念——消除左递归，它对于理解和优化编译器的解析性能具有重要意义。通过学习和分析这段代码，可以深入理解消除左递归的算法以及它在实际...
编译原理实验四-语义分析
01-20
《编译原理实验四——语义分析：Java实现与递归下降法》 在计算机科学领域，编译原理是理解程序设计语言如何转化为机器可执行代码的关键学科。本实验主要探讨的是语义分析这一编译过程的重要阶段，采用Java语言进行...
编译原理(三) 消除文法的左递归
热门推荐
llin-黎辰
11-28 5万+
算法的功能对于任意上下文无关的文法消除左递归问题分析一、产生式直接消除左递归形如P→Pα|βP\rightarrow P \alpha | \beta可以通过直接消除转化为： P→βP′P′→αP′|ϵ \begin{aligned} &P \rightarrow \beta P' \\ &P' \rightarrow \alpha P' | \epsilon \end{aligned} 二、产
怎么消除文法的左递归性
公众号：风景邮递Yuan的博客
05-20 2490
原文法：A → Aα1 | Aα2 | ... | Aαm | β1 | β2 | ... | βn。转换后的文法：A → β1A' | β2A' | ... | βnA'例如：E → E + T | E - T | T。例如：S → Sa | Sb | A。例如：A → Aa | Ab | B。例如：S → Sabc | ε。转换后的文法：S → A S'原文法：A → Aα | β。转换后的文法：A → βA'转换后的文法：S → εS'转换后的文法：E → TE'转换后的文法：A → BA'
编译原理消除左递归c语言,编译原理之消除左递归
weixin_39666550的博客
05-19 3254
1.将以下文法消除左递归，分析符号串 i*i+i 。并分别求FIRST集、FOLLOW集，和SELECT集E -> E+T | TT -> T*F | FF -> (E) | i消除左递归：E -> TE'E' -> +TE' | εT -> FT'T' -> *FT' | εF -> (E) | i分析i * i + i:FIRST集：FIRST(...
编译原理-消除左递归
qq_33605778的博客
05-04 1万+
前言 在进行语法分析的时候，如果采用自上而下的分析方法（从开始符开始，推句子），那么要求文法不是左递归的，进而如果是左递归的，则要求消除左递归 左递归的定义：文法经过一次或多次推导之后，出现如下形式 左递归的分类 直接左递归：P → Pa 简介左递归：P → Aa， A → …… → Pb 直接左递归的消除 对于 P → Pa | b 形式(b可为空)...
C++ 多态
最新发布
wxk2227814847的博客
07-10 496
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
编译原理实验用C++语言实现文法类型的判断
03-25
A：编译原理实验中可以使用 C 语言实现文法类型的判断。具体实现方法如下： 1. 首先，需要确定待判断的文法类型。常见的文法类型包括正则文法、上下文无关文法、上下文有关文法和递归可枚举文法等。 2. 然后，需要设计相应的算法或程序，以判断一定的文法是否符合所选定的文法类型的要求。例如，如果需要判断一个文法是否为上下文无关文法，可以采用 CYK 算法、LL(1) 文法分析器或 LR 文法分析器等方法。 3. 在实现时，可以使用 C 语言提供的相关数据结构和函数，例如使用结构体表示文法符号、使用二维数组表示文法的各种产生式集合、使用递归函数实现 LL(1) 分析器等。 4. 最后，需要进行测试和验证。编写合适的测试用例，验证程序的正确性和性能，并进行必要的调整和改进。 总之，利用 C 语言实现文法类型的判断是编译原理实验中常见的任务之一，需要熟练掌握相应的算法和数据结构，并具备一定的编程能力和实验经验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值