搜索
返回列表 发新帖
查看: 2788|回复: 13
打印 上一主题 下一主题

来个全部功能的计算器

[复制链接]
韩金选
跳转到指定楼层
楼主
发表于 2012-9-1 12:35:19 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
5啊哈币
难度比较高 身为初1的我不会

最佳答案

梦中的婚礼

查看完整内容

我只会一个加减乘的。 #include int main() { system ("color c"); printf("\n\n==========================================\n\n"); sleep(2000); printf("欢迎使用加减乘计算器。\n\n"); sleep(2000); printf("接下来请输入："); printf("\n"); int a,b,c; scanf("%d",&a); printf("请再次输入："); printf("\n"); scanf("%d",&b); c=a+b; printf(" ...
回复

举报

韩金选
来自 2#
 楼主| 发表于 2012-9-1 12:47:15 | 只看该作者
速度来个啊
回复

举报

韩金选
来自 3#
 楼主| 发表于 2012-9-1 17:20:42 | 只看该作者
给我速度加  速度
回复

举报

梦中的婚礼
地板
发表于 2012-9-1 12:35:20 | 只看该作者
我只会一个加减乘的。
#include <stdio.h>
int main()
{
    system ("color c");
    printf("\n\n==========================================\n\n");
    sleep(2000);
    printf("欢迎使用加减乘计算器。\n\n");
    sleep(2000);
    printf("接下来请输入：");
    printf("\n");
    int a,b,c;
    scanf("%d",&a);
    printf("请再次输入：");
    printf("\n");
    scanf("%d",&b);
    c=a+b;
    printf("和是%d\n\n",c);
    c=a*b;
    printf("积是%d\n\n",c);
    c=a-b;
    printf("差是%d\n\n",c);
    sleep(999999999999999999999999999999999999999999999999999999999999);
    return 0;
}


评分

参与人数 1啊哈币 +2 收起 理由
lzl + 2 神马都是浮云

查看全部评分

回复

举报

韩金选
5#
 楼主| 发表于 2012-9-1 16:26:50 | 只看该作者
速度啊我要哭了
回复

举报

韩金选
6#
 楼主| 发表于 2012-9-1 16:28:46 | 只看该作者
谁能给我解释一下啊？先谢谢了
回复

举报

凡夫俗子
7#
发表于 2012-9-6 08:03:14 来自手机 | 只看该作者
tom075395 发表于 2012-9-1 18:44:58
#include
int main()
{        
printf("早上好");
sleep(5000);
        return 0;
}

。。。来自: Android客户端
回复

举报

wkl
8#
发表于 2012-9-9 22:55:57 | 只看该作者
#include "evaluation.h"
002
#include "stack.h"
003
#include <stdio.h>
004
#define NULL 0
005
                      //运算符之间的关系
006
                      // +    -   *    /   (   )  \n
007
char relation[7][7] ={
008
                /* + */ {'>','>','<','<','<','>','>'},
009
                /* - */ {'>','>','<','<','<','>','>'},
010
                /* * */ {'>','>','>','>','<','>','>'},
011
                /* / */ {'>','>','>','>','<','>','>'},
012
                /* ( */ {'<','<','<','<','<','=',' '},
013
                /* ) */ {'>','>','>','>',' ','>','>'},
014
                /*\n*/  {'<','<','<','<','<',' ','='}
015
                    };
