c语言计算器通用栈

于 2022-11-24 15:59:33 发布
阅读量434 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh080223/article/details/128020531
版权

数据结构 c语言 
#include<stdio.h>
#include<stdlib.h> 
#include<math.h>

#define STACK_INIT_SIZE 100
/*定义栈初始容量*/
#define STACK_INCREMENT 10
/*定义栈增加容量*/
#define M 100
/*定义字符串的长度*/

typedef enum{
	OK=1,
	ERROR=0
}Status;

typedef struct{
	void* pBase;
	void* pTop;
	void* shuzu[M];
	int elementSize;
	int stackSize;
	
}Stack;

Stack* Stack_Construct(int sizeOfElement);
/*功能：构造一个栈
 *参数：栈元素类型的长度 
 *返回：构造成功返回新构造的栈；否则返回NULL 
 */

Stack* Stack_Construct(int sizeOfElement){
	Stack *pStack;
	pStack=(Stack*)malloc(sizeof(Stack));
	if(pStack==NULL){
		return NULL;
	}
	pStack->pBase=malloc(STACK_INIT_SIZE*sizeOfElement);
	if(pStack->pBase==NULL){
		free(pStack);
		return NULL;
	}
	pStack->pTop=pStack->pBase;
	pStack->elementSize=sizeOfElement;
	pStack->stackSize=STACK_INIT_SIZE;
	return pStack;
}

Status Stack_Init(Stack *pStack);
/*参数：pStack是指向栈的指针 
 *返回：成功返回OK；否则返回ERROR 
 */

void Stack_Free(Stack *pStack);
/*参数：pStack是指向栈的指针 
 *返回：无 
 */

void Stack_Clear(Stack *pStack);
/*参数：pStack是指向栈的指针 
 *返回：无 
 */
 
bool Stack_IsEmpty(Stack *pStack);
/*参数：pStack是指向栈的指针
 *返回：若栈为空，返回true；否则返回false 
 */

bool Stack_IsFull(Stack *pStack);
/*参数：pStack是指向栈的指针 
 *返回：若栈已满，返回true；否则返回false 
 */

int Stack_Length(Stack *pStack);
/*参数：pStack是指向栈的指针 
 *返回:栈的长度 
 */

char Stack_GetTop(Stack *pStack);
/*功能：取出栈顶元素
 *参数：pStack是指向栈的指针
 *返回：返回栈顶元素 
 */ 

Status Stack_Push(Stack *pStack,void *pVoid);
/*功能：将pVoid指向的数据压入pStack指向的栈 
 *参数：pStack是指向栈的指针，pVoid是指向数据的指针
 *返回：成功返回OK；否则返回ERROR 
 */ 

Status Stack_Pop(Stack *pStack,void *pVoid);
/*功能：将pStack指向的栈的元素弹出存入pVoid指向的内存 
 *参数：pStack是指向栈的指针，pVoid是指向数据的指针 
 *返回：成功返回OK；否则返回ERROR 
 */ 

Status Stack_Traverse(Stack *pStack,Status(*visit)());
/*功能：对pStack指向的栈的每个元素执行visit操作 
 *参数：pStack是指向栈的指针，visit是函数指针 
 *返回：成功返回OK；失败返回ERROR 
 */

float ConvertToFloat(char m[M],float r);
/*功能：将数字串转换为浮点数 
 *参数：m[M]是原数字串，r是浮点数即结果 
 *返回：返回结果浮点数r 
 */

int Judge(char x);
/*功能：判断运算符的类型并分级 
 *参数：x是运算符的符号 
 *返回：字符所代表的级数 
 */
 
int Culculate(int x1,int x2,char s);
/*功能：执行计算 
 *参数：x1是第一个数字
        x2是第二个数字
		s是运算符 
 *返回：返回运算结果 
 */

Stack *pIntStack;
pIntStack=Stack_Construct(sizeof(int));
/*构造一个数字栈*/

