用c语言编写的计算器源代码

作品：科学计算器

作者：欧宗龙

编写环境：vc++6.0

语言：c

#include "stdafx.h"

#include

#include

#include

#include "resource.h"

#include "MainDlg.h"

#include

#include

#define PI 3.141593

BOOL A_Op=FALSE;

BOOL WINAPI Main_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

switch(uMsg)

{

HANDLE_MSG(hWnd, WM_INITDIALOG, Main_OnInitDialog);

HANDLE_MSG(hWnd, WM_COMMAND, Main_OnCommand);

HANDLE_MSG(hWnd,WM_CLOSE, Main_OnClose);

}

return FALSE;

}

BOOL Main_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)

{

return TRUE;

}

void TrimNumber(char a[])//判断并删除小数点后无用的零

{

for(unsigned i=0;i

{

if(a[i]=='.')

{

for(unsigned j=strlen(a)-1;j>=i;j--)

{

if(a[j]=='0')

{

a[j]='\0';

}

else if(a[j]=='.')

{

a[j]='\0';

}

else break;

}

}

}

}

double Operate(char Operator,double n1,double n2) //判断符号，进行相应的运算{

if(Operator=='0')

{

}

if(Operator=='+')

{

n2+=n1;

}

if(Operator=='-')

{

n2=n1-n2;

}

if(Operator=='*')

{

n2*=n1;

}

if(Operator=='/')

{

n2=n1/n2;

}

if(Operator=='^')

{

n2=pow(n1,n2);

}

return n2;

}

////////////////////////

////////////////////////

void IntBinary(char a[],int n)

{

if(n>1)IntBinary(a,n/2);

sprintf(a,"%s%i",a,n%2);

}

void decimal(char a[],double m)

{

if(m>0.000001)

{

m=m*2;

sprintf(a,"%s%d",a,(long)m);

decimal(a,m-(long)m);

}

}

void Binary(char a[],double Num)

{

char DecP[256]="";

double x,y;

double *iptr=&y;

x=modf(Num,iptr);

decimal(DecP,x);

IntBinary(a,(int)y);

strcat(a,".");

strcat(a,DecP);

}

////////////////////////////////////

void Main_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)

{

static DELTIMES=0;

static char str[256];

static char Operator='0';

static double RNum[3];

switch(id)

{

case IDC_BUTTONN1://数字1

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"1");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN2://数字2

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"2");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN3://数字3

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"3");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN4://数字4

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"4");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN5://数字5

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"5");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN6://数字6

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"6");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN7://数字7

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"7");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN8://数字8

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"8");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN9://数字9

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"9");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONN0://数字0

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

strcat(str,"0");

SetDlgItemText(hwnd,IDC_EDIT,str);

RNum[1]=atof(str);

A_Op=FALSE;

}

break;

case IDC_BUTTONDEL://小数点.del

{

if(A_Op)

{

SetDlgItemText(hwnd,IDC_EDIT,NULL);

}

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

if(DELTIMES==0)

{

strcat(str,".");

}

DELTIMES++;

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=FALSE;

}

break;

case IDC_BUTTONADD: //加法运算

{

RNum[1]=atof(str);

RNum[0]=RNum[1];

RNum[1]=RNum[2];

RNum[2]=Operate(Operator,RNum[1],RNum[0]);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

Operator='+';

DELTIMES=0;

A_Op=TRUE;

}

break;

case IDC_BUTTONSUB: //减法运算

{

RNum[1]=atof(str);

RNum[0]=RNum[1];

RNum[1]=RNum[2];

RNum[2]=Operate(Operator,RNum[1],RNum[0]);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

DELTIMES=0;A_Op=TRUE;

Operator='-';

}

break;

case IDC_BUTTONMUL: //乘法运算

{

RNum[1]=atof(str);

RNum[0]=RNum[1];

RNum[1]=RNum[2];

RNum[2]=Operate(Operator,RNum[1],RNum[0]);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

Operator='*';

DELTIMES=0;

A_Op=TRUE;

}

break;