016
char OP[8] = {'+','-','*','/','(',')','\n'};
017
void menu()
018
{
019
    printf("===============================\n");
020
    printf("    [1]输入表达式并求值        \n");
021
    printf("    [2]退出                      \n");
022
    printf("===============================\n");
023
}
024
char Precede(char opnd,char c)
025
{
026
    int i = 0;
027
    int j = 0;
028
    switch(opnd)
029
    {
030
    case '+':
031
                i = 0;
032
                switch(c)
033
                {
034
                    case '+':
035
                            j = 0;
036
                            return relation[i][j];
037
                            break;
038
                    case '-':
039
                            j = 1;
040
                            return relation[i][j];
041
                            break;
042
                    case '*':
043
                            j = 2;
044
                            return relation[i][j];
045
                            break;
046
                    case '/':
047
                            j = 3;
048
                            return relation[i][j];
049
                            break;
050
                    case '(':
051
                            j = 4;
052
                            return relation[i][j];
053
                            break;
054
                    case ')':
055
                            j = 5;
056
                            return relation[i][j];
057
                            break;
058
                    case '\n':
059
                            j = 6;
060
                            return relation[i][j];
061
                            break;
062
                }
063
                break;
064
    case '-':
065
                i = 1;
066
                switch(c)
067
                {
068
                    case '+':
069
                            j = 0;
070
                            return relation[i][j];
071
                            break;
072
                    case '-':
073
                            j = 1;
074
                            return relation[i][j];
075
                            break;
076
                    case '*':
077
                            j = 2;
078
                            return relation[i][j];
079
                            break;
080
                    case '/':
081
                            j = 3;
082
                            return relation[i][j];
083
                            break;
084
                    case '(':
085
                            j = 4;
086
                            return relation[i][j];
087
                            break;
088
                    case ')':
089
                            j = 5;
090
                            return relation[i][j];
091
                            break;
092
                    case '\n':
093
                            j = 6;
094
                            return relation[i][j];
095
                            break;
096
                }
097
                break;
098
    case '*':
099
                i = 2;
100
                switch(c)
101
                {
102
                    case '+':
103
                            j = 0;
104
                            return relation[i][j];
105
                            break;
106
                    case '-':
107
                            j = 1;
108
                            return relation[i][j];
109
                            break;
110
                    case '*':
111
                            j = 2;
112
                            return relation[i][j];
113
                            break;
114
                    case '/':
115
                            j = 3;
116
                            return relation[i][j];
117
                            break;
118
                    case '(':
119
                            j = 4;
120
                            return relation[i][j];
121
                            break;
122
                    case ')':
123
                            j = 5;
124
                            return relation[i][j];
125
                            break;
126
                    case '\n':
127
                            j = 6;
128
                            return relation[i][j];
129
                            break;
130
                }
131
                break;
132
    case '/':
133
                i = 3;
134
                switch(c)
135
                {
136
                    case '+':
137
                            j = 0;
138
                            return relation[i][j];
139
                            break;
140
                    case '-':
141
                            j = 1;
142
                            return relation[i][j];
143
                            break;
144
                    case '*':
145
                            j = 2;
146
                            return relation[i][j];
147
                            break;
148
                    case '/':
149
                            j = 3;
150
                            return relation[i][j];
151
                            break;
152
                    case '(':
153
                            j = 4;
154
                            return relation[i][j];
155
                            break;
156
                    case ')':
157
                            j = 5;
158
                            return relation[i][j];
159
                            break;
160
                    case '\n':
161
                            j = 6;
162
                            return relation[i][j];
163
                            break;
164
                }
165
                break;
166
    case '(':
167
                i = 4;
168
                switch(c)
169
                {
170
                    case '+':
171
                            j = 0;
172
                            return relation[i][j];
173
                            break;
174
                    case '-':
175
                            j = 1;
176
                            return relation[i][j];
177
                            break;
178
                    case '*':
179
                            j = 2;
180
                            return relation[i][j];
181
                            break;
182
                    case '/':
183
                            j = 3;
184
                            return relation[i][j];
185
                            break;
186
                    case '(':
187
                            j = 4;
188
                            return relation[i][j];
189
                            break;
190
                    case ')':
191
                            j = 5;
192
                            return relation[i][j];
193
                            break;
194
                    case '\n':
195
                            j = 6;
196
                            return relation[i][j];
197
                            break;
198
                }
199
                break;
200
        case ')':
201
                i = 5;
202
                switch(c)
203
                {
204
                    case '+':
205
                            j = 0;
206
                            return relation[i][j];
207
                            break;
208
                    case '-':
209
                            j = 1;
210
                            return relation[i][j];
211
                            break;
212
                    case '*':
213
                            j = 2;
214
                            return relation[i][j];
215
                            break;
216
                    case '/':
217
                            j = 3;
218
                            return relation[i][j];
219
                            break;
220
                    case '(':
221
                            j = 4;
222
                            return relation[i][j];
223
                            break;
224
                    case ')':
225
                            j = 5;
226
                            return relation[i][j];
227
                            break;
228
                    case '\n':
229
                            j = 6;
230
                            return relation[i][j];
231
                            break;
232
                }
233
                break;
234
        case '\n':
235
                i = 6;
236
                switch(c)
237
                {
238
                    case '+':
239
                            j = 0;
240
                            return relation[i][j];
241
                            break;
242
                    case '-':
243
                            j = 1;
244
                            return relation[i][j];
245
                            break;
246
                    case '*':
247
                            j = 2;
248
                            return relation[i][j];
249
                            break;
250
                    case '/':
251
                            j = 3;
252
                            return relation[i][j];
253
                            break;
254
                    case '(':
255
                            j = 4;
256
                            return relation[i][j];
257
                            break;
258
                    case ')':
259
                            j = 5;
260
                            return relation[i][j];
261
                            break;
262
                    case '\n':
263
                            j = 6;
264
                            return relation[i][j];
265
                            break;
266
                }
267
                break;
268
        default :
269
                return NULL;
270
                break;
271
    }
272
    return NULL;
273
}
274
float Operator(float first,char theta,float second)
275
{
276
    switch(theta)
277
    {
278
        case '+':
279
            return first + second;
280
            break;
281
        case '-':
282
            return first - second;
283
            break;
284
        case '*':
285
            return first * second;
286
            break;
287
        case '/':
288
            return first / second;
289
            break;
290
        default:
291
            break;
292
    }
293
}
294
BOOL In(char c,char *OP)
295
{
296
    int i = 0;
297
    while(OP[i] != '\0')
298
    {
299
        if(OP[i] == c)
300
        {
301
            return 1;
302
        }
303
        i++;
304
    }
305
    return 0;
306
}
[文件] demo.cpp ~ 3KB    下载(123)
001
#include <stdio.h>
002
#include <stdlib.h>
003
#include "evaluation.h"
004
#include "stack.h"
005
int main()
006
{
007
    OpStack OPTR;               //运算符栈
008
    NumStack OPND;              //操作数栈
009
    char expression[40] = {0};  //保存表达式
010
    int i = 0;                  //操作数和运算符存储标志
011
    char c = 0;                 //接受用户的输入
012
    float opNum = 0;            //转换操作数
013
    int flag = 0;               //操作数是否进栈的标志位
014
    int printFlag = 0;          //控制操作数数组和操作符数组是否打印的标志位
015
    char e = 0;                 //接受出栈的值
016
    float a = 0;                //保存第一操作数
017
    float b = 0;                //保存第二操作数
018
    char theta = 0;             //保存运算符
019
    float result = 0;           //运算结果
020
    int QUIT = 1;               //判断是否推出的标志
021

022
    //初始化栈
023
    InitOpStack(&OPTR);
024
    InitNumStack(&OPND);
025

026
    //运算符栈先入栈'#'
027
    OpPush(&OPTR,'\n');
028

029
    menu();
030
    while(QUIT)
031
    {  
032
        printf("请输入你的选择(0~1)：");
033
        c = getchar();
034
        fflush(stdin);
035
        if(c == 49)
036
        {
037
            i = 0;
038
            printf("请输入你的表达式：\n");
039
            c = getchar();
040
            expression[i] = c;
041
            ++i;
042
            while(c != '\n' || OpGetTop(OPTR,&e) && e != '\n')
043
            {
044
                if(!In(c,OP))    //如否不是运算符就入操作数栈
045
                {  
046
                    if(opNum == 0)
047
                    {
048
                        opNum = (float)(c - 48);
049
                        c = getchar();
050
                        expression[i] = c;
051
                        ++i;
052
                        if(In(c,OP))
053
                            flag = 1;
054
                    }
055
                    else
056
                    {
057
                        opNum = opNum * 10 + (c - 48);
058
                        c = getchar();
059
                        expression[i] = c;
060
                        ++i;
061
                        if(In(c,OP))
062
                            flag = 1;
063
                    }
064
                    if(flag == 1)
065
                    {
066
                        NumPush(&OPND,opNum);
067
                        flag = 0;
068
                        opNum = 0;
069
                    }
070
                }
071
                else
072
                {
073
                    OpGetTop(OPTR,&e);
074
                    switch(Precede(e,c))
075
                    {
076
                        case '<':    //栈顶元素优先权低
077
                                OpPush(&OPTR,c);
078
                                c = getchar();
079
                                expression[i] = c;
080
                                ++i;
081
                                break;
082
                        case '=':   //去掉括号并接受下一个字符
083
                                OpPop(&OPTR,&e);
084
                                c = getchar();
085
                                expression[i] = c;
086
                                ++i;
087
                                break;
088
                        case '>':    //退栈并将运算结果入栈
089
                                OpPop(&OPTR,&theta);
090
                                NumPop(&OPND,&b);
091
                                NumPop(&OPND,&a);
092
                                NumPush(&OPND,Operator(a,theta,b));
093
                                break;
094
                        default:
095
                                break;
096
                    }
097
                }
098
            }
099
            for(int j = 0;expression[j] != '\n';j++ )
100
            {
101
                printf("%c",expression[j]);
102
            }
103
                printf(" %c ",'=');
104
                NumGetTop(OPND,&result);
105
                printf("%0.2f\n",result);
106
          }
107
       else if(c == 48)
108
       {
109
          break;
110
       }
111
       else
112
       {
113
           printf("输入错误！请重新输入！！\n");
114
       }
115
    }
116
    //system("PAUSE");
117
    return 0;
118
}
[文件] evaluation.h ~ 489B    下载(111)
01
#ifndef EVALUATION_H
02
#define EVALUATION_H
03
#define FALSE 0
04
#define TRUE 1
05
#define BOOL int
06

