初识编译原理

最新推荐文章于 2023-09-09 23:37:50 发布
最新推荐文章于 2023-09-09 23:37:50 发布
阅读量1.1k 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglianzhu_91/article/details/121877722
版权

皇家药学院的信管专业毕竟不是专门的计算机专业。WEB的课程也是基本等于没有，没有开设编译原理课程。为了巩固基础知识，自学编译原理

第一课：sub虚拟机和sub简单编译器。

为了简单，虚拟机只支持两个命令：
push和add
push要带一个数字参数，效果就是把跟的参数压栈
add不用带参数，效果就是从栈顶取两个元素相加，把结果压入栈顶

这里借助二叉树实现语法分析，把加法代码解析为二叉树，对二叉树采用左后遍历（先遍历左节点，再遍历右节点，再遍历父节点）。对节点值不是加号的生成push "节点值"的命令。对节点值为加号的节点，生成add命令。这样整个数遍历完了就生成sub虚拟机的机器码了。
在这里插入图片描述

sub虚拟机实现

#pragma once
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <vector>
#include <stack>
using namespace std;

/*
此学习示例作为编译原理练习用例，实现简单的sub虚拟机。
该虚拟机只支持两个命令：
push 数字
add
虚拟机结构为栈结构，push的作用为向栈压入一个数据
add的作用从栈取两个顶部元素相加，并且把计算结果压入栈顶

比如:1+2+3的机器代码如下，可以自定义高级语言编译得到机器识别的代码

push 1
push 2
add
push 3
add

由虚拟机加载该编译器输出的命令文件压栈执行，最后得到结果
*/

/// <summary>
/// 从文件读入到string里
/// </summary>
/// <param name="filename">文件名</param>
/// <returns>文件串</returns>
string ReadFileIntoString(char* filename);

/// <summary>
/// 分割字符串
/// </summary>
/// <param name="str">字符串</param>
/// <param name="delim">分割串</param>
/// <returns>字符串向量</returns>
vector<string> SplitString(const string& str, const string& delim);

/// <summary>
/// 浮点类型转换字符串
/// </summary>
/// <param name="d"></param>
/// <returns></returns>
string DoubleToString(double d);

/// <summary>
/// 字符串转浮点数
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
double StringToDouble(string str);

/// <summary>
/// 入口函数
/// </summary>
/// <returns></returns>
int main(int argc, char* argv[])
{
	//有参数就按参数传
	if (argc > 1)
	{
		for (int i = 1; i < argc; i++)
		{
			//加载机器代码
			string code = ReadFileIntoString(argv[i]);
			//分割得到每行代码
			vector<string> vecStr = SplitString(code, "\n");
			//虚拟机执行栈
			stack<string> machineStack;
			//顺序执行代码
			for (int i = 0; i < vecStr.size(); i++)
			{
				string oneLine = vecStr[i];
				//分割一条命令
				vector<string> vecCode = SplitString(oneLine, " ");
				//是push命令
				if (vecCode[0] == "push")
				{
					machineStack.push(vecCode[1]);
				}
				//执行add命令
				else if (vecCode[0] == "add")
				{
					string oneVal = machineStack.top();
					machineStack.pop();
					string towVal = machineStack.top();
					machineStack.pop();
					double res = StringToDouble(oneVal)+ StringToDouble(towVal);
					machineStack.push(DoubleToString(res));
				}
			}
			//命令执行完成后取出栈顶元素输出
			if (machineStack.size() > 0)
			{
				string res = machineStack.top();
				cout << "执行结果:" << res<<endl;
			}
		}
	}
	else
	{
		cout << "未传入要执行的文件名!" << endl;
	}
	return 0;
}

/// <summary>
/// 浮点类型转换字符串
/// </summary>
/// <param name="d"></param>
/// <returns></returns>
string DoubleToString(double d) {
	ostringstream os;
	if (os << d) return os.str();
	return "invalid conversion";
}

/// <summary>
/// 字符串转浮点数
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
double StringToDouble(string str) {
	istringstream iss(str);

	double  x;
	if (iss >> x) return x;
	return 0.0;
}

