简单算术表达式计算器

最恨那些一点不珍惜别人劳动成果,问一两句就否定之类的老师,我也只能是呵呵呵呵呵。

说是什么没有按他说的那个什么破表写,然后看也不看就走了,呵呵呵呵

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#define max 100
using namespace std;//push(i) pop() top() empty()
class a_stack
{
   private:
    double donser[max];
    int length=0;
   public:
    void push_num(a_stack &l,double i);//入栈push
    void pop_num(a_stack &l);//出栈pop
    double top_num(a_stack &l);//返回栈顶数据top
    int check_empty(a_stack &l);//检查是否为空empty
};
class b_stack
{
   private:
    char donser1[max];
    int length1=0;
   public:
    void push_num(b_stack &l,char i);//入栈push
    void pop_num(b_stack &l);//出栈pop
    int top_num(b_stack &l);//返回栈顶数据top
    int check_empty(b_stack &l);//检查是否为空empty
};

void a_stack::push_num(a_stack &l,double i)
{
    int k;
    l.length++;
    k=l.length;
    l.donser[k]=i;
}

void a_stack::pop_num(a_stack &l)
{
    int k;
    k=l.length;
    l.length--;
    l.donser[k]=0;
}

double a_stack::top_num(a_stack &l)
{
    return l.donser[l.length];
}

int a_stack::check_empty(a_stack &l)//1为空
{
    if(l.length==0){return 1;}
    else return 0;
}

void b_stack::push_num(b_stack &l,char i)
{
    int k;
    l.length1++;
    k=l.length1;
    l.donser1[k]=i;
}

void b_stack::pop_num(b_stack &l)
{
    int k;
    k=l.length1;
    l.length1--;
    l.donser1[k]=0;
}

int b_stack::top_num(b_stack &l)
{
    return l.donser1[l.length1];
}

int b_stack::check_empty(b_stack &l)//1为空
{
    if(l.length1==0){return 1;}
    else return 0;
}