07
extern char relation[7][7];                                      //运算符关系数组
08
extern char OP[8];                                               //运算符数组
09
void menu();
10
char Precede(char opnd,char c);                                  //判断运算的优先级
11
float Operator(float first,char theta,float second);             //进行操作数之间的操作
12
BOOL In(char c,char *OP);                                        //判断输入的值是否运算符
13
#endif
[文件] stack.cpp ~ 2KB    下载(112)
001
#include <stdlib.h>
002
#include <malloc.h>
003
#include <memory.h>
004
#include <assert.h>
005
#include "stack.h"
006

007
const int STACK_INIT_SIZE = 100;    // 初始分配的长度
008
const int STACKINCREMENT  = 10;     // 分配内存的增量
009
BOOL InitNumStack(NumStack *S)
010
{
011
    S->base = (float *)malloc(STACK_INIT_SIZE *sizeof(float));
012
    if(S ->base == NULL)
013
        return FALSE;
014
    S ->top = S ->base;
015
    S->stacksize = STACK_INIT_SIZE;
016
    return TRUE;
017
}
018
void NumDestroyNumStack(NumStack *S)
019
{
020
    assert(S != NULL);
021
    free(S ->base);
022
    S->base = S->top = NULL;
023
}
024
BOOL NumGetTop(NumStack S, float *e)
025
{
026
    assert((S.base != NULL) && (S.top != NULL));
027
    if(S.top  == S.base)
028
        exit(0);
029
    *e = *(--S.top);
030
    return TRUE;
031
}
032
BOOL NumPush(NumStack *S, float e)
033
{
034
    if(S == NULL)
035
        return FALSE;
036
    assert((S->base != NULL) && (S ->top != NULL));
037
    if(S ->top - S ->base >= S->stacksize)
038
    {
039
        S ->base = (float *)realloc(S ->base,(S ->stacksize + STACKINCREMENT) * sizeof(float));
040
        if(! S ->base)
041
            exit(0);
042
        S ->top = S->base + S ->stacksize;
043
        S ->stacksize += STACKINCREMENT;
044
    }
045
    *(S ->top++) = e;
046
    return TRUE;
047
}
048
BOOL NumPop(NumStack *S, float *e)
049
{
050
    if((* S).top == (*S).base)
051
        return FALSE;
052
    *e = * --(* S).top;
053
    return TRUE;
054
}
055