/// <summary>
/// 从文件读入到string里
/// </summary>
/// <param name="filename">文件名</param>
/// <returns>文件串</returns>
string ReadFileIntoString(char* filename)
{
	ifstream ifile(filename);
	//将文件读入到ostringstream对象buf中
	ostringstream buf;
	char ch;
	while (buf && ifile.get(ch))
	{
		buf.put(ch);
	}
	//返回与流对象buf关联的字符串
	return buf.str();
}

/// <summary>
/// 分割字符串
/// </summary>
/// <param name="str">字符串</param>
/// <param name="delim">分割串</param>
/// <returns>字符串向量</returns>
vector<string> SplitString(const string& str, const string& delim) {
	vector<string> res;
	if ("" == str) return res;
	//先将要切割的字符串从string类型转换为char*类型  
	//不要忘了  
	char* strs = new char[str.length() + 1];
	strcpy(strs, str.c_str());
	char* d = new char[delim.length() + 1];
	strcpy(d, delim.c_str());
	char* p = strtok(strs, d);
	while (p) {
		string s = p; //分割得到的字符串转换为string类型  
		res.push_back(s); //存入结果数组  
		p = strtok(NULL, d);
	}
	return res;
}

sub编译器实现
头文件

#pragma once
#include <iostream>
#include <string>
using namespace std;
//二叉树数据类型
typedef string TreeElemType;
/// <summary>
/// 定义二叉树结构
/// </summary>
typedef struct BitTreeNode {

	/// <summary>
	/// 存数据的节点
	/// </summary>
	TreeElemType data;

	/// <summary>
	/// 左边节点
	/// </summary>
	struct BitTreeNode* leftChild;

	/// <summary>
	/// 右边节点
	/// </summary>
	struct BitTreeNode* rightChild;
};

实现文件

#include "CompileStudy.h"
#include <fstream>
#include <sstream>
#include <vector>
#include <stack>

/*
此学习示例作为编译原理练习用例，实现简单的sub编译器。面向一个只支持sub的虚拟机。
该虚拟机只支持两个命令：
push 数字
add
虚拟机结构为栈结构，push的作用为向栈压入一个数据
add的作用从栈取两个顶部元素相加，并且把计算结果压入栈顶

比如:1+2+3就是符合该编译器定义的语法

编译结果为:
push 1
push 2
add
push 3
add

由虚拟机加载该编译器输出的命令文件压栈执行，最后得到结果
*/

/// <summary>
/// 从文件读入到string里
/// </summary>
/// <param name="filename">文件名</param>
/// <returns>文件串</returns>
string ReadFileIntoString(char* filename);

/// <summary>
/// 输出向量字符串到文件
/// </summary>
/// <param name="filename">文件名</param>
/// <returns>文件串</returns>
void WriteStrToFile(string filename, vector<string>* codeList);

/// <summary>
/// 分割字符串
/// </summary>
/// <param name="str">字符串</param>
/// <param name="delim">分割串</param>
/// <returns>字符串向量</returns>
vector<string> SplitString(const string& str, const string& delim);

/// <summary>
/// 遍历二叉树生成栈代码
/// </summary>
/// <param name="node">总节点</param>
/// <returns>栈执行代码</returns>
void TraverseMakeCode(const BitTreeNode* node, vector<string>* codeList);

/// <summary>
/// 替换字符串
/// </summary>
/// <param name="str">源串</param>
/// <param name="old_value">老串</param>
/// <param name="new_value">新串</param>
/// <returns></returns>
string& ReplaceAllStr(string& str, const  string& old_value, const  string& new_value);