case IDC_BUTTONDIV: //除法运算

{

RNum[1]=atof(str);

RNum[0]=RNum[1];

RNum[1]=RNum[2];

RNum[2]=Operate(Operator,RNum[1],RNum[0]);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

Operator='/';

DELTIMES=0;

A_Op=TRUE;

}

break;

case IDC_BUTTONXY://x的y次方

{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[1]=atof(str);

RNum[0]=RNum[1];

RNum[1]=RNum[2];

RNum[2]=Operate(Operator,RNum[1],RNum[0]);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

Operator='^';

DELTIMES=0;

}

break;

case IDC_BUTTONPI: //圆周率PI，弧度

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

if(atof(str)!=0)

{

RNum[2]=atof(str)*PI;

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

}

else

{

sprintf(str,"%f",PI);

SetDlgItemText(hwnd,IDC_EDIT,str);

}

A_Op=TRUE;

}

break;

case IDC_BUTTONSQRT: //开根号

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=sqrt(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONSIN: //三角函数sin函数

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=sin(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONCOS://三角函数cos函数

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=cos(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONTAN://三角函数tan函数

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=tan(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONSQ: //平方

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=atof(str)*atof(str);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONCUBE://三次方

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=atof(str)*atof(str)*atof(str);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONEX://e的x次方

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=exp(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTON10X://10的x次方

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=pow(10,atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONLN: //ln x

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=log(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONLOG10: //log10

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=log10(atof(str));

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONBINARY: //十进制转换为二进制{

char a[256]="";

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[2]=atof(str);

Binary(a,RNum[2]);

strcpy(str,a);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

A_Op=TRUE;

}

break;

case IDC_BUTTONCLEAR://清除数据

{

DELTIMES=0;

Operator='0';

RNum[0]=RNum[1]=RNum[2]=0;

memset(str,0,sizeof(str));

SetDlgItemText(hwnd,IDC_EDIT,NULL);

A_Op=FALSE;

}

break;

case IDC_BUTTONBACKSPACE://退格键

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

int i=strlen(str);

str[i-1]='\0';

SetDlgItemText(hwnd,IDC_EDIT,str);

}

break;

case IDC_ENTER://Enter键

{

GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));

RNum[1]=atof(str);

RNum[0]=RNum[1];

RNum[1]=RNum[2];

RNum[2]=Operate(Operator,RNum[1],RNum[0]);

sprintf(str,"%f",RNum[2]);

TrimNumber(str);

SetDlgItemText(hwnd,IDC_EDIT,str);

Operator='0';

DELTIMES=0;

}

break;

default:

break;

}

}

void Main_OnClose(HWND hwnd)

{

EndDialog(hwnd, 0);

}

本人拙作，如有不足之处请谅解。

速算,简易计算器c语言代码,可实现加减乘除

#include"stdio.h" #include"math.h" #include"stdlib.h" struct optrstyle { int top; char stack[20]; } struct opndstyle { int top; int stack[20]; } void main() { char ch; while(1) { printf("-----------------------------------------\n"); printf("|-----------欢迎来到速算24--------------|\n"); printf("|----------是否开始游戏?????------------|\n"); printf("|--------- 开始游戏请按'Y'-------------|\n"); printf("|--------- 退出游戏请按其他键-------------|\n"); printf("-----------------------------------------\n"); scanf("%c",&ch); if(ch=='Y' or ch=='y') { } else break; } } int EvaluateExpression() { // 算术表达式求值的算符优先算法。设OPTR 和OPND 分别为运算符栈和运算数栈，OP 为运算符集合。 InitStack(OPTR); Push(OPTR,'#'); InitStack(OPND); c = getchar(); while(c!='#' || GetTop(OPTR)!='#') { if(!In(c,OP))

c语言计算器源代码

# include # include # include # define maxsize 100 typedef double datatype1; typedef char datatype2; typedef struct stack1 { datatype1 data1[maxsize]; int top1; /*栈顶元素*/ }seqstack1,*pseqstack1; /* 顺序栈*/ typedef struct stack2 { datatype2 data2[maxsize]; int top2; /*栈顶元素*/ }seqstack2,*pseqstack2; /* 顺序栈*/ /*栈的初始化*/ pseqstack1 init_seqstack1(void) { pseqstack1 S; S=(pseqstack1)malloc(sizeof(pseqstack1)); if(S) S->top1=-1; return S; } pseqstack2 init_seqstack2(void) { pseqstack2 S; S=(pseqstack2)malloc(sizeof(pseqstack2)); if(S) S->top2=-1; return S; } /*判断栈空*/ int empty_seqstack1(pseqstack1 S) { if(S->top1==-1) return 1; else return 0; } int empty_seqstack2(pseqstack2 S) { if(S->top2==-1)

C语言表达式计算器代码

#include #include #include typedef struct Expression //定义表达式结构体 { int num[64]; char ch[64]; }Exper; typedef struct node //定义字栈 { char e[100]; int top; }linkstack; typedef struct Node //定义整数栈 { int c[100]; int top; }link; char precede(char a,char b) //符号判断 { int i=0,j=0; char sign[]="+-*/()^%"; char prec[8][8]={">><<()<<",">><<()<<",">>>>()<<",">>>>()<<","((((~~((","))))~~))",">>>>()>>",">>>>()> >"}; if (b=='=') { return 0; } while(sign[i]!=a) { i++; } while (sign[j]!=b) { j++;

} return(prec[i][j]); } void push1(linkstack *p,char c) //字符入栈 { p->e[p->top++]=c; } void push2(link *p,int num) //整数入栈 { p->c[p->top++]=num; } char gettop(linkstack *s) //读字符栈顶的元素{ char c; c=s->e[s->top-1]; return(c); } char pop1(linkstack *s) //字符出栈 { char c; c=s->e[--s->top]; return(c); } int pop2(link *N) //整数入栈 { int num; num=N->c[--N->top]; return(num); } int operate(int a, char oper,int b)//进行运算 { int num; switch (oper) {

