c语言 if自动机 while自动机 bool自动机 算术自动机

最新推荐文章于 2021-02-10 22:50:55 发布
最新推荐文章于 2021-02-10 22:50:55 发布
阅读量197 收藏 1
点赞数
分类专栏： 采用自底向上归约编译器 文章标签： 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cappuccino_614/article/details/108293717
版权

自动机变元

自动机结构

草稿结构图：
            | if自动机
while自动机 | bool自动机

我自己倒是看得懂..

在这里插入图片描述
bool自动机归约成B，可以被if，while等自动机调用；
if和while自动机归约成S，被主自动机调用；
主自动机负责代码块；

算术自动机：
算术自动机
只能被bool自动机调用，最终归约成E（不是S）

代码部分

bool自动机代码

int boolautomat(enum Symbols * pst, enum Symbols * tpst, struct _token *sst)
{
	int * ppst = NULL;//栈指针，用来遍历栈，返回操作码
	ppst = tpst;
	int state = 1;//状态
	int isok = 0;//结束?
	int opr = 0;
	while (isok == 0)
	{
		switch (state)
		{
		case 1://开始态
			switch (*ppst)
			{
			case NEGA:
				state = 2;
				break;
			case NTS_E:
				state = 4;
				break;
			case NTS_B:
				state = 15;
				break;
			case L_PARENS:
				state = 20;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = -1;
			}
			break;
		case 2://B->!B
			switch (*ppst)
			{
			case NTS_B:
				state = 3;
				break;
			default:
				state = 1;
			}
			break;
		case 4://B->E||E rop E
			switch (*ppst)
			{
			case LT:
				state = 5;
				break;
			case GT:
				state = 6;
				break;
			case LE:
				state = 7;
				break;
			case GE:
				state = 8;
				break;
			case EQUL:
				state = 9;
				break;
			default:
				state = -1;
			}
			break;
		case 5://B->E<.E
			switch (*ppst)
			{
			case NTS_E:
				state = 10;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = -1;
			}
			break;
		case 6://B->E>.E
			switch (*ppst)
			{
			case NTS_E:
				state = 11;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = -1;
			}
			break;
		case 7://B->E<=.E
			switch (*ppst)
			{
			case NTS_E:
				state = 12;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = -1;
			}
			break;
		case 8://B->E>=.E
			switch (*ppst)
			{
			case NTS_E:
				state = 13;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = -1;
			}
			break;
		case 9://B->E==.E
			switch (*ppst)
			{
			case NTS_E:
				state = 14;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = -1;
			}
			break;
		case 15://B->B.||B |B.&&B |B.
			switch (*ppst)
			{
			case OR:
				state = 16;
				break;
			case AND:
				state = 18;
				break;
			default:
				state = -1;
			}
			break;
		case 16://B->B||.B
			switch (*ppst)
			{
			case NTS_B:
				state = 17;
				break;
			case NEGA:
				state = 2;
				break;
			case NTS_E:
				state = 4;
				break;
			case L_PARENS:
				state = 20;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = 1;
			}
			break;
		case 18://B->B&&.B
			switch (*ppst)
			{
			case NTS_B:
				state = 19;
				break;
			case NEGA:
				state = 2;
				break;
			case NTS_E:
				state = 4;
				break;
			case L_PARENS:
				state = 20;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = 1;
			}
			break;
		case 20://B->(.B)
			switch (*ppst)
			{
			case NTS_B:
				state = 21;
				break;
			case NEGA:
				state = 2;
				break;
			case NTS_E:
				state = 4;
				break;
			case L_PARENS:
				state = 20;
				break;
			case INT:
				state = 23;
				break;
			case ID:
				state = 23;
				break;
			default:
				state = 1;
			}
			break;
		case 21://B->(B.)
			switch (*ppst)
			{
			case R_PARENS:
				state = 22;
				break;
			default:
				state = -1;
			}
			break;
		}
		ppst++;
		if (ppst == (pst + pstack))//指针在栈顶
		{
			int z = 0;
			switch (state)
			{
			case -1:
				opr = -1;
				break;
			case 3:
				opr= 2;
				break;
			case 4://预读 rop
				switch (tokentable[ptid].value)//预读
				{
				case LE:
					opr = 0;
					break;
				case LT:
					opr = 0;
					break;
				case GE:
					opr = 0;
					break;
				case GT:
					opr = 0;
					break;
				case EQUL:
					opr = 0;
					break;
				case L_PARENS:
					opr = -1;
					break;
				default:
					opr = 3;
					break;
				}
				break;
			case 10://B->E<E
				opr = 4;
				break;
			case 11://B->E>E
				opr = 5;
				break;
			case 12://B->E<=E
				opr = 6;
				break;
			case 13://B->E>=E
				opr = 7;
				break;
			case 14://B->E==E
				opr = 8;
				break;

			case 15://预读 || && 
				switch (tokentable[ptid].value)//预读
				{
				case AND:
					opr = 0;
					break;
				case OR:
					opr = 0;
					break;
				case L_PARENS:
					opr = -1;
					break;
				default://结束状态
					return 1;
					break;
				}
				break;
			case 17://B->B||B
				opr = 9;
				break;
			case 19://B->B && B
				opr = 10;
				break;
			case 22://B->(B)
				opr = 11;
				break;
			case 23://调用算术自动机
				z = 0;
				z = arithautomat(pst,(ppst - 1), sst);
				if (z == 0)
				{
					return 0;
				}
				opr = 99;
				break;
			default:
				opr = 0;//其他情况均请求归约器入栈
			}
			int ok = boolredu(pst, sst, opr);
			if (ok == -1)
			{
				return 0;
			}
			state = 1;
			ppst = tpst;//栈指针归位
			outs(pst);
		}
	}
}