Stack *pSymbolStack;
pSymbolStack=Stack_Construct(sizeof(char));
/*构造一个符号栈*/

Status Stack_Init(Stack *pStack){
	pStack->pBase=(void*)malloc(STACK_INIT_SIZE*sizeof(void));
	if(pStack->pBase==NULL){
		return ERROR;
	}
	pStack->pTop=pStack->pBase;
	pStack->stackSize=STACK_INIT_SIZE;
	return OK;
}

void Stack_Free(Stack *pStack){
	free(pStack->pBase);
	pStack->pBase=NULL;
	pStack->pTop=NULL;
	pStack->stackSize=0;
	return;
}

void Stack_Clear(Stack *pStack){
	pStack->pTop=pStack->pBase;
}

bool Stack_IsEmpty(Stack *pStack){
	if(pStack->pTop==pStack->pBase){
		return true;
	}
	else{
		return false;
	}
}

bool Stack_IsFull(Stack *pStack){
	if(pStack->pTop-pStack->pBase==pStack->stackSize){
		return true;
	}
	else{
		return false;
	}
}

int Stack_Length(Stack *pStack){
	return pStack->pTop-pStack->pBase;
}

char Stack_GetTop(Stack *pStack){
	return pIntStack->shuzu[pIntStack->pTop];
}

Status Stack_Push(Stack *pStack,void *pVoid){
	int newSize;
	void *pVoid_2;
	if(Stack_Length(pStack)>=Stack->stackSize){
		newSize=pStack->stackSize+STACK_INCREMENT;
		pVoid_2=(void*)realloc(pStack->pBase,newSize*sizeof(void));
		if(pVoid_2==NULL){
			return ERROR;
		}
		else{
			pStack->pBase=pVoid_2;
			pStack->pTop=pStack->pBase+pStack->stackSize;
			pStack->stackSize=newSize;
		}
	}
	*(pStack->pTop)=*pVoid;
	pStack->pTop++;
	return OK;
}

Status Stack_Pop(Stack *pStack,void *pVoid){
	if(pStack->pTop==pStack->pBase){
		return ERROR;
	}
	else{
		pStack->pTop--;
		*pVoid=*(pStack->pTop);
		return OK;
	}
}

Status Stack_Traverse(Stack *pStack,Status(*visit)()){
	int i,j;
	j=Stack_Length(pStack);
	for(i=0;i<n;i++){
		if(visit(&(pStack->pBase[i]))==ERROR){
			return ERROR;
		}
	}
	return OK;
}

float ConvertToFloat(char m[M]){
	int i=0;
	float value=0;
	while(m[i]!='\0'&&m[i]!='.'){
		value=value*10+(m[i]-'0');
		i=i+1;
	}
	if(m[i]=='\0'){
		return value;
	}
	i=i+1;
	int weight=0.1;
	while(m[i]!='\0'){
		value=value+(m[i]-'0')*weight;
		weight=weight/10;
		i=i+1;
	}
	return value;
}

int Judge(char x){
	if(x=='('){
		return 1;
	}
	else if(x=='+'||x=='-'){
		return 2;
	}
	else if(x=='*'||x=='/'){
		return 3;
	}
	else if(x=='^'){
		return 4;
	}
	else if(x==')'){
		return 5;
	}
}

int Culculate(int x1,int x2,char s){
	int result;
	switch(s){
		case '+':{
			result=x1+x2;
			break;
		}
		case '-':{
			result=x1-x2;
			break;
		}
		case '*':{
			result=x1*x2;
			break;
		}
		case '/':{
			result=x1/x2;
			break;
		}
		case '^':{
			result=pow(x1,x2);
			break;
		}
	}
}

