数据结构——模拟计算器

最新推荐文章于 2024-04-27 23:54:07 发布
最新推荐文章于 2024-04-27 23:54:07 发布
阅读量1.2k 收藏 10
点赞数
分类专栏： 大学 练手 文章标签： 数据结构 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42420778/article/details/86412873
版权 

#include "graphics.h"
#include "windows.h"
#include "math.h"
#include "conio.h"
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#define N 100

const int max = 100;  //设置常量max=100

typedef struct  //声明堆栈结构体
{
    char data[N][N];
    int top;

}stack;

typedef struct figure  //声明数字结构体
{
    char x[N];
}figure;

/**********************方法声明区**********************/
void chuli(char ch[],struct figure a[]);
void clear_cal();

void init(stack *sta);
void inffixtosuffix(stack *sta,figure a[],char suffix[][max],int *length);
void suffixtoresult(stack *sta,char suffix[][max],int length);
/**********************方法声明区**********************/

/**********************GUI界面区**********************/
void calcul_memu()  //计算器界面
{
    setfillcolor(BLACK);//暂时白色
    solidrectangle(0,100,480,600);

    setcolor(WHITE);//暂时蓝色
    line(0,100,480,100);
    line(0,200,480,200);
	line(360,250,480,250);
    line(0,300,480,300);
	line(360,350,480,350);
    line(0,400,480,400);
	line(360,450,480,450);
    line(0,500,480,500);
    line(120,100,120,600);
    line(240,100,240,600);
    line(360,100,360,600);

    settextstyle(50,50,_T("幼圆"));
    outtextxy(30,120,_T("("));
    outtextxy(150,120,_T(")"));
    outtextxy(390,120,_T("+"));
    outtextxy(30,220,_T("7"));
    outtextxy(150,220,_T("8"));
    outtextxy(270,220,_T("9"));
    outtextxy(30,320,_T("4"));
    outtextxy(150,320,_T("5"));
    outtextxy(270,320,_T("6"));
    outtextxy(30,420,_T("1"));
    outtextxy(150,420,_T("2"));
    outtextxy(270,420,_T("3"));
    outtextxy(30,520,_T("."));
    outtextxy(150,520,_T("0")); 
    outtextxy(390,520,_T("="));
    outtextxy(260,120,_T("<"));
    outtextxy(270,520,_T("C"));
	settextstyle(49,49,_T("幼圆"));
	outtextxy(390,201,_T("-"));
	outtextxy(390,401,_T("/"));
	outtextxy(390,351,_T("*"));
	settextstyle(30,30,_T("幼圆"));
	outtextxy(380,460,_T("MHF"));
	outtextxy(380,260,_T("SQR"));
	outtextxy(380,310,_T("ABS"));
}

int count=0;
char str[N]={'0'};          //字符数组赋初始值
figure st[N];
char suffix[N][N]={'0'};    //后缀数组赋初始值
stack sta;