用C语言编写计算器

用c编写的，有各种检错的功能，用栈和优先级实现。头文件是：ss.h typedef union{float a;char b;} eletype; typedef struct{ eletype *base; eletype *top; int stacksize; }stack; stack * createStack(int); int isempty(stack *); int gettopStack(stack *,eletype *); int push(stack *,eletype); int pop(stack *,eletype *data); stack * createStack(int m) { stack *p; p=(stack *)malloc(sizeof(stack)); if(!p)return 0; p->base=(eletype *)malloc(m*sizeof(eletype)); if(!p->base)return 0; p->top=p->base; p->stacksize=m; return p; } int isempty(stack *lp) { if(lp->top > lp->base)return 0; else return 1; } int gettopStack(stack *lp,eletype *data) { while(isempty(lp))return 0; *data = *(lp->top - 1); return 1; }

int push(stack *lp,eletype data) { if(lp->top - lp->base >= lp->stacksize) { lp->base=(eletype *)realloc(lp->base,(lp->stacksize+1)*sizeof(eletype)); if(!lp->base)return 0; lp->stacksize++; } lp->top++; *(lp->top-1)=data; return 1; } int pop(stack *lp,eletype *data) { while(isempty(lp))return 0; *data = *(--lp->top); return 1; } Main函数的编写： #include "ss.h" #define SHU printf("fuck!! biao da shi cuowu!!!"); int n,x,y=0; float t=0; char c; char panduan(char,char); float yunsuan(float,char,float); int jiexi(char a[100]); float zhuan(char c[20]); main() { char a[100]; int m; char d,l; stack *optr; stack *open; eletype data; eletype * data1; char e[20]; float j,k;

C语言简单计算器实现四则运算可带括号