while自动机代码

int whileautomat(enum Symbols * pst, enum Symbols * tpst, struct _token *sst)
{
	int * ppst = NULL;//栈指针，用来遍历栈，返回操作码
	ppst = tpst;
	int state = 1;//状态
	int isok = 0;//结束?
	int opr = 0;
	while (isok == 0)
	{
		switch (state)
		{
		case 1://开始态
			switch (*ppst)
			{
			case WHILE:
				state = 2;
				break;
			case NTS_W:
				state = 3;
				break;
			case NTS_WD:
				state = 6;
				break;
			case NTS_S:
				return 1;
			default:
				state = -1;
			}
			break;
		case 3://WD->W.B do
			switch (*ppst)
			{
			case NTS_B:
				state = 4;
				break;
			default:
				state = 8;
			}
			break;
		case 4://WD->W B. do
			switch (*ppst)
			{
			case DO:
				state = 5;
				break;
			default:
				state = -1;
			}
			break;
		case 6://S->WD.S
			switch (*ppst)
			{
			case NTS_S:
				state = 7;
				break;
			default:
				state = 9;
			}
			break;
		}
		ppst++;
		if (ppst == (pst + pstack))//指针在栈顶
		{
			int z = 0;
			switch (state)
			{
			case -1:
				opr = -1;
				break;
			case 2:
				opr = 2;
				break;
			case 5://WD->W B do
				opr = 3;
				break;
			case 7://S->WD S
				opr = 4;
				break;
			case 8://调用bool自动机
				z = 0;
				z = boolautomat(pst, (ppst - 1), sst);
				if (z == 0)
				{
					return 0;
				}
				opr = 99;
				break;
			case 9://调用主自动机
				z = 0;
				z = mainautomat(pst, (ppst - 1), sst);
				if (z == 0)
				{
					return 0;
				}
				opr = 99;
				break;

			default:
				opr = 0;//其他情况均请求归约器入栈
			}
			int ok = whileredu(pst, sst, opr);
			if (ok == -1)
			{
				return 0;
			}
			state = 1;
			ppst = tpst;//栈指针归位
			outs(pst);
		}
	}
}

if自动机代码