void mouse_imfor()  //处理鼠标的消息；
{
    int length=0;
    int i=-1;
    int go=0;
	double result=0;
    for(int a=0;a<N;a++)
        strcpy(st[i].x,"0");
    MOUSEMSG m;
    while(go==0)
    {
        setcolor(WHITE);
        settextstyle(60,20,_T("幼圆"));
        m=GetMouseMsg();
        switch(m.uMsg)
        {
        case WM_LBUTTONDOWN:
            if(m.x>0&&m.x<120&&m.y>100&&m.y<200)
            {
                ++i;count++;
                str[i]='(';
            }
            if(m.x>120&&m.x<240&&m.y>100&&m.y<200)
            {
                ++i;count++;
                str[i]=')';
            }
            if(m.x>240&&m.x<360&&m.y>100&&m.y<200)
            {
                i--;
                count--;
                outtextxy(460-i*20,20,_T(str));
                outtextxy(460-(i+1)*20,20,_T(" "));     //按'<'键清除后一个，往后退；
            }
            if(m.x>360&&m.x<480&&m.y>100&&m.y<200)
            {
                ++i;count++;
                str[i]='+';
            }
            if(m.x>0&&m.x<120&&m.y>200&&m.y<300)
            {
                ++i;count++;
                str[i]='7';
            }
            if(m.x>120&&m.x<240&&m.y>200&&m.y<300)
            {
                ++i;count++;
                str[i]='8';
            }
            if(m.x>240&&m.x<360&&m.y>200&&m.y<300)
            {
                ++i;count++;
                str[i]='9';
            }
            if(m.x>360&&m.x<480&&m.y>200&&m.y<250)
            {
                ++i;count++;
                str[i]='-';
            }
			if(m.x>360&&m.x<480&&m.y>250&&m.y<300)
            {
                ++i;count++;
                str[i]='s';
            }
            if(m.x>0&&m.x<120&&m.y>300&&m.y<400)
            {
                ++i;count++;
                str[i]='4';
            }
            if(m.x>120&&m.x<240&&m.y>300&&m.y<400)
            {
                ++i;count++;
                str[i]='5';
            }
            if(m.x>240&&m.x<360&&m.y>300&&m.y<400)
            {
                ++i;count++;
                str[i]='6';
            }
			if(m.x>360&&m.x<480&&m.y>300&&m.y<350)
            {
                ++i;count++;
                str[i]='a';
            }
            if(m.x>360&&m.x<480&&m.y>350&&m.y<400)
            {
                ++i;count++;
                str[i]='*';
            }
            if(m.x>0&&m.x<120&&m.y>400&&m.y<500)
            {
                ++i;count++;
                str[i]='1';
            }
            if(m.x>120&&m.x<240&&m.y>400&&m.y<500)
            {
                ++i;count++;
                str[i]='2';
            }
            if(m.x>240&&m.x<360&&m.y>400&&m.y<500)
            {
                ++i;count++;
                str[i]='3';
            }
            if(m.x>360&&m.x<480&&m.y>400&&m.y<450)
            {
                ++i;count++;
                str[i]='/';
            }
			if(m.x>360&&m.x<480&&m.y>450&&m.y<500)
            {
                ++i;count++;
                str[i]='m';
            }
            if(m.x>0&&m.x<120&&m.y>500&&m.y<600)
            {
                ++i;count++;
                str[i]='.';
            }
            if(m.x>120&&m.x<240&&m.y>500&&m.y<600)
            {
                ++i;count++;
                str[i]='0';
            }
            outtextxy(460-i*20,20,_T(str));
            if(m.x>240&&m.x<360&&m.y>500&&m.y<600)
            {
                ++i;count++;
                str[i]='C';
            }
            str[i+1]='\0';
            if(m.x>360&&m.x<480&&m.y>500&&m.y<600)
            {
                ++i;count++;
                str[i]='=';
                str[i+1]='\0';
            }
            Sleep(100);
            break;
        case WM_RBUTTONUP:
            go=1;
            break;
        }
        if(str[i]=='C'||str[i]=='=')
            break;  
    }
    if(str[i]=='C')//按'C'键清空界面；
    {
        setbkcolor(BLACK);
        cleardevice();
        calcul_memu();
        mouse_imfor();
    }
    else if(str[i]=='=')
    {
        chuli(str,st);
        init(&sta);
        inffixtosuffix(&sta,st,suffix,&length);
        setbkcolor(BLACK);
        cleardevice();
        calcul_memu();
        init(&sta);
        suffixtoresult(&sta,suffix,length);

        go=0;
        while(go==0)
        {
            m=GetMouseMsg();
            switch(m.uMsg)
            {
            case WM_LBUTTONDOWN:
                if(m.x>240&&m.x<360&&m.y>500&&m.y<600)
                {
                    str[i]='C';
                }
                str[i+1]='\0';
                break;
            case WM_RBUTTONUP:
                go=1;
                break;
            }
            if(str[i]=='C')
                break;
        }   
        if(str[i]=='C')
        {
            setbkcolor(BLACK);
            cleardevice();
            calcul_memu();
            mouse_imfor();
        }
    }

}

void clear_cal()
{
    setbkcolor(BLACK);
    calcul_memu();
}//初始化界面;

int q;                  //定义一个全局变量，用来计数结构体数组的数量；