C语言简单计算器实现四则运算可带括号```c #include #include int priority(char op) if (op == '+' ， op == '-') return 1; else if (op == '*' ， op == '/') return 2; else if (op == '(') return 0; else return -1; void calculate(char op, int *numStack, int *top, char *opStack, int *opTop) int num2 = numStack[(*top)--]; int num1 = numStack[(*top)--]; switch (op) case '+':

numStack[++(*top)] = num1 + num2; break; case '-': numStack[++(*top)] = num1 - num2; break; case '*': numStack[++(*top)] = num1 * num2; break; case '/': numStack[++(*top)] = num1 / num2; break; } int eval(char *expr) int numStack[100]; char opStack[100]; int numTop = -1; int opTop = -1; int num = 0; int sign = 1;

while (*expr != '\0') if (*expr >= '0' && *expr <= '9') num = num * 10 + (*expr - '0'); } else if (*expr == '+' ， *expr == '-') numStack[++numTop] = num * sign; num = 0; sign = (*expr == '+') ? 1 : -1; } else if (*expr == '*' ， *expr == '/') while (opTop >= 0 && priority(*expr) <= priority(opStack[opTop])) calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop); } opStack[++opTop] = *expr; } else if (*expr == '(') opStack[++opTop] = '('; } else if (*expr == ')') while (opStack[opTop] != '(') calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);

用c语言编写的加减乘除计算器程序

#include<> double jjcc(double st[],int k){ for(int j=1;j47&&st1[i]<58){

sum1=(st1[i]-48)+sum1*10; i++; if(st1[i]=='.'){ i++; while(st1[i]>47&&st1[i]<58){ k=k*; sum2=(st1[i]-48)*k+sum2; i++; } } st2[c]=sum1+sum2; } else{ st2[++c]=st1[i]; i++; sum1=0; c++; } } printf("%.4f\n",jjcc(st2,c+1)); }

C语言编写的计算器源代码

C语言编写的计算器源代码 ```c #include #include #include #include #define MAX_EXPRESSION_SIZE 100 //栈结构定义 typedef struct int top; double data[MAX_EXPRESSION_SIZE]; } Stack; //初始化栈 void initStack(Stack *s) s->top = -1; //入栈 void push(Stack *s, double value) if (s->top == MAX_EXPRESSION_SIZE - 1) printf("Stack is full. Cannot push element.\n");

} else s->data[++(s->top)] = value; } //出栈 double pop(Stack *s) if (s->top == -1) printf("Stack is empty. Cannot pop element.\n"); return -1; } else return s->data[(s->top)--]; } //获取栈顶元素 double peek(Stack *s) if (s->top == -1) return -1; } else return s->data[s->top]; } //判断运算符的优先级

int getPriority(char operator) switch (operator) case '+': case '-': return 1; case '*': case '/': return 2; case '^': return 3; default: return -1; } //执行四则运算 double performOperation(double operand1, double operand2, char operator) switch (operator) case '+': return operand1 + operand2;

计算器源代码

#include #include #include using namespace std; const double pi = 3.14159265; const double e = 2.718281828459; const int SIZE = 1000; typedef struct node//为了处理符号而建立的链表(如: 1+(-2)) { char data; node *next; }node; typedef struct stack_num//存储数的栈 { double *top; double *base; }stack_num; typedef struct stack_char//存储运算符号的栈 { char *top; char *base; }stack_char; stack_num S_num;//定义 stack_char S_char;//定义 char fu[18] = {'\n', ')', '+', '-', '*', '/', '%', '^', 'Q', 'L', 'C', 'S', 'T', 'c', 's', 't', '('}; int compare[1000];//表现出各运算符号的优先级 double shu[1000];//存储"数" 的数组 double dai_result;//运算的结果，是为了处理M 运算(简介函数里有M的定义) int biao = 0;//和dia_result 一样，为了处理M 运算 char line[SIZE];//输入的所要计算的表达式 void init()//初始化 { compare[fu[0]] = -2;//用数字的大小表现出符号的优先级 compare[fu[1]] = -1; compare[fu[2]] = 2; compare[fu[3]] = 2; compare[fu[4]] = 4;

C语言计算器源代码