/// <summary>
/// 入口函数
/// </summary>
/// <returns></returns>
int main(int argc, char* argv[])
{
	//有参数就按参数传
	if (argc > 1)
	{
		for (int i = 1; i < argc; i++)
		{
			string code = ReadFileIntoString(argv[i]);
			cout << "读取:" << argv[i] << "代码为:" + code << endl;
			vector<string> vecStr = SplitString(code,"+");
			//1+2+3生成一颗二叉树
			if (vecStr.size() > 0)
			{
				BitTreeNode* mianNode= new BitTreeNode;
				mianNode->data = "+";
				mianNode->leftChild = NULL;
				mianNode->rightChild = NULL;
				for (int i = 0; i < vecStr.size(); i++)
				{
					//树的总节点
					BitTreeNode* oneNode = new BitTreeNode;
					oneNode->data = vecStr[i];
					oneNode->leftChild = NULL;
					oneNode->rightChild = NULL;
					if (mianNode->leftChild == NULL)
					{
						mianNode->leftChild = oneNode;
					}
					else if (mianNode->rightChild == NULL)
					{
						mianNode->rightChild = oneNode;
					}
					else
					{
						BitTreeNode* mianNodeNew = new BitTreeNode;
						mianNodeNew->data = "+";
						mianNodeNew->leftChild = mianNode;
						mianNodeNew->rightChild = oneNode;
						mianNode = mianNodeNew;
					}
				}
				//按二叉树生成代码
				cout << "构造语法二叉树完成"<< endl;
				vector<string> codeList;
				//按二叉树生成栈执行代码
				TraverseMakeCode(mianNode, &codeList);
				string outName = argv[i];
				//输出名字
				outName = ReplaceAllStr(outName,".code",".sub");
				//输出文件
				WriteStrToFile(outName, &codeList);
			}
		}
	}
	else
	{
		cout << "未传入要编译的文件名!" << endl;
	}
	return 0;
}

/// <summary>
/// 替换字符串
/// </summary>
/// <param name="str">源串</param>
/// <param name="old_value">老串</param>
/// <param name="new_value">新串</param>
/// <returns></returns>
string& ReplaceAllStr(string& str, const  string& old_value, const  string& new_value)
{
	while (true) {
		string::size_type   pos(0);
		if ((pos = str.find(old_value)) != string::npos)
			str.replace(pos, old_value.length(), new_value);
		else   break;
	}
	return str;
}

/// <summary>
/// 遍历二叉树生成栈代码
/// </summary>
/// <param name="node">总节点</param>
/// <returns>栈执行代码</returns>
void TraverseMakeCode(const BitTreeNode * node, vector<string>* codeList)
{
	if (node != NULL)
	{
		if (node->leftChild == NULL&& node->rightChild == NULL)
		{
			codeList->push_back("push " + node->data);
		}
		if (node->leftChild != NULL)
		{
			TraverseMakeCode(node->leftChild, codeList);
		}
		if (node->rightChild != NULL)
		{
			TraverseMakeCode(node->rightChild, codeList);
		}
		if (node->data =="+")
		{
			codeList->push_back("add");
		}
		
	}
}

/// <summary>
/// 从文件读入到string里
/// </summary>
/// <param name="filename">文件名</param>
/// <returns>文件串</returns>
string ReadFileIntoString(char* filename)
{
	ifstream ifile(filename);
	//将文件读入到ostringstream对象buf中
	ostringstream buf;
	char ch;
	while (buf && ifile.get(ch))
	{
		buf.put(ch);
	}
	//返回与流对象buf关联的字符串
	return buf.str();
}

/// <summary>
/// 输出向量字符串到文件
/// </summary>
/// <param name="filename">文件名</param>
/// <returns>文件串</returns>
void WriteStrToFile(string filename, vector<string>* codeList)
{
	ofstream outfile(filename.c_str(), ios::trunc);
	cout << "生成add栈代码" << endl;
	for (int j = 0; j < (*codeList).size(); j++)
	{
		cout << (*codeList)[j] << endl;
		outfile << (*codeList)[j] << endl;
	}
	outfile.close();
	cout << "代码生成在:"+ filename<< endl;
}

/// <summary>
/// 分割字符串
/// </summary>
/// <param name="str">字符串</param>
/// <param name="delim">分割串</param>
/// <returns>字符串向量</returns>
vector<string> SplitString(const string& str, const string& delim) {
	vector<string> res;
	if ("" == str) return res;
	//先将要切割的字符串从string类型转换为char*类型  
	//不要忘了  
	char* strs = new char[str.length() + 1]; 
	strcpy(strs, str.c_str());
	char* d = new char[delim.length() + 1];
	strcpy(d, delim.c_str());
	char* p = strtok(strs, d);
	while (p) {
		string s = p; //分割得到的字符串转换为string类型  
		res.push_back(s); //存入结果数组  
		p = strtok(NULL, d);
	}
	return res;
}