void chuli(char ch[],struct figure a[])  //将字符串分割出来；
{
    q=0;
    int m=0,j;
    char asd[15]={'0'};
    printf("\ncount=%d\n",count);
    while(m<count)
    {
        j=0;
        if(ch[m]=='=')
            break;
        if(ch[m]=='('||ch[m]==')')
        {
            asd[j]=ch[m];
            asd[j+1]='\0';
            m++;
            strcpy(a[q].x,asd);
            q++;
            continue;
        }
        if(ch[m]=='+'||ch[m]=='-')
        {
            if(ch[m-1]=='+'||ch[m-1]=='-'||ch[m-1]=='*'||ch[m-1]=='/'||m==0||ch[m]=='(')
            {
                asd[j]=ch[m];
                m++;
                j++;
                while(ch[m]!='+'&&ch[m]!='-'&&ch[m]!='*'&&ch[m]!='/'&&ch[m]!=')')
                {
                    asd[j]=ch[m];
                    j++;
                    m++;
                }
                asd[j]='\0';
                strcpy(a[q].x,asd);
                q++;
            }
            else 
            {
                asd[j]=ch[m];
                asd[j+1]='\0';
                m++;
                strcpy(a[q].x,asd);
                q++;
            }
            continue;
        }
        if(ch[m]=='*'||ch[m]=='/')
        {
            asd[j]=ch[m];
            asd[j+1]='\0';
            m++;
            strcpy(a[q].x,asd);
            q++;
            continue;
        }
		if(ch[m]=='s'||ch[m]=='a'||ch[m]=='m')
        {
            asd[j]=ch[m];
            asd[j+1]='\0';
            m++;
            strcpy(a[q].x,asd);
            q++;
            continue;
        }
        if(ch[m]!='+'&&ch[m]!='-'&&ch[m]!='*'&&ch[m]!='/'&&ch[m]!='('&&ch[m]!=')'&&ch[m]!='s'&&ch[m]!='a'&&ch[m]!='m')
        {
            while(ch[m]!='+'&&ch[m]!='-'&&ch[m]!='*'&&ch[m]!='/'&&ch[m]!='('&&ch[m]!=')'&&ch[m]!='='&&ch[m]!='s'&&ch[m]!='a'&&ch[m]!='m')
            {
                asd[j]=ch[m];
                j++;
                m++;
            }
            asd[j]='\0';
            strcpy(a[q].x,asd);
            q++;
            continue;
        }
    }
}
/**********************GUI界面区**********************/

/**********************计算器算法区**********************/
void init(stack *sta)  //初始化栈；
{
    int i;
    for(i=0;i<max;i++)
        strcpy(sta->data[i],"0");
    for(i=0;i<5;i++)
        printf("初始化栈：%s\n",sta->data[i]);
    sta->top=-1;
}

void inffixtosuffix(stack *sta,struct figure *a,char suffix[][N],int *length)  //中缀表达式变为后缀表达式；
{
    int i=0;
    int j=0;
    for(i=0;i<q;)
    {
        if(strcmp(a[i].x,"(")==0)  //若运算符为（
        {
            sta->top++;
            strcpy(sta->data[sta->top],a[i].x);
            i++;
            continue;
        }
        else if(strcmp(a[i].x,")")==0)  //若运算符为）
        {
            while(strcmp(sta->data[sta->top],"(")!=0&&sta->top!=-1)
            {
                strcpy(suffix[j],sta->data[sta->top]);
                sta->top--;
                j++;
            }
            strcpy(sta->data[sta->top],"0");
            i++;
            sta->top--;
            continue;
        }
        else if(strcmp(a[i].x,"=")==0)  //若运算符为=
        {
            i++;
            continue;
        }
        else if(strcmp(a[i].x,"+")==0||strcmp(a[i].x,"-")==0)  //若运算符为+或-
        {
            while(strcmp(sta->data[sta->top],"(")!=0&&sta->top!=-1)
            {   
                strcpy(suffix[j],sta->data[sta->top]);
                sta->top--;
                j++;
            }
            sta->top++;
            strcpy(sta->data[sta->top],a[i].x);
            i++;
            continue;
        }
        else if(strcmp(a[i].x,"*")==0||strcmp(a[i].x,"/")==0)  //若运算符为*或/
        {
            while(strcmp(sta->data[sta->top],"(")!=0&&sta->top!=-1&&strcmp(sta->data[sta->top],"+")!=0&&strcmp(sta->data[sta->top],"-")!=0)
            {
                strcpy(suffix[j],sta->data[sta->top]);
                sta->top--;
                j++;
            }
            sta->top++;
            strcpy(sta->data[sta->top],a[i].x);
            i++;
            continue;
        }
		else if(strcmp(a[i].x,"s")==0)  //若运算符为SQR
		{
			sta->top++;
			strcpy(sta->data[sta->top],a[i].x);
			i++;
			continue;
		}
		else if(strcmp(a[i].x,"a")==0)  //若运算符为ABS
		{
			sta->top++;
			strcpy(sta->data[sta->top],a[i].x);
			i++;
			continue;
		}
		else if(strcmp(a[i].x,"m")==0)  //若运算符为MHF
		{
			sta->top++;
			strcpy(sta->data[sta->top],a[i].x);
			i++;
			continue;
		}
        else   //若不是运算符
        {
            strcpy(suffix[j],a[i].x);
            j++;
            i++;
            continue;
        }
    }
    while(sta->top!=-1)   //此时p扫描完毕,栈不空时循环
    {
        strcpy(suffix[j],sta->data[sta->top]);
        sta->top--;
        j++;
    }
    *length =j;
    printf("\nlength=%d\n\n",*length);

}