int i;
double a,b;
char s[250],c;
int main()
{
    cout<<"输入算式:";
    while(gets(s),strcmp(s,"#")!=0)
    {
        //stack<char>s1;
        //stack<double>s2;
        b_stack s1;
        a_stack s2;

        for(i=0;s[i];i++)
        {
            if(s[i]>=‘0‘&&s[i]<=‘9‘) //如果是数字继续找数字
            {
                a=0;
                while(s[i]>=‘0‘&&s[i]<=‘9‘)
                {
                    a=a*10+s[i]-‘0‘;
                    i++;
                }
                i--;
                s2.push_num(s2,a);
            }
            else if(s[i]==‘(‘) //如果(
            {
                s1.push_num(s1,s[i]);
            }
            else if(s[i]==‘)‘) //如果)
            {
                while(s1.top_num(s1)!=‘(‘)//找不到前括号就循环
                {
                    c=s1.top_num(s1);//符号top
                    s1.pop_num(s1);//删掉
                    a=s2.top_num(s2);//数字top
                    s2.pop_num(s2);//删掉
                    b=s2.top_num(s2);//当前数字top
                    s2.pop_num(s2);//删掉
                    if(c==‘+‘) a+=b;
                    if(c==‘-‘) a=b-a;
                    if(c==‘*‘) a=b*a;
                    if(c==‘/‘) a=b/a;
                    s2.push_num(s2,a);
                }
                s1.pop_num(s1);//删除前括号
                if(s1.check_empty(s1)==1){continue;}
                if(s1.top_num(s1)==‘*‘) //去掉括号以后栈还是乘
                {
                    s1.pop_num(s1);//删掉
                    a=s2.top_num(s2);//数字top
                    s2.pop_num(s2);//删掉
                    b=s2.top_num(s2);//当前数字top
                    s2.pop_num(s2);//删掉
                    a=b*a;
                    s2.push_num(s2,a);
                }
            }
            else if(s[i]==‘-‘||s[i]==‘+‘) //如果是+-
            {
                if(s1.check_empty(s1)==0&&s1.top_num(s1)!=‘(‘)//优先级低或者一样交换符号
                {
                    c=s1.top_num(s1);//字符栈顶
                    s1.pop_num(s1);//删掉
                    a=s2.top_num(s2);//数字栈顶1
                    s2.pop_num(s2);//删掉
                    b=s2.top_num(s2);//数字栈顶2
                    s2.pop_num(s2);//删掉
                    if(c==‘+‘) a+=b;
                    if(c==‘-‘) a=b-a;
                    if(c==‘*‘) a=b*a;
                    if(c==‘/‘) a=b/a;
                    s2.push_num(s2,a);//运算以后的入数字栈
                    s1.push_num(s1,s[i]);//字符入栈
                }
                else if(s1.check_empty(s1)==1||s1.top_num(s1)==‘(‘)//如果空或者前括号
                {
                    s1.push_num(s1,s[i]);//字符入栈
                }
            }
            else if(s[i]==‘/‘) //如果除
            {
                b=0;
                c=s[i];//存一下符号
                if(s1.check_empty(s1)==1||s1.top_num(s1)==‘(‘) //空就入栈不运算
                {
                    s1.push_num(s1,c);
                    continue;
                }
                i+=2;//找符号后面的数字
                while(s[i]>=‘0‘&&s[i]<=‘9‘)
                {
                    b=b*10+s[i]-‘0‘;
                    i++;
                }
                i--;//找到数字
                a=s2.top_num(s2);//取出数字栈顶
                s2.pop_num(s2);//删掉
                if(s1.top_num(s1)==‘*‘) //优先级一样交换符号
                {
                    a=a*b;
                    s1.pop_num(s1);//删除原来的
                    s1.push_num(s1,c);//换成新的
                }
                else a=a/b;//优先级高做除法
                s2.push_num(s2,a);//新数字入栈
            }
            else if(s[i]==‘*‘) //如果乘
            {
                b=0;
                c=s[i];
                if(s1.check_empty(s1)==1||s1.top_num(s1)==‘(‘)
                {
                    s1.push_num(s1,c);
                    continue;
                }
                i+=2;
                if(s[i]==‘(‘)
                {
                    s1.push_num(s1,c);
                    i--;
                    continue;
                }
                while(s[i]>=‘0‘&&s[i]<=‘9‘)
                {
                    b=b*10+s[i]-‘0‘;
                    i++;
                }
                i--;
                a=s2.top_num(s2);
                s2.pop_num(s2);
                if(s1.top_num(s1)==‘/‘)
                {
                    a=a/b;
                    s1.pop_num(s1);
                    s1.push_num(s1,c);
                }
                else if(s1.top_num(s1)!=‘/‘)
                {
                    a=a*b;
                }
                s2.push_num(s2,a);
            }

        }
        while(!s1.check_empty(s1))//如果符号栈非空就循环
        {
            c=s1.top_num(s1);//符号top
            s1.pop_num(s1);//删掉
            a=s2.top_num(s2);//数字top
            s2.pop_num(s2);//删掉
            b=s2.top_num(s2);//当前数字top
            s2.pop_num(s2);//删掉
            if(c==‘+‘) a+=b;
            if(c==‘-‘) a=b-a;
            if(c==‘*‘) a=b*a;
            if(c==‘/‘) a=b/a;
            s2.push_num(s2,a);
        }
        printf("%.2f\n",s2.top_num(s2));
    }
    return 0;
 }

手撸两个栈弄一下午也是够了

时间: 2024-08-02 21:02:50

简单算术表达式计算器的相关文章

简单算术表达式的求值程序

题目: 写一个三则运算(加减乘)表达式的求值程序,为了简化,规定数字只有一位,表达式内没有空格,但允许有括号.满足四则运算的结合性和优先级. 解答: 这是一道编译原理题,题目的要求把词法分析简单化了,只做语法分析.一般使用递归下降法求解. 首先写出BNF(包括结合性和优先权). exp → exp addop term | t e r m addop → + | - term → term mulop factor | f a c t o r mulop → * factor → ( exp )

简单算术表达式求值

#include <stdio.h> #include <string.h> int main() { int n,i; char a[200]; int f=0,l=0; gets(a); for(i=0;i<strlen(a);i++) { if(a[i]>='0'&&a[i]<='9')//如果是数字 { if(a[i+1]>='0'&&a[i+1]<='9')//如果后面那个也是数字 { f=(f+a[i]-48

Openjudge-计算概论(A)-简单算术表达式求值

描述: 两位正整数的简单算术运算(只考虑整数运算),算术运算为: +,加法运算:-,减法运算:*,乘法运算:/,整除运算:%,取余运算. 算术表达式的格式为(运算符前后可能有空格):运算数 运算符 运算数 请输出相应的结果. 输入一行算术表达式.输出整型算数运算的结果(结果值不一定为2位数,可能多于2位或少于2位). 样例输入 32+64 样例输出 96思路:使用字符串,从前往后扫,直至结束,把符号提出来,进行运算.注意:输入时一定要用gets(char)库函数,否则会报错的!代码如下: 1 #

编译器--简单数学表达式计算器

做了一个能够计算简单数学表达式值的小计算器,算不上是编译器,但用到了编译器的知识.最近在看一些编译器的东西,所以动手写这个最简单的计算器,既是对那些抽象的编译器知识有个形象的认识,也为后面添加复杂的东西--语句打下基础.此计算器是以<编译原理与实践>中实现的tiny编译器为参考写的,tiny是一个值得去研究的编译器,可以说是麻雀虽小,五脏俱全.从词法分析到代码生成都有,并且代码非常清晰易懂.我觉得想要了解编译器,可以从tiny入手,去将它跑起来并分析.废话不多说,开始记录这个小计算器. 先说下

Openjudge-NOI题库-简单算术表达式求值

题目描述 Description 两位正整数的简单算术运算(只考虑整数运算),算术运算为: +,加法运算:-,减法运算:*,乘法运算:/,整除运算:%,取余运算. 算术表达式的格式为(运算符前后可能有空格):运算数 运算符 运算数 请输出相应的结果. 输入输出格式 Input/output 输入: 一行算术表达式. 输出: 整型算数运算的结果(结果值不一定为2位数,可能多于2位或少于2位). 输入输出样例 Sample input/output 样例测试点#1 输入样例: 32+64 输出样例:

*1397简单算术表达式求值

1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 char a[20]; 5 using namespace std; 6 int js(int x,int y,char f) 7 { 8 switch(f) 9 { 10 case '+':cout<<x+y;break; 11 case '-':cout<<x-y;break; 12 case '*':cout<&

算法手记(2)Dijkstra双栈算术表达式求值算法

这两天看到的内容是关于栈和队列,在栈的模块发现了Dijkstra双栈算术表达式求值算法,可以用来实现计算器类型的app. 编程语言系统一般都内置了对算术表达式的处理,但是他们是如何在内部实现的呢?为了了解这个过程,我们可以自行搭建一套简易的算术表达式处理机制,这里就用到栈特性和本篇提到的Dijkstra算法. 概述:     算术表达式可能是一个数.或者是由一个左括号.一个算术表达式.一个运算符.另一个算术表达式和一个右括号组成的表达式.为了简化问题,这里定义的是未省略括号的算术表达式,它明确地

python实现算术表达式的词法语法语义分析(编译原理应用)

本学期编译原理的一个大作业,我的选题是算术表达式的词法语法语义分析,当时由于学得比较渣,只用了递归下降的方法进行了分析. 首先,用户输入算术表达式,其中算术表达式可以包含基本运算符,括号,数字,以及用户自定义变量. 词法分析,检查单词变量是否正确:语法分析,检查算术表达式语法是否正确并输出生成语法树:语义分析,输出四元表达式. 最终效果图: 例如输入: 词法分析结果: 语法分析结果: 语义分析结果: 算术表达式的组成语法如下: 无符号整数 = 〈数字〉{〈数字〉} 〈标识符〉= 〈字母〉{〈字母

【Scala编程】格式化算术表达式程序

格式化算术表达式程序 为了练习模式匹配的使用,该博文介绍编写格式化算术表达式的程序,最终的呈现结果如下面这个二维布局的数学表达式所示,这里除法运算被垂直打印出来: 1 - * (x + 1) 2 ----------- x 1.5 - + --- 2 x 为了实现这个程序,我们需要做一下工作: 1. 编写一个二维布局库来创建和渲染二维布局元素.这里主要应用Scala面向对象编程的一些方法,通过组合与继承来构建简单部件,进而实现库的设计. 2. 编写一个表达式的格式化类,利用二维布局库来渲染二维字