源码和编译结果
源码

1+2+3

编译结果

push 1
push 2
add
push 3
add

执行测试
在这里插入图片描述

源码

1+2+3+23+64+100+76

编译结果

push 1
push 2
add
push 3
add
push 23
add
push 64
add
push 100
add

在这里插入图片描述

执行测试
在这里插入图片描述

这次的例子复习了C++二叉树和二叉树的遍历。理解基础栈式虚拟机原理，理解基本的代码编译。如果真的有个芯片支持push和add，那么这就是一个简单的求和语言编译器。避免直接写push和add命令，也就是语言抽象的“高级语言”

小乌鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Sublime Text 全程图文指引、Notepad++ 简单使用
freeking101的博客
11-21 1万+
Sublime Text 全程图文指引、Notepad++ 简单使用
汇编指令机器码对应列表
weixin_43708844的博客
12-09 8113
指令集依照机器操作码、汇编助记符和汇编操作数来描述指令，遵循下列约定： l reg8: 8位寄存器。 l reg16: 16位寄存器。 l mem8: 8位内存数值。 l mem16: 16位内存数值。 l immed8: 8位立即数值。 l immed16: 16位立即数值。 l immed32: 32位立即数值。 l segReg...
编译原理：编译原理简明教程知识点梳理（应对考试版）
最新发布
weixin_53472920的博客
09-09 2963
翻译程序：把某种程序设计语言（源语言）编写的程序（源程序）翻译成与之等价的另一种语言（目标语言）的程序（目标程序）。编译程序：编译程序是一种翻译程序，将高级语言编写的源程序翻译成等价的机器语言或汇编语言的目标程序。解释程序：翻译一句执行一句，不生成目标文件，直接执行源代码文件。
编译原理（核心速成）
Edward2022的博客
03-21 8947
编译原理(混子速成）： 1.DFA、NFA 2.LL文法、LR文法：FIRST、FOLLOW
Sublime编辑器 使用笔记
走向CTO的路上...
09-19 533
[Decode error - output not utf-8]  在使用Sublime时，刚开始使用C 编写一个Hello.c 代码 ，并未出现 这个错误 能够正常的输出hello word，如下所示： 但是 将其写成C++ ，就会出这个问题，查了一些资料，得出一个解决方案. 我用的是 Sub 3，所以改的地方是 将其 复制出来，并
JNA初识
04-20
标题 "JNA初识" 涉及到的是Java Native Access (JNA) 技术，这是一种在Java中调用本地（系统）库的机制，无需编写C代码或使用Java的Java Native Interface (JNI)。JNA允许Java程序直接与操作系统功能进行交互，如...
从初识C语言到C语言进阶源码.zip
10-18
这些代码示例是实践和理解C语言的关键，通过动手编写和调试代码，学习者能更深入地理解C语言的工作原理。 3. **进阶话题**：随着学习的深入，可能会涉及到指针、结构体、联合体、位运算、预处理器等进阶主题。这些...
STM32如何编译和下载程序\如何新建工程模板\初识STM32库
05-05
STM32是一款基于ARM Cortex...在实际操作过程中，务必注意查阅STM32的数据手册和参考手册，了解每个外设的工作原理和寄存器配置。同时，多做实验，理解每个步骤的实际效果，这样能更好地巩固理论知识，并提升动手能力。
Android 初识 Helloworld 详解
09-05
在Android开发中，初学者通常从创建一个简单的“HelloWorld”项目开始，了解其基本结构和工作原理。本文主要解析Eclipse+ADT环境中创建的HelloWorld项目的各个部分，帮助开发者深入理解Android应用的构建。 首先，...
1.初识Java.zip
05-31
【初识Java】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（后被Oracle公司收购）于1995年发布。它的设计目标是具备“简单性、面向对象、健壮性、安全性、可移植性、高效性、多线程和动态性”等...
编译原理----概述
Chas的博客
12-07 538
编译原理 资源整理一
编译原理
weixin_30276935的博客
09-09 158
编译原理是什么：编译原理是计算机专业的一门重要专业课，旨在介绍编译程序构造的一般原理和基本方法。内容包括语言和文法、词法分析、语法分析、语法制导翻译、中间代码生成、存储管理、代码优化和目标代码生成。编译原理是计算机专业设置的一门重要的专业课程。虽然只有少数人从事编译方面的工作，但是这门课在理论、技术、方法上都对学生提供了系统而有效的训练，有利于提高软件人员的素质和能力。 好处：可以用语法分析来分...
编译原理总结
Keep Fighting!
10-10 671
编译原理总结 编译原理总结 文章目录编译原理总结前言一、编译的过程二、前端1.词法分析2.语法分析2.1 LL分析2.2 LR分析3.语义分析4. 中间代码5. 后端5.1 指令选择5.2 活跃性分析5.3 寄存器分配5.4 数据流分析5.5 静态单赋值总结 前言 总结编译原理的重点。 一、编译的过程 编译分为前端和后端。 前端包括词法分析，语法分析，语义分析，中间代码生成。 后端主要负责对中间代码进行优化，生成目标平台代码，对目标平台代码进行优化等。 前端与目标平台基本无关，因此有通用的工具：词法
编译原理详细总结
weixin_44478207的博客
09-08 6364
编译原理 编译概述   把高级程序语言翻译成汇编语言或机器语言的工作称为编译，完成这项翻译工作的软件系统称为编译程序或编译器。下图展示高级语言从编译到执行的大致过程（本文中图片来源均为张莉等编著的《编译技术》）。   对于纯编译型语言（如c），程序在执行之前必须要有编译过程。对于解释型的语言，可以对源代码或中间代码按行解释执行。 文法和语言的概念和表示 词法分析 语法分析 符号表管理 运行时的存储组织及管理 源程序的中间形式 语义分析和代码生成 ...
编译原理简介
qq_40203390的博客
07-05 2032
编译原理 一、什么是编译程序？ 从功能上讲，一个编译程序就是一个语言翻译程序，语言翻译程序把一种语言（称为源语言）书写的程序翻译成另一种语言（称为目标语言）的等价程序。 编译程序的目的就是讲源语言程序翻译成等价的目标语言程序。 常见语言翻译程序的有： 汇编程序：将汇编语言程序翻译成机器语言程序； 编译程序：源语言是FORTRAN、Pascal或者C那样的高级语言程序，目标语言是像汇编语言或...
编译原理笔记（一）引论
hanmo22357的博客
05-05 3089
编译程序的地位编译程序是现代计算机系统的基本组成部分之一；多数计算机都配有不止一种高级语言编译程序，对有些高级语言甚至配置了几个不同性能的编译程序。编译程序的功能：从功能上看，一个编译程序就是一个语言翻译程序，把一种语言（源语言）书写的程序翻译成另一种语言（目标语言）的等价程序。但是其中的源语言是高级语言，目标语言是低级语言。编译程序的重要性：编译程序使得多数计算机用户不必考虑与机器有关的繁琐细节，使得程序员独立于机器。程序设计语言处理程序的典型流程：编译程序是程序设计语言处理程序的一部分。
编译原理（整体理解）
qq_44386498的博客
12-12 4773
编译原理整体理解，编译原理实际上要我们了解传统编译器的工作原理。它可以分为六个部分：词法分析、语法分析、语义分析、中间代码生成、代码优化、目标代码生成。 整个过程其实就像你把一篇英语文章翻译成中文一样，首先要明白的词法分析是一个程序，一个程序要有输入和输出，输入的是字符流，不能称之为单词，就像英语中的几个字母组成字符串，我们怎么能称之为单词，赋予这个字符串权威意义的只有字典，字典规定了它的属性与意义。那么词法分析中也应该有替代字典这一功能的，于是就有词法规则描述工具(状态转换图、巴克斯范式BNF、有穷自动机
Linux内核构建系统1
08-04
作者强调，虽然开发驱动程序并不一定需要深入理解整个内核构建系统，但在遇到问题时，直接理解其工作原理往往能更高效地解决问题。 1. **前言** 文章开篇指出，对于Linux内核驱动开发者，有时仅依赖编写符合需求的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小乌鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值