void suffixtoresult(stack *sta,char suffix[][N],int length)  //后缀表达式输出结果;
{
    int i=0;
	double result = 0;
    while(i<length)
    {
        if(strcmp(suffix[i],"+")==0)
        {
            printf("\n\nsta=%s\n\n",sta->data[sta->top]);
            printf("\n\nsta=%s\n\n",sta->data[sta->top-1]);

            result=atof(sta->data[sta->top-1])+atof(sta->data[sta->top]);
            sta->top--;
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
        else if(strcmp(suffix[i],"-")==0)
        {
			result=atof(sta->data[sta->top-1])-atof(sta->data[sta->top]);
            sta->top--;
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
        else if(strcmp(suffix[i],"*")==0)
        {
            result=atof(sta->data[sta->top-1])*atof(sta->data[sta->top]);
            sta->top--;
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
        else if(strcmp(suffix[i],"/")==0)
        {
            result=atof(sta->data[sta->top-1])/atof(sta->data[sta->top]);
            sta->top--;
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
		else if(strcmp(suffix[i],"s")==0)
        {
            result=sqrt(atof(sta->data[sta->top]));
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
		else if(strcmp(suffix[i],"a")==0)
        {
            result=(double)abs(atof(sta->data[sta->top]));
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
		else if(strcmp(suffix[i],"m")==0)
        {
            result=(double)-abs(atof(sta->data[sta->top]));
            sprintf(sta->data[sta->top],"%.2lf",result);
            i++;
            continue;
        }
        else
        {
            sta->top++;
            strcpy(sta->data[sta->top],suffix[i]);
            i++;
            continue;
        }
    }
    printf("\n\nresult=%f\n",result);
//  printf("\n\nsta=%s\n\n",sta->data[sta->top]);
//  printf("sta->top=%d\n\n",sta->top);
    setcolor(WHITE);
    settextstyle(60,20,_T("幼圆"));
    if(sta->top==0)
        outtextxy(480-strlen(sta->data[sta->top])*20,20,_T(sta->data[sta->top]));
    else if(sta->top!=0)
        outtextxy(190,20,_T("ERROR"));


}
/**********************计算器算法区**********************/

void main()
{
    initgraph(480,600);     //设置窗口的大小；
    setbkcolor(BLACK);      //设置背景色为黑色；
    cleardevice();          //用背景色来清空屏幕；
    calcul_memu();
    mouse_imfor();
    closegraph();
    printf("s：%s\n",str);
    printf("结构体测试：\n");
    for(int i=0;i<q;i++)
        printf("%s\n",st[i].x);
    printf("suffix:\n");
    for(int m=0;m<q;m++)
        printf("%s\n",suffix[m]);
    getch();
}

大二练手作品，参考网上的代码，在此基础上添加了开方（SQR）和取绝对值（ABS）算法。GUI界面需要EasyX程序处理，VC++无法直接编译

龍淵
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
数据结构实验——链栈
12-22
在进行数据结构实验时，可以设计不同的场景来测试链栈的功能，比如模拟计算器的运算过程，使用链栈处理括号嵌套的问题，或者用链栈实现一个简单的逆波兰表达式求值器。这些实践可以帮助我们更好地理解链栈的工作原理...
java数据结构的手机计算器
07-27
这需要用到另一个数据结构——优先队列。通过优先队列，我们可以维护运算符的优先级，确保高级运算符先执行。但Java标准库并没有提供优先队列，所以开发者可能使用了自定义的堆或者数组模拟这一功能。 在J2ME平台上...
数据结构模拟器
shumoyin的博客
12-12 4774
数据结构模拟器：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
线性与树型数据结构可视化模拟器
程序设计
11-15 577
题目2:线性与树型数据结构可视化模拟器数据结构课程是计算机类专业的核心课程之一，是计算机科学与技术必修的专业基础课程。数据结构研究的范围和计算机软件有着密切的联系。课程涉及到大量的概念、定义以及数据结构的相关算法，具有一定的抽象性，尤其是树和图有较多的比较难理解的结构和算法。为了进一步展示算法运行过程中的动态性，题目要求利用图形可视化的方法，从数据结构的可视化和算法执行过程的可视化两个方面实现-一个可视化系统。
【C++数据结构】栈实现简单计算器（类模板）
最新发布
2301_80937868的博客
04-27 1472
栈的重要应用之一是表达式求值。本文以简单算术表达式为例展现这一应用。
线性与树型数据结构可视化模拟器[2023-07-06]
code helper
07-06 56
题目2:线性与树型数据结构可视化模拟器数据结构课程是计算机类专业的核心课程之一，是计算机科学与技术必修的专业基础课程。数据结构研究的范围和计算机软件有着密切的联系。课程涉及到大量的概念、定义以及数据结构的相关算法，具有一定的抽象性，尤其是树和图有较多的比较难理解的结构和算法。为了进一步展示算法运行过程中的动态性，题目要求利用图形可视化的方法，从数据结构的可视化和算法执行过程的可视化两个方面实现-一个可视化系统。
操原上机作业（二）
yin__ren的博客
04-16 4585
一、实验目的： （1）理解操作系统线程的概念和应用编程过程； （2）理解线程的同步概念和编程； 二、实验内容： （1）在Ubantu 或Fedora 环境使用fork函数创建一对父子进程，分别输出各自的进程号和提示信息串。 相关参考： 由 fork 创建的新进程被称为子进程。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进...
可视化算法加强记忆
sm_Bo的博客
10-18 1297
https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
IOS应用源码——房贷计算器改进.zip
10-14
3. **源码分析**：源码是软件的灵魂，阅读和理解源码能帮助我们了解应用的架构、数据结构、算法和逻辑流程。改进可能体现在更高效的计算方式、更友好的用户界面或者更全面的功能添加。 4. **版本控制**：源码改进...
单片机课程设计——计算器设计.doc
02-27
掌握应用程序开发环境，常用 的LCD显示器的使用方法和一般键盘的使用方法 此设计是基于单片机技术的简易计算器的方案，本次设计所提出的一种基于单片机技术 的简易计算器的方案，采用具有数据处理能力的中央处理器...
易语言模拟_计算器
07-23
本文将深入探讨“易语言模拟_计算器”的相关知识点，包括源码结构、模拟计算器的设计与实现，以及其中涉及的子程序——数字按钮和四则计算按钮。 首先，我们来看“易语言模拟_计算器”这个项目。这个项目的目标是...
数据结构C语言 模拟器
06-07
数据结构C语言 模拟器 里面有程序 可以直接模拟 并有详细解释
数据结构实现的计算器 C语言版
07-12
实现了小数，负数的计算；实现了括号加减乘除优先级；实现了开方，次方。 用了栈这种数据结构，点开直接运行 main.c 这个文件
数据结构Kruskal算法动态演示以及计算器可视化实现实验报告
07-03
Kruskal算法的动态演示以及计算器的实现一直是一个比较经典的问题，这里晒出来分享下
简单计算器的实现(数据结构)
02-28
和数据结构数上的要求一样.作业和课程设计的的要求都达到,有注西,包你满意(请下载修正版,解决关于括号问题.谢谢)
数据结构课设文件系统模拟器
08-22
内附详细课程设计文档，以及可运行代码，数据结构文件系统模拟器
一些实用的小网站、小工具、软件
热门推荐
想握住此生辽阔
07-10 1万+
免费在线画图工具：https://www.draw.io/ 在线听音乐：http://tool.liumingye.cn/music/?page=homePage
数据结构课设——计算器
m0_56144302的博客
07-07 2244
在实验-03、实验-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符&&、||、！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，能进行异常处理。
数据结构基础之计算器的实现
WUST_cws的博客
10-15 2839
对于数据结构初学者来说，带有优先级的计算器的实现是一个很头疼的问题，即使目前教材上上已经讲解得很详细，但依然难以难以形象的理解并通过编程实现计算器的功能。作者通过实践，运用栈，对带有‘*’、‘/’运的表达式和带有’)’、’)’的表达式进行化归，实现了此功能。
数据结构与算法课程设计--模拟简单计算器.docx
05-30
"数据结构与算法课程设计--模拟简单计算器.docx" 这篇文档涉及的是一个数据结构与算法的课程设计项目，目标是构建一个能够处理包含括号、加减乘除运算的简单计算器。该计算器需能处理不合法输入的检测，并能正确...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龍淵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值