056

057

058

059

060
BOOL InitOpStack(OpStack *S)
061
{
062
    S->base = (char *)malloc(STACK_INIT_SIZE *sizeof(char));
063
    if(S ->base == NULL)
064
        return FALSE;
065
    S ->top = S ->base;
066
    S->stacksize = STACK_INIT_SIZE;
067
    return TRUE;
068
}
069
void OpDestroyOpStack(OpStack *S)
070
{
071
    assert(S != NULL);
072
    free(S ->base);
073
    S->base = S->top = NULL;
074
}
075
BOOL OpGetTop(OpStack S,char*e)
076
{
077
    assert((S.base != NULL) && (S.top != NULL));
078
    if(S.top  == S.base)
079
        exit(0);
080
    *e = *(--S.top);
081
    return TRUE;
082
}
083
BOOL OpPush(OpStack *S,char e)
084
{
085
    if(S == NULL)
086
        return FALSE;
087
    assert((S->base != NULL) && (S ->top != NULL));
088
    if(S ->top - S ->base >= S->stacksize)
089
    {
090
        S ->base = (char *)realloc(S ->base,(S ->stacksize + STACKINCREMENT) * sizeof(char));
091
        if(! S ->base)
092
            exit(0);
093
        S ->top = S->base + S ->stacksize;
094
        S ->stacksize += STACKINCREMENT;
095
    }
096
    *(S ->top++) = e;
097
    return TRUE;
098
}
099
BOOL OpPop(OpStack *S,char *e)
100
{
101
    if((* S).top == (*S).base)
102
        return FALSE;
103
    *e = * --(* S).top;
104
    return TRUE;
105
}
[文件] stack.h ~ 777B    下载(110)
01
#ifndef STACK_H
02
#define STACK_H
03
#define FALSE 0
04
#define TRUE 1
05
#define BOOL int
06
/*
07
* 栈结构的定义
08
*/
09

