C语言写一个简单的计算器

最新推荐文章于 2024-03-02 21:04:51 发布
最新推荐文章于 2024-03-02 21:04:51 发布
阅读量282 收藏 1
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：https://my.oschina.net/u/3202498/blog/819040
版权

#include<stdio.h>
#include<stdlib.h>
struct num //定义结构体保存字符串之后化为数
{
    int a;
    int b;
    int ab[25];
};
struct node //定义链表节点
{
    int pd;//1：符号，2：数；
    double m;
    char sign;
    struct node *last;
    struct node *next;

};
struct node* deal_with(char a[]);
double array_change_num(struct num x);
double cif(int n);
void calculate_1(struct node *head);
void calculate(struct node *head);
int main()
{
    int i=0;
    char a[100];
    struct node *pHead;
    printf("*****************************\n");
    printf("*       这是一个计算器      *\n");
    printf("*****************************\n");
    while(1)
    {
        printf("请输入表达式，回车键结束：\n");
        gets(a);
        printf("=");
        pHead=deal_with(a);
        while(pHead->next!=NULL)
        {
            calculate(pHead);
        }
        printf("%f",pHead->m);
        printf("\n");
        free(pHead);
    }

    return 0;

}
double cif(int n)//求10的n次方
{
    double result=1.0;
    int i;
    for(i=0;i<n;i++)
    {
        result*=10.0;
    
    }
    return result;

}
struct node* deal_with(char a[])  //处理表达式
{
    int i=0;
    int j;
    int k;
    struct num temp;
    struct node *t;
    struct node *head;
    struct node *end;
    head=end=(struct node*)malloc(sizeof(struct node));                        
    while(a[i]!='\0')//遍历a[]中的每一个字符，创建双向链表
    {
        if(a[i]=='+'||a[i]=='-')
        {
            if(i==0)
                i++;
            else
            {
                if(a[i-1]=='(')
                    i++;
                else
                {
                    t=(struct node*)malloc(sizeof(struct node));
                    t->pd=1;
                    t->sign=a[i];
                    t->last=end;
                    end->next=t;
                    end=t;
                    i++;
                }
            
            
            }
        }
        else if(a[i]=='*'||a[i]=='/')
        {
            t=(struct node*)malloc(sizeof(struct node));
            t->pd=1;
            t->sign=a[i];
            t->last=end;
            end->next=t;
            end=t;
            i++;
        
        }
        else if(a[i]=='('||a[i]==')')
        {
            t=(struct node*)malloc(sizeof(struct node));
            t->pd=1;
            t->sign=a[i];
            t->last=end;
            end->next=t;
            end=t;
            i++;
        
        }
        else
        {
            temp.a=0;
            temp.b=0;
            for(j=0;j<25;j++)
                temp.ab[j]=0;
            k=0;               //k记录实数的位数
            
            while(a[i]!='('&&a[i]!=')'&&a[i]!='+'&&a[i]!='-'&&a[i]!='*'&&a[i]!='/'&&a[i]!='\0')
            {
                k++;
                i++;
            
            }

            for(j=i-k;j<i;j++)//计算实数整数位数
            {
                if(a[j]=='.')
                    break;
                temp.a++;
            }
            if(temp.a!=k)
                temp.b=k-temp.a-1;//小数位数
            else
                temp.b=0;
            for(j=i-k;j<i-k+temp.a;j++)
            {temp.ab[j-i+k]=a[j]-48;}
            for(j=i-k+temp.a+1;j<i;j++)
            {temp.ab[j-i+k-1]=a[j]-48;}

            t=(struct node*)malloc(sizeof(struct node));
            t->pd=2;
            t->sign='#';
            if((i-k)>1)
            {
                if(a[i-k-1]=='-')
                {
                    if(a[i-k-2]=='(')
                        t->m=-array_change_num(temp);
                    else 
                        t->m=array_change_num(temp);
                }
                else if(a[i-k-1]=='+')
                    t->m=array_change_num(temp);
                else if(a[i-k-1]=='*')
                    t->m=array_change_num(temp);
                else
                    t->m=array_change_num(temp);
            }
            else if(i-k==1)
            {
                if(a[0]=='-')
                    t->m=-array_change_num(temp);
                else
                    t->m=array_change_num(temp);

            }
            else
            t->m=array_change_num(temp);
            t->last=end;
            end->next=t;
            end=t;

        }
        
    
    }
    head=head->next;
    head->last=NULL;
    end->next=NULL;
    return head;
}