C++语言编写;; include include include using namespace std; const double pi = 3.; const double e = ; const int SIZE = 1000; typedef struct node { i++; ge = 0; biao_dian = 1; } iflinei == 'P' {

shu++p = pi; i++; break; } iflinei == 'E' { shu++p = e; i++; break; } ifflag1 { h = h 10 + linei - '0'; flag = 1; i++; ifbiao_dian

ge++; } else break; } ifflag { ifbiao_dian { int r = 1; forint k = 1; k <= ge; k++ r = 10; h /= r; } shu++p = h; + ^乘方 Foff Enter= "<

cout<<"M在前面结果的基础上继续计算,如：上次结果为10,现输入+2"<>start

C语言实现计算器功能

C语言实现计算器功能 计算机科学中的计算器功能是一个非常常见的问题。在C语言中，我们可以使用各种技术和算法来实现这个功能。在本文中，我将介绍一种简单的实现方法，该方法可以处理基本的四则运算。 首先，我们需要定义我们的计算器结构。在C语言中，我们可以使用结构来组织相关的数据和函数。我们可以定义一个名为 Calculator 的结构体，它包含两个浮点数类型的操作数和一个字符类型的操作符。 ```c typedef struct float operand1; float operand2; char operator; } Calculator; ``` 接下来，我们可以定义一些辅助函数来执行各种计算。我们可以使用switch 语句来根据操作符执行相应的操作。我们可以使用 scanf 函数来读取用户输入的操作数和操作符。 ```c float add(float operand1, float operand2) return operand1 + operand2;

float subtract(float operand1, float operand2) return operand1 - operand2; float multiply(float operand1, float operand2) return operand1 * operand2; float divide(float operand1, float operand2) return operand1 / operand2; void calculate(Calculator* calculator) switch(calculator->operator) case '+': printf("Result: %f\n", add(calculator->operand1, calculator->operand2)); break; case '-': printf("Result: %f\n", subtract(calculator->operand1, calculator->operand2)); break; case '*': printf("Result: %f\n", multiply(calculator->operand1, calculator->operand2)); break;

一元稀疏多项式计算器c语言

一元稀疏多项式计算器c语言 下面是一个使用C语言编写的一元稀疏多项式计算器的示例代码。```c #include #include //定义多项式的一个节点 typedef struct Node int coefficient; // 系数 int exponent; // 指数 struct Node* next; // 下一个节点 } Node; //创建一个节点 Node* createNode(int coefficient, int exponent) Node* newNode = (Node*)malloc(sizeof(Node)); newNode->coefficient = coefficient; newNode->exponent = exponent; newNode->next = NULL; return newNode; //插入节点到多项式中

Node* insertNode(Node* head, int coefficient, int exponent) Node* newNode = createNode(coefficient, exponent); if(head == NULL) return newNode; } else Node* temp = head; while(temp->next != NULL) temp = temp->next; } temp->next = newNode; return head; } //打印多项式 void printPolynomial(Node* head) Node* temp = head; while(temp != NULL) printf("%dx^%d ", temp->coefficient, temp->exponent); temp = temp->next; if(temp != NULL)

简易计算器C语言代码

简易四则运算计算器 计算机工具地历史而言，中国古代最早采用地一种计算工具叫筹策，又叫做算筹，这种算筹多用竹子制成，也有用木头，兽骨充当材料的，大约270枚一束，放在布袋里可随身携带。直到今天仍在使用的住算盘，是中国古代计算工具领域中的另一项发明明代时的住算盘已经与现代的住算盘几乎相同。 17世纪初，西方国家的计算工具有了较大的发展。英国数学家纳尔发现了“纳皮尔算筹”；英国牧师奥却德发明了圆柱形对数计算尺，这种计算尺不仅能做加减乘涂，乘方和开方运算，甚至可以计算三角函数，指数函数和对数函数。这些计算工具不仅带动了计算的发展，也为现代计算器发展尊定了良好的基础，成为现代社会应用广泛的计算工具，如手机，操作系统上附带的多功能计算器。 项目设计目的 掌握模块的划分； 掌握结构体定义； 掌握栈的操作； 掌握函数的定义； 掌握栈的基本操作； 掌握VC的基本绘图库； 掌握鼠标的响应操作； 目设计内容 设计一个含有界面的计算器，输入一个包含括号的表达式，使用栈数据类型实现整数的四则运算操作，开方运算。 项目设计要求 根据分析，系统要求实现以下几点基本功能： 可通过按钮输入数字、运算符； 能通过按钮实现退格、清除功能； 实现加、减、乘、除、开方运算功能； 实现括号运算； 显示运算结果； 良好的交互界面。