int main(){
	printf("Enter The Expression Including '+' '-' '*' '/' '^' '(' ')' And Intengers\n");
	Stack* stack=(Stack*)malloc(sizeof(Stack));
	Stack_Init(stack);
	int a=0,b=0,c=0,result=0,x1,x2;
	char y;
	char s[M]={0};
	char n[M]={0};
	char d[M]={0};
	char *str=(char*)malloc(sizeof(char)*M);
	char fuhao; 
	while((y=getchar())!='\n'){
		str[a]=y;
		a++;
	}
	str[a]='\0';
	for(a=0;str[a]!='\0';a++){
		if(a==0&&str[a]=='-'){
			s[b++]=str[a];
		}
		else if(str[a]=='('&&str[a+1]=='-'){
			a++;
			s[b++]=str[a++];
			while(str[a]>='0'&&str[a]<='9'){
				s[b]=str[a];
				n[b]=atoi(s);
				b++;
				a++;
			}
			Stack_Push(pIntStack,&n[b]);
			while(b>0){
				s[b]=0;
				n[b]=0;
				b--;
			}
		}
		else if(str[a]>='0'&&str[a]<='9'){
			while(str[a]>='0'&&str[a]<='9'){
				s[b]=str[a];
				n[b]=atoi(s);
				b++;
				a++;
			}
			Stack_Push(pIntStack,&n[b]);
			while(b>0){
				s[b]=0;
				n[b]=0;
				b--;
			}
			a--;
		}
		else{
			if(pSymbolStack->pTop==-1){
				Stack_Push(pSymbolStack,&str[a]);
			}
			else if(Judge(str[a])==1){
				Stack_Push(pSymbolStack,&str[a]);
			}
			else if(Judge(str[a])==2){
				if(Judge(Stack_GetTop(pSymbolStack))==1){
					Stack_Push(pSymbolStack,&str[a]);
				}
				else if(Judge(Stack_GetTop(pSymbolStack))==2){
					while(pSymbolStack->pTop>=0&&pIntStack>=1){
						Stack_Pop(pIntStack,&x2);
                    	Stack_Pop(pIntStack,&x1);
                    	Stack_Pop(pSymbolStack,&fuhao);
						result=Culculate(x1,x2,fuhao);
						Stack_Push(pIntStack,&result);
					}
					Stack_Push(pSymbolStack,&str[a]);
				}
				else if(Judge(Stack_GetTop(pSymbolStack))==3){
					while(pSymbolStack->pTop>=0&&pIntStack->pTop>=1){
						Stack_Pop(pIntStack,&x2);
                    	Stack_Pop(pIntStack,&x1);
                    	Stack_Pop(pSymbolStack,&fuhao);
						result=Culculate(x1,x2,fuhao);
						Stack_Push(pIntStack,&result);
					}
					Stack_Push(pSymbolStack,&str[a]);
				}
			}
			else if(Judge(str[a])==3){
				if(Judge(Stack_GetTop(pSymbolStack))==1){
					Stack_Push(pSymbolStack,&str[a]);
				}
				else if(Judge(Stack_GetTop(pSymbolStack))==2){
					Stack_Push(pSymbolStack,&str[a]);
				}
				else if(Judge(Stack_GetTop(pSymbolStack))==3){
					while(pSymbolStack->pTop>=0&&pIntStack->pTop>=1){
						Stack_Pop(pIntStack,&x2);
                    	Stack_Pop(pIntStack,&x1);
                    	Stack_Pop(pSymbolStack,&fuhao);
						result=Culculate(x1,x2,fuhao);
						Stack_Push(pIntStack,&result);
					}
					Stack_Push(pSymbolStack,&str[a]);
				}
			}
			else if(Judge(str[a])==4){
            	if(Judge(Stack_GetTop(pSymbolStack))==1){
                    Stack_Push(pSymbolStack,&str[a]);
                }
                else if(Judge(Stack_GetTop(pSymbolStack))==2){
                    Stack_Push(pSymbolStack,&str[a]);
                }
                else if(Judge(Stack_GetTop(pSymbolStack))==3){
                    Stack_Push(pSymbolStack,&str[a]);
                }
                else if(Judge(Stack_GetTop(pSymbolStack))==4){
                    while(pSymbolStack->pTop>=0&&pIntStack->pTop>=1){
                        Stack_Pop(pIntStack,&x2);
                    	Stack_Pop(pIntStack,&x1);
                    	Stack_Pop(pSymbolStack,&fuhao);
                        result=Culculate(x1,x2,fuhao);
                        Stack_Push(pIntStack,&result);
                    }
                    Stack_Push(pSymbolStack,&str[a]);
                }
            }
            else if(Judge(str[a])==5){
                do{
                    Stack_Pop(pIntStack,&x2);
                    Stack_Pop(pIntStack,&x1);
                    Stack_Pop(pSymbolStack,&fuhao);
                    result=Culculate(x1,x2,fuhao);
                    Stack_Push(pIntStack,&result);
                }while(Judge(Stack_GetTop(pSymbolStack))!=1);
                StackSymbol_Pop(pSymbolStack);
            }
		}
	}
	free(str);
	while(pSymbolStack->pTop!=-1){
		Stack_Pop(pIntStack,&x2);
  		Stack_Pop(pIntStack,&x1);
  		Stack_Pop(pSymbolStack,&fuhao);
        result=Culculate(x1,x2,fuhao);
        Stack_Push(pIntStack,&result);
	}
	printf("The Result Is %d",result);
	return 0;
}