double array_change_num(struct num x)//结构体化为实数
{
    int i;
    int temp;
    double result=0;
    for(i=0;i<x.a;i++)
    {temp=x.ab[i];result+=(double)temp*cif(x.a-1-i);}
    for(i=0;i<x.b;i++)
    {temp=x.ab[x.a+i];result+=(double)temp/cif(i+1);}
    return result;

}
void calculate_1(struct node *head)//计算没有括号的表达式
{
    struct node *t,*result;
    t=head;    
    while(t->sign!='*'&&t->sign!='/'&&t->next!=NULL)
        t=t->next;        
    if(t!=NULL&&t->sign=='*')
    {
        if(t->last->last!=NULL)
        {
            result=(struct node*)malloc(sizeof(struct node ));
            result->pd=2;
            result->m=t->last->m*t->next->m;
            result->last=t->last->last;
            result->next=t->next->next;
            t->last->last->next=result;
            if(t->next->next!=NULL)
                t->next->next->last=result;
            free(t->last);
            free(t->next);
            free(t);

        }
        else
        {
            head->m=(t->last->m)*(t->next->m);
            head->next=t->next->next;
            if(t->next->next!=NULL)
                t->next->next->last=head;
            free(t->next);
            free(t);
        
        }
                
    }
    else if(t!=NULL&&t->sign=='/')
    {
        if(t->last->last!=NULL)
        {
            result=(struct node*)malloc(sizeof(struct node ));
            result->pd=2;
            result->m=(t->last->m)/(t->next->m);
            result->last=t->last->last;
            result->next=t->next->next;
            t->last->last->next=result;
            if(t->next->next!=NULL)
                t->next->next->last=result;
            free(t->last);
            free(t->next);
            free(t);    
        }
        else
        {
            head->m=t->last->m/t->next->m;
            head->next=t->next->next;
            if(t->next->next!=NULL)
                t->next->next->last=head;
            free(t->next);
            free(t);    
        }
    
    }
    else 
    {
        t=head;
        while(t->next!=NULL&&t->sign!='+'&&t->sign!='-')
        {
            t=t->next;        
        }
        if(t!=NULL&&t->sign=='+')
        {
            if(t->last->last!=NULL)
            {
                result=(struct node*)malloc(sizeof(struct node ));
                result->pd=2;
                result->m=(t->last->m)+(t->next->m);
                result->last=t->last->last;
                result->next=t->next->next;
                t->last->last->next=result;
                if(t->next->next!=NULL)
                    t->next->next->last=result;
                free(t->last);
                free(t->next);
                free(t);
            }
            else
            {
                head->m=t->last->m+t->next->m;
                head->next=t->next->next;
                if(t->next->next!=NULL)
                    t->next->next->last=head;
                free(t->next);
                free(t);
            }
        }

        else //if(t!=NULL&&t->sign=='-')
        {
            if(t->last->last!=NULL)
            {
                result=(struct node*)malloc(sizeof(struct node ));
                result->pd=2;
                result->m=(t->last->m)-(t->next->m);
                result->last=t->last->last;
                result->next=t->next->next;
                t->last->last->next=result;
                if(t->next->next!=NULL)
                    t->next->next->last=result;
                free(t->last);
                free(t->next);
                free(t);

            }
            else
            {
                head->m=t->last->m-t->next->m;
                head->next=t->next->next;
                if(t->next->next!=NULL)
                    t->next->next->last=head;
                free(t->next);
                free(t);
            }
        }
    
    }
    
    
}
void calculate(struct node *head)            //一般的表达式计算
{
    struct node *t1,*t2,*tHead;    
    t2=head;
    while(t2->next!=NULL&&t2->sign!=')')
        t2=t2->next;
    if(t2->sign==')')
    {
        t1=t2;
        while(t1->sign!='(')
            t1=t1->last;
        if(t1->last!=NULL)
        {
            tHead=t1->next;
            t2->last->next=NULL;
            tHead->last=NULL;
            while(tHead->next!=NULL)
            {
                calculate_1(tHead);
            }
            tHead->last=t1->last;
            t1->last->next=tHead;
            tHead->next=t2->next;
            if(t2->next!=NULL)
                t2->next->last=tHead;
            free(t1);
            free(t2);
        }
        else
        {
            
            tHead=head->next;
            tHead->last=NULL;
            t2->last->next=NULL;            
            if(t2->next!=NULL)
                t2->next->last=head;
            
            while(tHead->next!=NULL)
            {
                calculate_1(tHead);
            }
            head->pd=2;
            head->sign='#';
            head->next=t2->next;
            if(t2->next!=NULL)
                t2->next->last=head;
            head->m=tHead->m;
            free(tHead);
            free(t2);
        }
    }
    else
    {
        while(head->next!=NULL)
            calculate_1(head);    
    
    }
        
}