项目详细设计 功能模块图 根据系统功能要求，主要含有四大模块，分别是计算器界面设计模块、计算器按键控制模块、四则混合运算模块、计算器记忆处理模块。 计算器界面设计模块：调用VC图形系统函数和字符函数画出计算器的界面，包括24个按钮和一个文本输入框。 计算机按键控制模块：计算器通过键盘按键值的判断，执行相应的操作，如接收数字输入等。 计算器计算处理模块。计算处理模块主要完成可以包括括号的表达式运算，运算包括加，减，乘，除、开方。计算处理模块在按键控制模块中被调用执行。处理模块是通过栈来实现的，分别定义了两个顺序栈，一个用来存放操作符栈，一个用来存放操作数栈。 计算器记忆处理模块。记忆处理模块使计算其具有记忆功能。记忆当前输入的表达式，给出一个最后的运算结果。可以清楚部分或全部记忆的值。 图简易计算器模块图 数据结构简易计算器C语言代码.doc 该系统主要的数据有操作符集，用一维数组存放；存放操作符的优先级关系集，操作符的优先级关系用一个二维数组来体现；另外定义两个栈，一个用来存放操作符，一个用来存放操作数。 charops[7]={'+','-','*','/','(',')','#'}; intcmp[7][7]={ {2,2,1,1,1,2,2}, {2,2,1,1,1,2,2}, {2,2,2,2,1,2,2}, {2,2,2,2,1,2,2}, {1,1,1,1,1,3,0}, {2,2,2,2,0,2,2}, {1,1,1,1,1,0,3}}; typedefstruct { charelem[Stack_Size]; inttop; }SeqStack; typedefstruct { intelem[Stack_Size]; inttop; }SeqStackOperand;

用c语言编写的计算器源代码

作品：科学计算器 作者：欧宗龙 编写环境：vc++6.0 语言：c #include "stdafx.h" #include #include #include #include "resource.h" #include "MainDlg.h" #include #include #define PI 3.141593 BOOL A_Op=FALSE; BOOL WINAPI Main_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch(uMsg) { HANDLE_MSG(hWnd, WM_INITDIALOG, Main_OnInitDialog); HANDLE_MSG(hWnd, WM_MAND, Main_Onmand); HANDLE_MSG(hWnd,WM_CLOSE, Main_OnClose); } return FALSE; } BOOL Main_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam) { return TRUE; } void TrimNumber(char a[])//判断并删除小数点后无用的零

for(unsigned i=0;i=i;j--) { if(a[j]=='0') { a[j]='\0'; } else if(a[j]=='.') { a[j]='\0'; } else break; } } } } double Operate(char Operator,double n1,double n2) //判断符号，进行相应的运算{ if(Operator=='0') { } if(Operator=='+') { n2+=n1; } if(Operator=='-') { n2=n1-n2; } if(Operator=='*') { n2*=n1; } if(Operator=='/') { n2=n1/n2; } if(Operator=='^') { n2=pow(n1,n2); } return n2; }

C语言程序设计-简单的计算器

- - . "程序设计根底(C)"课程设计报告 简易计算器设计 学生姓名： 学号： 班级： 指导老师： 日期： 309工作室设计 目录 一、设计目标错误!未定义书签。 二、总体设计1 三、详细设计2 四、调试与测试3 五、分析及结论4 六、参考文献5 【附录】5 一、设计目标 设计一个C语言程序〔简单计算器设计〕 具体要求：在功能上功能尽量模拟windows操作系统中的计算器，系统界面不做强制要求。 主要功能：进展+、-、*、/、三角函数、对数、幂等各项数学运算，能够进展进制间的相互转换与计算。 二、总体设计 1、程序设计组成框图