int ifautomat(enum Symbols * pst, enum Symbols * tpst, struct _token *sst)
{
	int * ppst = NULL;//栈指针，用来遍历栈，返回操作码
	ppst = tpst;
	int state = 1;//状态
	int isok = 0;//结束?
	int opr = 0;
	while (isok == 0)
	{
		switch (state)
		{
		case 1://开始态
			switch (*ppst)
			{
			case IF:
				state = 2;
				break;
			case NTS_CA:
				state = 5;
				break;
			case NTS_FA:
				state = 17;
				break;
			case NTS_S:
				return 1;
			default:
				state = -1;
			}
			break;
		case 2://CA->if. B them
			switch (*ppst)
			{
			case NTS_B:
				state = 3;
				break;
			default:
				state = 18;
			}
			break;
		case 3://CA->if B. them
			switch (*ppst)
			{
			case THEN:
				state = 4;
				break;
			default:
				state = -1;
			}
			break;
		case 5://FA->CA.S
			switch (*ppst)
			{
			case NTS_S:
				state = 6;
				break;
			case BEGIN:
				state = 19;
				break;
			default:
				state = -1;
			}
			break;
		case 7://CBE->else. if
			switch (*ppst)
			{
			case IF:
				state = 9;
				break;
			default:
				state = -1;
			}
			break;
		case 10://CB->CBE. B then
			switch (*ppst)
			{
			case NTS_B:
				state = 11;
				break;
			default:
				state = 18;
			}
			break;
		case 11://CB->CBE B. then
			switch (*ppst)
			{
			case THEN:
				state = 12;
				break;
			default:
				state = -1;
			}
			break;
		case 13://FB->CB. S
			switch (*ppst)
			{
			case NTS_S:
				state = 14;
				break;
			case BEGIN:
				state = 19;
			default:
				state = 19;
			}
			break;
		case 15://FC->CE.S
			switch (*ppst)
			{
			case NTS_S:
				state = 16;
				break;
			case BEGIN:
				state = 19;
				break;
			default:
				state = 19;
			}
			break;
		case 17://S->FA.***
			switch (*ppst)
			{
			case ELSE:
				state = 7;
				break;
			case NTS_CBE:
				state = 10;
				break;
			case NTS_CB:
				state = 13;
				break;
			case NTS_CE:
				state = 15;
				break;
			case NTS_FB:
				state = 20;
				break;
			case NTS_FC:
				state = 22;
				break;
			default:
				state = -1;
			}
			break;
		case 20://S->FA FB...FB FC
			switch (*ppst)
			{
			case NTS_FB:
				state = 20;
				break;
			case NTS_FC:
				state = 21;
				break;
			default:
				state = 17;
				ppst--;
			}
			break;
		}
		ppst++;
		if (ppst == (pst + pstack))//指针在栈顶
		{
			int z = 0;
			switch (state)
			{
			case -1:
				opr = -1;
				break;
			case 4://CA->if B then
				opr = 2;
				break;
			case 6://FA->CA S
				opr = 3;
				break;
			case 7://预读 IF
				switch (tokentable[ptid].value)//预读
				{
				case IF:
					opr = 0;
					break;
				default:
					opr = 4;//CE->else
					break;
				}
				break;
			case 9://CBE->else if
				opr = 5;
				break;
			case 12://CB->CBE B then
				opr = 6;
				break;
			case 14://FB->CB S
				opr = 7;
				break;
			case 16://FC->CE S
				opr = 8;
				break;
			case 17://预读 
				switch (tokentable[ptid].value)//预读
				{
				case ELSE:
					opr = 0;
					break;
				case NTS_CBE:
					opr = 0;
					break;
				case NTS_CB:
					opr = 0;
					break;
				case NTS_CE:
					opr = 0;
					break;
				case NTS_FB:
					opr = 0;
					break;
				default:
					opr = 10;//S->FA
					break;
				}
				break;
			case 18://调布尔自动机
				z = 0;
				z = boolautomat(pst, (ppst - 1), sst);
				if (z == 0)
				{
					return 0;
				}
				opr = 99;
				break;
			case 19://调主自动机
				z = 0;
				z = mainautomat(pst, (ppst - 1), sst);
				if (z == 0)
				{
					return 0;
				}
				opr = 99;
				break;
			case 20://预读 
				switch (tokentable[ptid].value)//预读
				{
				case ELSE:
					opr = 0;
					break;
				case NTS_FB:
					opr = 0;
					break;
				case NTS_FC:
					opr = 0;
					break;
				default:
					opr = 12;//S->FAFB...FB
					break;
				}
				break;
			case 21://S->FA FB...FB FC 
				opr = 9;
				break;
			case 22:
				opr = 11;
				break;
			default:
				opr = 0;//其他情况均请求归约器入栈
			}
			int ok = ifredu(pst, sst, opr);
			if (ok == -1)
			{
				return 0;
			}
			state = 1;
			ppst = tpst;//栈指针归位
			outs(pst);
		}
	}
}