zh080223
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
通用栈（c实现）
zhangsiyao11的博客
07-12 1714
c语言实现的通用栈，可存放各种数据类型. cstack.h文件 #pragma once typedef struct Node { void *pdata; struct Node *pnext; }Node,*PNode; typedef struct CStack { int count; int data_size; Node *phead; }C
栈溢出攻击之弹出计算器
Bonjour~
04-15 7733
一.系统栈溢出原理函数栈帧及寄存器在高级语言中，当函数被调用时，系统栈会为这个函数开辟一个新的栈帧，并把它压入栈中。这个栈帧中的内存空间被它所属的函数独占，正常情况下是不会和别的函数共享的。当函数返回时，系统栈会弹出该函数所对应的栈帧。Win32系统提供两个特殊的寄存器用于标识位于系统栈顶端的栈帧： 1. ESP：栈指针寄存器，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的栈顶； 2.
C语言堆栈计算器
07-03
C语言实现的堆栈计算器，通过输入整个算式进行计算，并且对简单错误进行判断输出，可识别括号等特殊符号。
通用栈的设计和实现[C实现]
编程语言小筑
03-09 335
①、栈的定义 typedef struct { void **base; /* 栈底 */ void **top; /* 栈顶 */ int size; /* 栈的大小 */ }stack_t; 在此设计的通用栈将会达到以下两点要求： ①、可以处理任意的数据类型的数据 请注意栈中base和top的数据类型，其为void**，因此其可以处理各种数据类型...
通用堆栈c语言版本（可以适应任何类型）
_愤怒的石头_的专栏
04-27 680
#include #include #include #define OK 0; #define ERROR -1 #define OVERFLOW -2 #define YES 1 #define NO 0 #define STACK_INIT_SIZE 100 #define STACK_INCREMENT 10 typedef int Status; typedef int T
C语言计算器代码一个简单的计算器C代码
12-31
根据给定的信息，本文将详细解析“C语言计算器代码一个简单的计算器C代码”中的关键知识点。这段代码实现了一个简易的命令行计算器程序，利用栈结构处理输入的数据与运算符，并计算出结果。 ### 标题解析：C语言...
c语言实现的高级计算器.7z
04-09
6. **内存管理**：如果计算器程序涉及动态数据结构，如链表或栈，就需要使用C语言的动态内存分配函数`malloc`和`free`来管理内存。 7. **编译与调试**：C语言程序需要通过编译器转换为机器代码才能运行。使用`gcc`...
用c语言写的计算器代码。
07-06
通过这个简单的C语言计算器项目，我们可以学习到C语言的基本语法、输入/输出操作、控制结构以及简单的数学运算。这只是一个起点，更复杂的计算器可能会包括括号支持、多个运算符优先级处理等特性，需要更深入的编程...
计算器的设计与实现c语言作业源码+代码详细注释.zip
12-15
首先，C语言是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也支持面向对象编程的计算机程序设计语言。它的灵活性和高效性使其成为编写系统软件和嵌入式应用的理想选择。在设计计算器时，...
栈实现计算器（c语言版）
10-25
这是c语言计算器程序代码，用栈实现，以#号键结尾输入公式计算数值
自己用C语言写的简单计算器，用堆栈实现
10-30
自己用C语言写的简单计算器，用堆栈实现，欢迎大家指正！
c语言计算器（栈实现）
u012986121的专栏
10-11 1466
#include #include #define MAXSIZE 100 typedef struct stack {     int stack[MAXSIZE];     int index; }Stack; int isNoOp(int ch) { if (ch == ')' || ch == '(') { return 1;
c语言通用数据类型栈,C语言实现通用数据类型栈结构
weixin_33952775的博客
05-21 262
Stack.htypedef struct {void *elems;int elemSize;int logicalLen;int allocLen;}Stack;void StackNew(Stack *s,int elemSize);void StackDispose(Stack *s);void StackPush(Stack *s,void *elemAddr);void StackPo...
通用栈的设计和实现[C语言]
做事先做人！
03-09 3226
①、栈的定义 typedef struct { void **base; /* 栈底 */ void **top; /* 栈顶 */ int size; /* 栈的大小 */ }stack_t; 在此设计的通用栈将会达到以下两点要求：     ①、可以处理任意的数据类型的数据             请注意栈中base和top的数据类型，其为void**
通用栈
chaoyue1216的专栏
04-18 1545
栈是一种用得比较多的数据结构，用处很广。但很多时候，栈中的元素是不一样的。那如何写一个通用的栈呢。在C++中有模板，那如何用C实现通用的栈呢。 在C语言中，不同的数据类型，占用的字节数不一样。参考qsort对不同数据类型的排序方法，可以得知，使用一个指针，以及此类型的大小即可。 具体的请参考以下代码实现。 /*实现通用的栈结构 */ #include typedef struct
利用栈实现计算器功能-C语言
热门推荐
weixin_42287162的博客
03-01 1万+
功能： 实现计算器，可以运算带括号的表达式。 如1+（1+1）*2+1 首先，我们需要了解中缀表达式和后缀表达式。 中缀表达式（符号在中间）： 如1+（1+1）*2+1 后缀表达式（符号在后面）： 如上会得到1 1 1 + 2 * + 1 + 步骤： ①从左往右，若遇到数字先放一边，遇到符号就进栈。 ②若栈顶是“（”，接下来符号肯定进栈；若接下来遇到“）”，“）”不进栈，将符号从栈里取出，直到遇到...
基本计算器 II-c语言栈法
weixin_43327597的博客
05-17 279
基本计算器 II-c语言栈法 给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。 整数除法仅保留整数部分。 你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。 注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。 示例 1： 输入：s = “3+2*2” 输出：7 示例 2： 输入：s = " 3/2 " 输出：1 示例 3： 输入：s = " 3+5 / 2 " 输出：5 提示： 1 <= s.length
C语言堆栈实现计算器（求后缀表达式）
weixin_52088967的博客
05-31 807
C语言
带括号的C语言计算器,栈实现的带括号的计算器
最新发布
05-28
好的，以下是一个使用栈实现带括号的C语言计算器的示例代码： ```c #include #include #include // 定义栈结构 typedef struct stack { int top; int capacity; int* array; } Stack; // 创建一个新的空栈 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值