2、设计思路 简单计算器的设计的程序中主要调用的函数有：数学函数的定义和I/O函数；设计思路和理念在于一切追求简便易操作原理，通过个人的构思和设计以及调试运行设计出这一款简单的计算器。 3、程序设计流程图 三、详细设计 1、功能函数① 函数的功能：两数的+、-、*、/计算、求平均 函数的入口：从main()的if(flag==1)开关构造中进入，即flag的值为1时进入该函数，从而进展该功能函数的计算。 函数调用关系：被主函数调用，由if()开关构造中进入。 函数的出口：函数的出口为printf("是否继续运算？(Y/N) :")，此时输入"Y〞，继续前面的构造。 2、功能函数② 函数的功能: *的y次方的计算、两数的求余、以*为底y的对数 函数的入口：从main()的if(flag==2)开关构造中进入，即flag的值为2时进入该函数，从而进展该功能函数的计算。 函数调用关系：被主函数调用，由if()开关构造中进入。 函数的出口：函数的出口为printf("是否继续运算？(Y/N) :")，此时输入"Y〞，继续前面的构造。 3、功能函数③ 函数的功能: 单个数值sin、cos、tan的计算，以e为底的指数、求绝对值 函数的入口：从main()的if(flag==3)开关构造中进入，即flag的值为3时进入该函数，从而进展该功能函数的计算。 函数调用关系：被主函数调用，由if()开关构造中进入。 函数的出口：函数的出口为printf("是否继续运算？(Y/N) :")，此时输入"Y〞，继续前面的构造 4、功能函数④ 函数的功能: 单个数值的ln值、以10为底的对数、取整、平方、立方计算 函数的入口：从main()的if(flag==4)开关构造中进入，即flag的值为4时进入该函数，从而进展该功能函数的计算。 函数调用关系：被主函数调用，由if()开关构造中进入。 函数的出口：函数的出口为printf("是否继续运算？(Y/N) :")，此时输入"Y〞，继续前面的构造 5、功能函数⑤

C语言计算器源代码

C语言计算器源代码 以下是一个简单的C语言计算器源代码，可以实现基本的四则运算。```c #include int mai char operator; double num1, num2; double result; printf("欢迎使用简单计算器！\n"); printf("请输入运算符(+, -, *, /): "); scanf("%c", &operator); printf("请输入第一个数字: "); scanf("%lf", &num1); printf("请输入第二个数字: "); scanf("%lf", &num2); switch (operator) case '+': result = num1 + num2; printf("结果: %.2lf\n", result);

break; case '-': result = num1 - num2; printf("结果: %.2lf\n", result); break; case '*': result = num1 * num2; printf("结果: %.2lf\n", result); break; case '/': if (num2 != 0) result = num1 / num2; printf("结果: %.2lf\n", result); } else printf("除数不能为0\n"); } break; default: printf("无效的运算符\n");

} return 0; ``` 运行代码后，程序会首先打印欢迎信息，并要求用户输入运算符、第 一个数字和第二个数字。之后，程序使用switch语句根据用户输入的运 算符执行相应的计算，并打印结果。如果用户输入的运算符不是"+", "-", "*", "/"之一，程序会打印"无效的运算符"的提示信息。 注意，这只是一个简单的计算器实现，没有进行输入的合法性校验， 例如对于数字的输入是否合法、输入的运算符是否合法等。在实际应用中，需要对输入进行合法性校验和错误处理。

单片机计算器c语言代码负数小数连续计算