算术自动机代码

int arithautomat(enum Symbols * pst, enum Symbols * tpst, struct _token *sst)//(语法栈,语法栈当前位置，语义栈,)
{
	int * ppst = NULL;//栈指针，用来遍历栈，返回操作码
	ppst = tpst;
	int state = 1;//状态
	int isok = 0;//结束?
	int opr = 0;
	while (isok == 0)
	{
		//不在栈顶
		switch (state)
		{
		case 1://开始态
			switch (*ppst)
			{
			case NTS_T:
				state = 2;
				break;
			case INT:
				state = 3;
				break;
			case ID:
				state = 3;
				break;
			case L_PARENS:
				state = 4;
				break;
			case NTS_E:
				state = 15;
				break;
			default:
				state = -1;
			}
			break;
		case 2://E->T|T.+E|T.-E
			switch (*ppst)
			{
			case PLUS:
				state = 5;
				break;
			case SUB:
				state = 6;
				break;
			default:
				state = -1;
			}
			break;
		case 3://T->INT.*T|INT./T|INT
			switch (*ppst)
			{
			case MULT:
				state = 7;
				break;
			case DIV:
				state = 8;
				break;
			default:
				state = -1;
			}
			break;
		case 4://T->(.E)|E->|T->|
			switch (*ppst)
			{
			case INT:
				state = 3;
				break;
			case ID:
				state = 3;
				break;
			case NTS_T:
				state = 2;
				break;
			case NTS_E:
				state = 13;
				break;
			default:
				state = -1;
			}
			break;
		case 5://T->INT|INT*T|INT/T|(E)|E->T-.E|T+.E|T
			switch (*ppst)
			{
			case NTS_E:
				state = 9;
				break;
			case NTS_T:
				state = 2;
				break;
			case INT:
				state = 3;
				break;
			case ID:
				state = 3;
				break;
			case L_PARENS:
				state = 4;
				break;
			default:
				state = -1;
			}
			break;
		case 6://同5，-推导出6状态
			switch (*ppst)
			{
			case NTS_E:
				state = 10;
				break;
			case NTS_T:
				state = 2;
				break;
			case INT:
				state = 3;
				break;
			case ID:
				state = 3;
				break;
			case L_PARENS:
				state = 4;
				break;
			default:
				state = -1;
			}
			break;
		case 7://T->INT*.T|INT/.T|INT|.INT*T|.INT/T
			switch (*ppst)
			{
			case INT:
				state = 3;
				break;
			case ID:
				state = 3;
				break;
			case NTS_T:
				state = 11;
				break;
			case L_PARENS:
				state = 4;
				break;
			default:
				state = -1;
			}
			break;
		case 8://同7，/推导出8状态
			switch (*ppst)
			{
			case INT:
				state = 3;
				break;
			case ID:
				state = 3;
				break;
			case NTS_T:
				state = 12;
				break;
			case L_PARENS:
				state = 4;
				break;
			default:
				state = -1;
			}
			break;
		case 13://E->(E.)
			switch (*ppst)
			{
			case R_PARENS:
				state = 14;
				break;
			default:
				state = -1;
			}
			break;
		}
		ppst++;
		if (ppst == (pst + pstack))//指针在栈顶
		{
			switch (state)
			{
			case -1:
				opr=-1;
				break;
			case 2://预读+.-
				switch (tokentable[ptid].value)//预读
				{
				case PLUS:
					opr = 0;
					break;
				case SUB:
					opr = 0;
					break;
				case L_PARENS:
					opr = -1;
					break;
				default:
					opr = 2;
					break;
				}
				break;
			case 3://预读*./
				switch (tokentable[ptid].value)//预读
				{
				case MULT:
					opr = 0;
					break;
				case DIV:
					opr = 0;
					break;
				case L_PARENS:
					opr = -1;
					break;
				default:
					opr = 8;
					break;
				}
				break;
			case 9://T+E.
				opr = 3;
				break;
			case 10://T-E.
				opr = 4;
				break;
			case 11://INT*T.
				opr = 6;
				break;
			case 12://INT/T.
				opr = 7;
				break;
			case 14://T->(E).
				opr = 5;
				break;
			case 15://E.归约完成
				return 1;
			default:
				opr = 0;//其他情况均请求归约器入栈
			}
			int ok=arithredu(pst, sst, opr);
			if (ok == -1)
			{
				return 0;//错误，返回0
			}
			state = 1;
			ppst = tpst;//栈指针归位
			outs(pst);
		}
	}
}