转载于:https://my.oschina.net/u/3202498/blog/819040

chibin0558
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言写的一个简单的计算器
小小世界
01-07 5万+
大学的第一学期就这样结束了。前阵子临近放假，不知道该干嘛，就分别用java和C语言写了两个东西。java写了个文件查找的程序。但是感觉搜索东西一多界面就会卡住很难看。就不分享了。C语言写了个简易的计算器。至于为什么写计算器~因为刚学C语言的时候，还没摸过VC，还没碰过编译器就看了几个简单的加减乘除的计算代码。然后就自己想了下，写了段自己认为正确。却不知道错误百出的代码，还发到了论坛。问别人对不对。
C语言写的一个简易计算器
ARRAYLI_博客
01-02 5615
#include #include #include float sum = 0;  //定义全局变量，可以求出每次运算后的结果； int count = 0;  //定义去全局变量计算所有操作的次数； //加法运算； void Add() { float num1=0, num2=0; float temp = 0;  //用来记录上一次计算后的值； printf("请输入要
C语言一个简易计算器程序
12-09
用C语言代码编写的一个简易计算器，可以实现加减乘除的功能！
使用C语言实现简单计算器
最新发布
2301_82247031的博客
03-02 5085
计算器是我们生活中很常用的工具，作为一个在学习编程语言的我们，也需要用代码来实现一个计算器的代码，我们就用C语言来实现一个进行计算两个数字的简单计算器：
C语言实现一个简单的计算器
05-10
使用C语言实现了一个简单的计算器,可以计算简单的公式,比如1+2+3*4/5
c语言制作简单的计算器
sjy的博客
08-24 3311
#include<stdio.h> #include<stdlib.h> #include<memory.h> char ch={0};//单个字符 int numarr[30];//存放最终计算的数字的数组 int num_i=0; int fn=0;//存放最终的结果 char tnsarr[30];//存放数字字符的临时字符串数组 int tnsa_i...
计算器怎么用c语言编程,如何用C语言编写简易的计算器
weixin_29443363的博客
05-22 1529
表达式计算建议看一下《数据结构》，先转换为逆波兰表达式，然后再计算。当然用字符串匹配也是可以的，但是这样复杂度会比较高，匹配最里面的括号有一个方法就是寻找第一个右括号，和这个右括号对应的左括号合起来就是最里面的括号。当然我给你一个逆波兰表达式的代码吧，可以解决你的问题，有点长，300多行：#include #include #include #include #define ElemItem ...
用C语言写一个计算器
热门推荐
微小冷的学习笔记
12-23 4万+
用C语言写一个计算器 用C语言写一个计算器，除了四则混合运算之外，还支持三角函数和绝对值等函数。 PS E:\Code\PL\calc> .\a.exe abs(3*5-4^2) abs(3*5-4^2)=1.000000 25-7+6*(4-5) 25-7+6*(4-5)=12.000000 文章目录用C语言写一个计算器1. 加减法运算2. 加法和乘法3. 四则混合运算4. 浮点型计算器程序5. 加入三角函数 在计算器中，至少包含两类变量，即数字和运算符。例如，如果希望实现a+b×(c−
c语言写一个简易计算器多个整型数据混合运算
10-23
C语言编写一个简易计算器可以进行多个整型数据的混合运算。 首先，我们需要定义几个整型变量来接收用户输入的数据，包括运算符和操作数。我们可以使用scanf函数来获取用户输入的数据。 接下来，我们可以使用switch...
用C语言写一个简易计算器
03-05
以下是一个简单的 C 语言计算器示例： #include int main() { char operator; double num1, num2; printf("请输入运算符 (+, -, *, /): "); scanf("%c", &operator); printf("请输入两个数字: "); scanf...
C语言程序设计实现简单计算器
04-13
加法：输入一个数，按“+”，输入被加数，按“=”，输出结果。  减法：输入一个数，按“—”，输入被减数，按“=”，输出结果。  乘法：输入一个数，按“*”，输入另外个数，按“=”，输出结果。  除法：输入一个数，按“/”，输入另外个数，按“=”，输出结果。  求开方：按“#”，在输入一个数，按“=”，输出结果。  求乘方：输入一个数，按“ ^”,输入另外个数，按“=”，输出结果。Tab键：清零  Q键：退出计算器界面
简易计算器(c语言课程设计）
07-25
简易计算器(c语言课程设计）简易计算器(c语言课程设计）简易计算器(c语言课程设计）简易计算器(c语言课程设计）简易计算器(c语言课程设计）
C语言计算器（带括号、小数计算）
12-20
C语言计算器可以计算 + - / * 连在一起的运算，可以计算各种括号的运算，支持小数计算。 例：-2*(((1+1)*(2+2)+3)+6) = -34
整数小数四则运算计算器(C语言版,用栈实现)
11-27
1、可以计算多位整数或者小数范围内的四则运算。。 2、C语言，通过入栈方式实现四则运算优先级顺序。。 3、用了两个栈实现，操作数栈和运算符栈，这一点不是很让人满意。。 4、具体实现方式可参考严蔚敏《数据结构》相应内容。。
C语言-一元稀疏多项式计算器
03-27
为了保存和加载多项式，可以设计一个简单的文本格式，如每行表示一个非零项，格式为"系数 指数"。使用`fscanf`和`fprintf`函数读写文件。 7. 错误处理和边界条件： 在实现过程中，确保处理各种边界条件，例如空...
用C语言写一个简易计算器的代码
03-21
以下是一个简单的计算器代码，使用C语言编写： #include int main() { char operator; double num1, num2; printf("请输入运算符 (+, -, *, /): "); scanf("%c", &operator); printf("请输入两个数字: ");...
51单片机 c语言小数计算器,求一个 89C51 简易计算器的c语言程序 只要加减乘除就行！...
weixin_39620845的博客
05-20 177
该楼层疑似违规已被系统折叠隐藏此楼查看此楼case 0x7b: dengyu=1; //key=11; //wei++; break; } while(temp!=0xf0) { temp=P3; temp=temp&0xf0; ...
【C语言】实现简易计算器
超烦豆先森
07-31 2万+
实现一个简易的计算器，可以计算两个整数的加减乘除。
用C实现一个计算器（带小数点和括号以及运算优先级）
qq_38076413的博客
06-13 1万+
/************************************************************************* 功能：利用栈结构做一个简易的计算器 描述：括号为最高优先级，其次乘除为次优先级，加减法的优先级最低 作者：566 ********************************************************************
用C语言写一个简易计算器代码
06-12
好的，以下是一个简单的计算器代码示例，可以进行加减乘除四则运算： ```c #include int main() { char operator; // 运算符 double num1, num2; // 操作数 printf("请输入运算符(+, -, *, /): "); scanf("%...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值