单片机计算器c语言代码负数小数连续计算 单片机计算器是一种使用单片机作为核心控制器的计算器设备，可以实现基本的数学运算和复杂的科学计算。而本文将重点讨论在单片机计算器中如何处理负数和小数，并实现连续计算的功能。 在传统的单片机计算器中，一般使用定点数来表示和计算数值。定点数是一种固定小数点位置的数表示方法，对于整数和小数的处理方式有所不同。 对于负数的处理，可以使用补码表示法。补码是一种能够简化负数运算的数值表示方法，通过将负数的最高位设置为1，其余位取反再加1来表示负数。在单片机计算器中，可以使用有符号整数类型来表示负数，如int类型。在计算过程中，需要注意负数的加减运算，以及与正数的乘除运算。 对于小数的处理，由于单片机内部的运算是基于定点数的，因此需要将小数转化为定点数进行计算。可以选择将小数部分乘以一个固定的倍数，然后将其转化为整数进行运算。例如，可以选择将小数部分扩大100倍，然后将其转化为整数。在计算结果后，再将整数部分除以相应的倍数，得到最终的小数结果。 在实现连续计算的功能时，需要注意清零操作的时机。每次进行新的计算时，需要将之前的计算结果清零，以便进行新的运算。可以通过设置一个标志位来表示是否进行了清零操作，以便在下一次计

算时进行判断和处理。 在编写单片机计算器的C语言代码时，可以按照以下步骤进行： 1. 定义变量和标志位：包括表示数值的变量，表示是否进行了清零操作的标志位等。 2. 输入数值：可以通过键盘或者其他输入设备获取用户输入的数值。 3. 进行运算：根据用户输入的运算符，对数值进行相应的运算，包括加减乘除等。 4. 处理负数和小数：根据上述的处理方法，对负数和小数进行相应的转化和运算。 5. 输出结果：将计算结果输出到显示屏或者其他输出设备上。 6. 清零操作：根据用户的操作，判断是否需要进行清零操作，并相应地更新标志位。 通过以上步骤，就可以实现在单片机计算器中处理负数和小数，并实现连续计算的功能。在编写代码时，需要注意处理各种边界情况和异常情况，以保证计算的准确性和稳定性。 总结起来，本文介绍了在单片机计算器中处理负数和小数的方法，并讨论了实现连续计算的步骤和注意事项。通过合理的算法和代码

用c语言编写的加减乘除计算器程序

#include double jjcc(double st[],int k){ for(int j=1;j47&&st1[i]<58){

sum1=(st1[i]-48)+sum1*10; i++; if(st1[i]=='.'){ i++; while(st1[i]>47&&st1[i]<58){ k=k*0.1; sum2=(st1[i]-48)*k+sum2; i++; } } st2[c]=sum1+sum2; } else{ st2[++c]=st1[i]; i++; sum1=0; c++; } } printf("%.4f\n",jjcc(st2,c+1)); } 如有侵权请联系告知删除，感谢你们的配合！

关于计算器的c语言程序分析设计报告(简单的加减乘除)

关于计算器的程序分析设计报告 吕艺玮 1.问题描绘： 用C语言写出一个可以运行“+〞、“-〞、“*〞、“/〞、“%〞、“^〞的简易计算器，并且输入错误时可以报错。 2.问题分析： 首先定义变量，利用if选择构造来确定是否报错，用switch语句来执行运算，应注意除法除数不能为零，取余时变量应为整数，且除数不能为零。 3.算法设计：

4.实验结果及分析： 分析：1〕.注意switch的用法； 2〕.注意取余时应是整数取余； 3〕.注意除数不能为零。 5.结论：

得到两个数的加、减、乘、除、乘方以及整数的取余，但不能涉及到第三个数，是一个简易的计算器，有很多值得改进的地方。 6.附源码： #include #include int main () { float a,b; char k,s; int c,d; scanf ("%f%c%f%c",&a,&k,&b,&s); if (s=='=') switch (k) { case '+' :printf("%g\n",a+b);break; case '-' :printf("%g\n",a-b);break; case '*' :printf("%g\n",a*b);break; case '/' :if (b=='0') printf ("Error!\n"); else printf("%g\n",a/b);break; case '%' : if (b==0) printf ("Error!\n"); else c=(int)a;d=(int)b; printf("%d\n",c%d);break; case '^' :printf("%g\n",pow(a,b));break; default:printf("Error!\n"); } else printf ("Error!\n"); return 0; }