归约部分则是弹栈压栈，然后结合语义填四元式，之后放上来

英国简欧风
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言基础---BOOL 类型,运算符,if 语句,switch语句
lifang30的博客
07-13 1857
一 BOOL布尔类型 1.BOOL 数据类型,是一种表示非真即假的数据类型,布尔类型的变量只有 YES 和 NO 两个值.YES 表示表达式为真, NO 表示表达式为假. 2.在 C语言中,认为非0即为真. 3.分支语句和循环语句中,经常使用 BOOL 值做判断,判断是否要执行循环. 二 关系运算符(>,>=, 1.用于比较运算,比较结果有两种方式YES 和 NO 2.判断两个数是否相
c语言平 ac自动机,多模式串匹配之AC自动机算法（Aho-Corasick算法）简介与C语言程序实现源码参考...
weixin_39867708的博客
05-17 509
一、概述AC自动机算法全称Aho-Corasick算法，是一种字符串多模式匹配算法。该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。AC算法用于在一段文本中查找多个模式字符串，即给你很多字符串，再给你一段文本，让你在文本中找这些串是否出现过，出现过多少次，分别在哪里出现。该算法应用有限自动机巧妙地将字符比较转化为了状态转移。此算法有两个特点，一个是扫描文本时完全不需要回溯，另一个是时...
c语言识别浮点数的有穷自动机
06-09
根据给定的信息，本文将详细解释“C语言识别浮点数的有穷自动机”的实现原理及代码逻辑。 ### 一、有穷自动机（Finite Automaton）简介 有穷自动机是一种理论计算机模型，用于识别特定类型的字符串或语言。在形式...
c语言代码实现自动机程序的设计
05-17
在C语言中，可以使用结构体来实现自动机程序的设计。 下面是一个简单的自动机程序示例，该程序可以识别输入的字符序列是否符合"ab*c"的规则： ``` #include #include // 定义状态枚举 enum State { START, A,...
python实现AC自动机
uhauha2929的专栏
02-10 1226
ac自动机可以看成带指针的字典树，每个节点的指针指向了当前节点的最大后缀的位置。在建立字典树后，可以层次遍历字典树来构建fail指针，根节点的直接孩子（第一层节点）的fail指针肯定是指向根节点的，之后的节点需要看其父节点的fail指针指向的节点，如果父节点的fail指针指向的节点的孩子中存在当前节点，则将当前节点的fail指针指向该节点，如果不存在，需要沿着fail指针一直向上寻找直至根节点，如果根节点的孩子中也找不到，说明树中不存在该字符，将当前节点的fail指针指向根节点就行了。最后，在查找时也类似，
编译原理有穷自动机
05-06
有穷自动机（Finite Automaton，简称FA）是编译原理中的一个重要概念，它是一种抽象的计算模型，用于识别和处理形式语言。在本项目中，C#代码实现了基于DFA（确定有限状态自动机）的字符串匹配功能，可以通过VS2012...
使用R语言中的Fuzzy C-Means算法对iris数据集进行模糊聚类分析
09-03
在这项分析中，我们使用R语言对经典的iris数据集进行了模糊聚类分析，采用了Fuzzy C-Means（FCM）算法。Fuzzy C-Means是一种改进的聚类算法，允许每个数据点以不同的隶属度（概率）属于多个簇，而不仅仅是硬性分配到单个簇。这种方法特别适用于数据点之间界限不清晰的情况，通过计算每个数据点到各个簇中心的距离来确定其隶属度，从而生成更灵活的聚类结果。 在该分析中，我们首先从iris数据集中提取了四个数值变量——花萼长度、花萼宽度、花瓣长度和花瓣宽度。接着，我们加载了R中的cluster包，并使用其中的fanny函数执行Fuzzy C-Means聚类。我们设定了聚类数为3，这是因为iris数据集中的物种数为3个，虽然我们事先知道这些类别，但我们通过算法进行盲分类，以便验证其效果。 fanny函数的一个重要特点是其模糊指数参数（memb.exp），该参数决定了隶属度的模糊性。设置为较高的数值会使聚类结果更加模糊，即数据点可能较均匀地分布在多个簇中；而较低的数值则使得聚类结果更接近传统的硬聚类。
【中科院1区】Matlab实现粒子群优化算法PSO-SAE实现故障诊断算法研究.rar
09-03
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
基于Web的农产品直卖平台+源代码+开题报告+演示视频.zip
09-03
计算机网络发展到现在已经好几十年了，在理论上面已经有了很丰富的基础，并且在现实生活中也到处都在使用，可以说，经过几十年的发展，互联网技术已经把地域信息的隔阂给消除了，让整个世界都可以即时通话和联系，极大的方便了人们的生活。所以说，农产品直卖平台用计算机技术来进行设计，不仅在管理方面更加的系统化，操作性强，最重要的是关于数据的保存和使用都能节约大量的时间，该系统非常的好用。 农产品直卖平台管理数据的工具是MySQL，编码的语言是Java，运用的框架是Spring Boot框架。该系统可以实现商家信用类型管理，农产品信息管理，农产品评价管理，商家管理，农产品订单管理，公告信息管理，用户管理等功能。 农产品直卖平台不仅能让操作人员使用更加地方便，并且设计的也很合理，能有效的避免误操作，让数据在录入的环节就符合设计需要，极大的规避了源头性的输入误差，顺利的让数据变得更加可控并且可靠，让出错的几率降到最低。 关键词：农产品直卖平台；农产品；评价；订单
PHP基于Linux的远程管理系统服务器端的实现(源代码+LW).rar
09-03
PHP基于Linux的远程管理系统服务器端的实现(源代码+LW).rar
基于javaweb的流浪宠物管理系统+源代码+开题报告+演示视频.zip
09-03
当下，正处于信息化的时代，许多行业顺应时代的变化，结合使用计算机技术向数字化、信息化建设迈进。传统的流浪宠物信息管理模式，采用人工登记的方式保存相关数据，这种以人力为主的管理模式已然落后。本人结合使用主流的程序开发技术，设计了一款基于Java Web的流浪宠物管理系统，可以较大地减少人力、财力的损耗，方便相关人员及时更新和保存信息。本系统主要使用B/S开发模式，在idea集成开发环境下，采用Java语言编码设计系统功能，MySQL数据库管理相关的系统数据信息，SSM框架设计和开发系统功能架构，最后通过使用Tomcat服务器，在浏览器中发布设计的系统，并且完成系统与数据库的交互工作。本文对系统的需求分析、可行性分析、技术支持、功能设计、数据库设计、功能测试等内容做了较为详细的介绍，并且在本文中也展示了系统主要的功能模块设计界面和操作界面，并对其做出了必要的解释说明，方便用户对系统进行操作和使用，以及后期的相关人员对系统进行更新和维护。通过设计基于Java Web的流浪宠物管理系统，可以极大地提高流浪宠物管理的工作效率，提升用户的使用体验。 关键词：流浪宠物管理，Java语言，B/S结
基于物联网的户外环境检测装置（STM32、APP、WIFI）
09-03
基于物联网的户外环境检测装置（STM32、APP、WIFI）
基于SpringBoot的医院药品管理系统+源代码+演示视频.zip
09-03
身处网络时代，随着网络系统体系发展的不断成熟和完善，人们的生活也随之发生了很大的变化，人们在追求较高物质生活的同时，也在想着如何使自身的精神内涵得到提升，而读书就是人们获得精神享受非常重要的途径。为了满足人们随时随地只要有网络就可以看书的要求，医院药品管理系统被开发研究了出来。 本文主要描述了该医院药品管理系统的具体开发过程，在SSM框架的基础上，采用vue技术和MYSQL数据库，使该医院药品管理系统具有很好的稳定性和安全性。本设计重点从系统概述、系统分析、系统设计、数据库设计、系统测试和总结这几个方面对该医院药品管理系统进行阐述，用户通过该医院药品管理系统可以查询自己喜欢的信息。 该医院药品管理系统不仅能够稳定的运行，快捷方便的操作，界面简洁清晰，而且功能齐全，实用性强。 关键词：医院药品管理系统，SSM框架，系统分析，数据库设计
c++课程大作业-基于c++与QT的俄罗斯方块游戏源代码+项目文档（高分项目）
09-03
c++课程大作业-基于c++与QT的俄罗斯方块游戏源代码+项目文档（高分项目），含有代码注释，新手也可看懂，个人手打98分项目，导师非常认可的高分项目，毕业设计、期末大作业和课程设计高分必看，下载下来，简单部署，就可以使用。 c++课程大作业-基于c++与QT的俄罗斯方块游戏源代码+项目文档（高分项目），含有代码注释，新手也可看懂，个人手打98分项目，导师非常认可的高分项目，毕业设计、期末大作业和课程设计高分必看，下载下来，简单部署，就可以使用。 c++课程大作业-基于c++与QT的俄罗斯方块游戏源代码+项目文档（高分项目），含有代码注释，新手也可看懂，个人手打98分项目，导师非常认可的高分项目，毕业设计、期末大作业和课程设计高分必看，下载下来，简单部署，就可以使用。 c++课程大作业-基于c++与QT的俄罗斯方块游戏源代码+项目文档（高分项目），含有代码注释，新手也可看懂，个人手打98分项目，导师非常认可的高分项目，毕业设计、期末大作业和课程设计高分必看，下载下来，简单部署，就可以使用。c++课程大作业-基于c++与QT的俄罗斯方块游戏源代码+项目文档（高分项目），含有代码注释
【中科院1区】Matlab实现鹈鹕优化算法POA-SAE实现故障诊断算法研究.rar
最新发布
09-03
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新发文】基于遗传算法GA-DELM的多输入单输出预测Matlab实现.rar
09-03
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
基于医疗报销系统+源代码+演示视频.zip
09-03
传统信息的管理大部分依赖于管理人员的手工登记与管理，然而，随着近些年信息技术的迅猛发展，让许多比较老套的信息管理模式进行了更新迭代，报销单信息因为其管理内容繁杂，管理数量繁多导致手工进行处理不能满足广大用户的需求，因此就应运而生出相应的医疗报销系统。 本医疗报销系统分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理公告信息以及公告的租赁信息，能够与用户进行相互交流等操作，用户可以查看报销单信息，可以查看公告以及查看管理员回复信息等操作。 该医疗报销系统采用的是WEB应用程序开发中最受欢迎的B/S三层结构模式，使用占用空间小但功能齐全的MySQL数据库进行数据的存储操作，系统开发技术使用到了JSP技术。该医疗报销系统能够解决许多传统手工操作的难题，比如数据查询耽误时间长，数据管理步骤繁琐等问题。总的来说，医疗报销系统性能稳定，功能较全，投入运行使用性价比很高。 关键词：医疗报销系统；MySQL数据库；SSM技术
Xjad反编译工具（Java源代码反编译工具）
09-03
XJad是基于Jad核心的Java源程序反编译软件，内置Jad1.5.8e2。 XJad可处理多个*.class文件，可以处理文件夹内的所有文件，甚至可以处理*.jar文件。 XJad带有多页面文本编辑器，反编译完成后可以直接编辑查看，编辑器支持java语法的高亮显示功能。 XJad是一个纯绿色软件，为使用方便，可以在选项中设置集成到资源管理器中，这样在*.class、*.java、*.jar 文件和目录上随时点击右键都可直接进行操作。 　　XJad还带有导出当前编辑器中的代码为HTML文件的功能，HTML文件保持代码高亮显示的样式风格。
PPT模板简洁风格200MPPT模板简洁风格200M
09-03
PPT模板简洁风格200MPPT模板简洁风格200M提取方式是百度网盘分享地址
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值