10

11
/*
12
*操作数栈
13
*/
14
typedef struct NumStack
15
{
16
    float *base;
17
    float *top;
18
    int stacksize;
19
}NumStack;
20
/*
21
*操作符栈
22
*/
23
typedef struct OpStack
24
{
25
    char *base;
26
    char *top;
27
    int stacksize;
28
}OpStack;
29
/*
30
*操作数栈的基本操作
31
*/
32
BOOL InitNumStack(NumStack *S);
33
void NumDestroyNumStack(NumStack *S);
34
BOOL NumGetTop(NumStack S,float *e);
35
BOOL NumPush(NumStack *S,float e);
36
BOOL NumPop(NumStack *S,float *e);
37
/*
38
*操作符栈的基本操作
39
*/
40
BOOL InitOpStack(OpStack *S);
41
void OpDestroyOpStack(OpStack *S);
42
BOOL OpGetTop(OpStack S,char*e);
43
BOOL OpPush(OpStack *S,char e);
44
BOOL OpPop(OpStack *S,char *e);
45
#endif

评分

参与人数 1啊哈币 +3 收起 理由
lzl + 3 神马都是浮云

查看全部评分

回复

举报

wkl
9#
发表于 2012-9-9 22:59:22 | 只看该作者
来自开源中国社区，楼主那里自己搜吧，我不能发链接
回复

举报

4k-Rn
10#
发表于 2012-12-24 21:09:06 | 只看该作者
[mw_shl_code=c,true]#include <stdio.h>
#include <math.h>
int main()
{
    system ("color c");
        int a,b,c,d,e,f;
      double i,m;
      long double o,p,q;
      char k;
      const double pi=3.141592;
    printf("==========================================\n");
    printf("欢迎使用计算器。\n\n");
    printf("(a是关于三角函数与双曲三角函数,x）输入a：");
    scanf("%d",&a);
    printf("(b是关于反三角函数,对数,e为底指数,y)输入b：");
    scanf("%d",&b);
    printf("输入底数：\t");
    scanf("%d",&c);
    printf("输入指数：\t");
    scanf("%d",&d);
    printf("输入根：\t");
    scanf("%lf",&i);
    e=a+b;
    printf("和是%d\t",e);
    e=a*b;
    printf("积是%d\t",e);
    e=a-b;
    printf("差是%d\t",e);
    e=a/b;
    printf("商是%d\n",e);
    e = pow(c, d);
    printf("乘方是%d\t\t\t",e);
    printf("二次根是%lf\n",sqrt(i));
    m=sin(a*pi/180);
    printf("sin正弦是%lf\t",m);
    m=sinh(a);
    printf("sinh双曲正弦是%lf\t",m);
    m=cos(a);
    printf("asin反正弦是%lf\t\n",m);
    m=acos(a);
    printf("cos余弦是%lf\t",m);
    m=cosh(a);
    printf("cosh双曲余弦是%lf\t",m);
    m=tan(a);
    printf("acos反余弦是%lf\t\n",m);
    m=atan(a);
    printf("tan正切是%lf\t",m);
    m=tanh(a);
    printf("tanh双曲正切是%lf\t",m);
    m=asin(a);
    printf("atan反正切（主值）是%lf\t",m);
    m = log10(b);
    printf("常用对数为：%lf\t",m);
    m = log(exp(b));
    printf("e为底指数为：%lf\t",m);
    m = hypot(a,b);
    printf("第三条边为：%lf\t",m);
    printf("\t\t\t-------备注-------\n");
    scanf("%s",k);
    return 0;
}[/mw_shl_code]
回复

举报

4399APPLE
11#
发表于 2013-10-8 10:24:47 | 只看该作者
这个行吗
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main()
  4. {
  5.         int a,b;
  6.     char c;
  7.     printf("欢迎使用此计算机！制作：梁浩奋\n");
  8.     printf("请输入您需要算的算式(输入完毕请按回车键)\n");
  9.     printf("----------------------------------------\n");
  10.     while(1)
  11.     {
  12.                 printf("在此输入：");
  13.                 scanf("%d%c%d",&a,&c,&b);
  14.                 if(c=='+')
  15.                         printf("它们的和是%d\n",a+b);
  16.                 if(c=='-')
  17.                         printf("它们的差是%d\n",a-b);
  18.                 if(c=='*')
  19.                         printf("它们的积是%d\n",a*b);
  20.                 if(c=='/' && b!=0)
  21.                         printf("它们的商是%d\n",a/b);
  22.         if(c=='/' && b==0)
  23.                         printf("除数不能是零\n");
  24.         if(c!='+' && c!='-' && c!='*' && c!='/')
  25.                         printf("输入有误!\n");
  26.     }
  27.         system("pause");
  28.         return 0;
  29. }
复制代码
回复

举报

4399APPLE
12#
发表于 2013-10-31 11:27:57 | 只看该作者
好啦好啦，说正经事，这个应该行

多功能计算机.c

9.62 KB, 下载次数: 338

点评

1935515130
好了好了，你的计算器比我厉害。但是漏洞太多了  发表于 2014-3-14 21:24
回复

举报

1935515130
13#
发表于 2014-3-14 21:20:45 | 只看该作者
万能计算器.exe
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

广播台
特别关注
阿哈王国（武汉）教育科技有限公司©2018      鄂ICP备17029633号-1
AhaKingdom (Wuhan) Education & Technology Co., Ltd.
快速回复 返回顶部 返回列表