c++ c语言 简单的四则运算

c语⾔实现简单四则运算c语⾔实现简单四则运算⼀、项⽬开始⼆、阅读代码1、参考代码使⽤了随机函数：srand(unsigned( time(NULL)));通过调⽤随机函数，将⽣成的100以内的随机整数赋给不同的变量，⼀部分⽤于四则运算式数据的来源，⽽赋给变量c的随机数则⽤于结合switch语句控制程序跳转执⾏不同的分⽀，即不同的四则运算，如下：c = rand() % 5; //随机产⽣⼩于5的⾮负整数switch (c)case 0:case 1:...........case 5:2、使⽤while语句控制除数不为0while (b == 0){b = rand() % 1; //若b=0则重新⽣成b，直到b不为0}3、使⽤if语句判断减数与被减数的⼤⼩if (a > b) //使a<b{d = a;a = b;b = d;}if (m > n) //使m<n{d = m;m = n;n = d;}通过if判断并赋值的⼿段保证结果不出现负数4、原代码仅能⼀次性⽣成20个随机的四则运算式，⽽⽆法从键盘输⼊结果并判断答案正确与否。

三、修改代码由于原代码⽆法从键盘读⼊数据，所以对其进⾏了改进。

1、增加键盘读⼊功能scanf("%d",&x);从键盘读⼊输⼊的答案2、对答案进⾏正确与否的判断if(x == (a+b))printf("You are right!\n");elseprintf("You are wrong!\n");通过⽐较输⼊答案与运算得出的答案告知⽤户计算是否正确。

四、代码托管路劲五、个⼈总结通过阅读与修改代码，实现了⾃⼰想要的功能，同时也增强了⾃⼰的动⼿能⼒。

在这个过程中，体会到程序编写的乐趣，当然也伴随有挫败感，但是，当看到程序输出了⾃⼰想要的结果的时候，却也有⼀种由衷的成就感。

同时也认识到，程序的规则是死的，是严格定义的，只要花时间总是能掌握的，因此不必有太多的畏惧之⼼。

四则运算c语言编程四则运算是数学中常见的基本运算，也是编程语言中必须掌握的基本知识。

在C语言中，四则运算包括加、减、乘、除四个基本运算。

本文将介绍C语言中四则运算的使用方法和注意事项。

加法运算加法运算是最基本的运算之一，C语言中使用“+”符号进行加法运算。

例如，计算两个整数a和b的和，可以使用以下代码：int a = 5;int b = 3;int sum = a + b;printf("sum = %d\n", sum);在这个例子中，首先定义了两个整数a和b，并将它们相加得到sum变量的值。

最后使用printf函数将sum的值输出到屏幕上。

减法运算减法运算也是常见的运算之一，C语言中使用“-”符号进行减法运算。

例如，计算两个整数a和b的差，可以使用以下代码：int a = 5;int b = 3;int diff = a - b;printf("diff = %d\n", diff);在这个例子中，首先定义了两个整数a和b，并将它们相减得到diff变量的值。

最后使用printf函数将diff的值输出到屏幕上。

乘法运算乘法运算也是常见的运算之一，C语言中使用“*”符号进行乘法运算。

例如，计算两个整数a和b的积，可以使用以下代码：int a = 5;int b = 3;int product = a * b;printf("product = %d\n", product);在这个例子中，首先定义了两个整数a和b，并将它们相乘得到product变量的值。

最后使用printf函数将product的值输出到屏幕上。

除法运算除法运算也是常见的运算之一，C语言中使用“/”符号进行除法运算。

例如，计算两个整数a和b的商，可以使用以下代码：int a = 5;int b = 3;int quotient = a / b;printf("quotient = %d\n", quotient);在这个例子中，首先定义了两个整数a和b，并将它们相除得到quotient变量的值。

用c语言编写加减乘除程序加减乘除是数学上最基本的四则运算，而用计算机语言实现这些运算则是计算机科学最基本的知识之一。

在c语言中，实现四则运算需要使用基本的算术运算符，并需要注意数据类型的匹配。

加法运算是最简单的四则运算之一，使用c语言执行加法运算的方法是，用“+”符号分隔两个运算数并用“=”符号赋值给结果变量。

例如，将两个整数相加并输出结果，代码如下：```#include <stdio.h>int main(){int a = 5, b = 7, sum;sum = a + b;printf("The sum of %d and %d is %d", a, b, sum);}```这段代码将输出结果：“The sum of 5 and 7 is 12”，其中sum 变量存储了a和b两个变量的和。

减法运算的实现方法与加法运算类似，只需将运算符改为“-”即可，例如：```#include <stdio.h>int main(){int a = 5, b = 7, diff;diff = a - b;printf("The difference between %d and %d is %d", a, b, diff);}```这段代码将输出结果：“The difference between 5 and 7 is -2”，其中diff变量存储了a和b两个变量的差。

乘法运算可以使用“*”符号来实现，例如：```#include <stdio.h>int main(){int a = 5, b = 7, prod;prod = a * b;printf("The product of %d and %d is %d", a, b, prod);return 0;```这段代码将输出结果：“The product of 5 and 7 is 35”，其中prod变量存储了a和b两个变量的积。

c选择语句四则运算C语言中的选择语句可以用来实现四则运算。

下面列举了十个例子，每个例子都包含了一个不同的四则运算操作。

1. 加法运算：```int a = 10;int b = 5;int result = a + b;printf("10 + 5 = %d\n", result);```2. 减法运算：```int a = 10;int b = 5;int result = a - b;printf("10 - 5 = %d\n", result);```3. 乘法运算：```int a = 10;int result = a * b;printf("10 * 5 = %d\n", result); ```4. 除法运算：```int a = 10;int b = 5;int result = a / b;printf("10 / 5 = %d\n", result); ```5. 求余运算：```int a = 10;int b = 5;int result = a % b;printf("10 %% 5 = %d\n", result); ```6. 复合运算符（加法和赋值）：```int b = 5;a += b;printf("a += b，a的值为：%d\n", a); ```7. 前置递增运算符：```int a = 10;int result = ++a;printf("++a的值为：%d\n", result); ```8. 后置递增运算符：```int a = 10;int result = a++;printf("a++的值为：%d\n", result); ```9. 条件运算符（三元运算符）：```int a = 10;int result = (a > b) ? a : b;printf("较大的数为：%d\n", result);```10. 逻辑与运算符：```int a = 10;int b = 5;if (a > 0 && b > 0) {printf("a和b都大于0\n");} else {printf("a和b不都大于0\n");}```以上是十个例子，每个例子都涉及到了不同的四则运算操作，通过选择语句可以实现不同的运算结果。

c语言四则运算程序C语言是一种通用的计算机程序设计语言，用于开发软件和操作系统等工程项目。

C语言的语法简洁，可以编写出高效的代码，因此在编写四则运算程序中被广泛应用。

四则运算指的是加减乘除四种基本运算。

在C语言中，可以使用基本的算术运算符来进行四则运算，例如“+”表示加法，“-”表示减法，“*”表示乘法，“/”表示除法。

在程序中使用scanf函数获取用户输入的数字，然后通过计算输出运算结果。

下面展示一个简单的加法程序，用户输入两个数字，程序通过相加运算输出结果：#include<stdio.h>int main(){int a,b,c;printf("Please enter two numbers:");scanf("%d %d",&a,&b);c=a+b;printf("%d + %d = %d\n",a,b,c);return 0;}以上程序展示了如何使用scanf函数获取用户的输入。

scanf函数的第一个参数是格式化字符串，指定要读取的类型及其数量，例如“%d”表示整数，“%f”表示浮点数。

第二个参数是存储输入值的变量名或指针，它们必须与格式化字符串中要读取的类型相匹配。

当用户输入两个整数后，程序将它们相加并输出结果。

输出语句中使用了占位符“%d”，它们对应的是printf函数中的后三个参数，分别是a,b,c的值。

除了加法，减法、乘法、除法的处理也很相似。

下面展示一个利用switch语句实现四则运算的程序：#include<stdio.h>int main(){int a,b,c;char op;printf("Please enter two numbers:");scanf("%d %d",&a,&b);printf("Please enter the operator:");scanf(" %c",&op);switch(op){case '+': c=a+b;break;case '-': c=a-b;break;case '*': c=a*b;break;case '/': c=a/b;break;default: printf("Invalid operator!");return1;break;}printf("%d %c %d = %d\n",a,op,b,c);return 0;}这个程序通过switch语句根据输入的运算符选择相应的操作。

大一c语言编程四则运算在学习C语言过程中，四则运算是我们最常接触的基础知识之一。

四则运算包括加、减、乘、除四种基本运算，本文将以大一C语言编程四则运算为主题，详细介绍四则运算的实现方法和注意点。

一、加法运算加法运算是最简单的运算之一，只需要使用“+”符号即可实现。

例如，将两个整数a和b相加，可以使用以下代码实现：int a = 10;int b = 20;int c = a + b;其中，a和b为要相加的两个整数，c为保存结果的变量。

二、减法运算减法运算与加法运算类似，只需要使用“-”符号即可实现。

例如，将两个整数a和b相减，可以使用以下代码实现：int a = 20;int b = 10;int c = a - b;其中，a和b为要相减的两个整数，c为保存结果的变量。

三、乘法运算乘法运算需要使用“*”符号。

例如，将两个整数a和b相乘，可以使用以下代码实现：int a = 10;int b = 20;int c = a * b;其中，a和b为要相乘的两个整数，c为保存结果的变量。

需要注意的是，如果a和b中有一个是浮点数，那么结果也会是浮点数。

四、除法运算除法运算需要使用“/”符号。

例如，将两个整数a和b相除，可以使用以下代码实现：int a = 20;int b = 10;int c = a / b;其中，a和b为要相除的两个整数，c为保存结果的变量。

需要注意的是，如果a和b中有一个是浮点数，那么结果也会是浮点数。

此外，如果b为0，程序将会出现除0错误。

五、复合运算除了基本的四则运算外，还有一些复合运算，例如加等于和减等于运算。

例如，将变量a加上10，可以使用以下代码实现：int a = 10;a += 10;其中，a += 10等价于a = a + 10。

减等于运算同理。

六、小数运算除了整数运算外，C语言还支持小数运算。

小数运算需要使用浮点型变量，例如：float a = 1.23;float b = 4.56;float c = a + b;其中，a和b为要相加的两个浮点数，c为保存结果的变量。

C语言编写四则运算#include<stdio.h>//计算器#include<malloc.h>#define STACK_SIZE100 //max size of the stack#define STACK_INCREMENT10 //realloc sizetypedef struct FStack//stack of int{float* base;float* top;int stacksize;}FStack;void Init(FStack* s){s->base = (float*)malloc(STACK_SIZE * sizeof(FStack));if (!s->base){printf("overflow!\n");return;}s->top = s->base;s->stacksize = STACK_SIZE;}bool isEmpty(FStack* s){if (s->top == s->base){return true;}else{return false;}}void Push(FStack* s, float e){if (s->top - s->base >= s->stacksize){printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);s->base = (float*)realloc(s->base, (s->stacksize +sizeof(FStack)));if (!s->base){printf("overflow!\n");return;}s->top = s->base + s->stacksize;s->stacksize += STACK_INCREMENT;}*(s->top) = e;(s->top)++;}float GetTop(FStack* s){if (s->top == s->base){printf("stack is empty!\n");return 0;}float e = *(s->top - 1);return e;}void Pop(FStack* s){if (s->top == s->base){printf("stack is empty!\n");return;}s->top--;}typedef struct CStack//stack of char{char* base;char* top;int stacksize;}CStack;void Init(CStack* s){s->base = (char*)malloc(STACK_SIZE * sizeof(CStack));if (!s->base){printf("overflow!\n");return;}s->top = s->base;s->stacksize = STACK_SIZE;}bool isEmpty(CStack* s){if (s->top == s->base){return true;}else{return false;}}void Push(CStack* s, int e){if (s->top - s->base >= s->stacksize){printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);s->base = (char*)realloc(s->base, (s->stacksize +sizeof(CStack)));if (!s->base){printf("overflow!\n");return;}s->top = s->base + s->stacksize;s->stacksize += STACK_INCREMENT;}*(s->top) = e;(s->top)++;}char GetTop(CStack* s){if (s->top == s->base){printf("stack is empty!\n");return 0;}char e = *(s->top - 1);return e;}void Pop(CStack* s){if (s->top == s->base){printf("stack is empty!\n");return;}s->top--;}bool isOper(char ch){if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%') {return true;}else{return false;}}int Priority(char ch){int p;switch(ch){case'(':p = 0;break;case'+':case'-':p = 1;break;case'*':case'/':case'%':p = 2;break;}return p;}float Calculate(float f1, float f2, char oper) {float f3;switch(oper){case'+':f3 = f1 + f2;break;case'-':f3 = f1 - f2;break;case'*':f3 = f1 * f2;break;case'%':f3 = (float)((int)f1 % (int)f2);break;case'/':if (f2 == 0){printf("\nDevided by zero!");exit(1);}else{f3 = f1 / f2;}break;}return f3;}float StrtoFloat(char* str, int* pos){float fRes;int i = *pos;int k;char n[50];for(k= 0; str[i] >= '0'&& str[i] <= '9'|| str[i] == '.'; i++, k++) {n[k] = str[i];}n[k] = '\0';*pos = i;fRes = atof(n);return fRes;}bool Check(char* str){int i = 0;while (str[i] != '\0'){if (str[i] != '+' && str[i] != '-' && str[i] != '*' && str[i] != '/' && str[i] != '%' && str[i] != '.' && str[i] != '(' && str[i] != ')' && (str[i] < '0' || str[i] > '9')){return false;}i++;}return true;}void main(){char exp[100];int i;float f, f1, f2;char oper;FStack fstack;CStack cstack;Init(&fstack);Init(&cstack);printf("The expression is:");gets(exp);if (!Check(exp)){printf("input error! exit now!\n");exit(1);}for (i = 0; exp[i] != '\0' && exp[i] != -52; i++){if (!isOper(exp[i])){f = StrtoFloat(exp, &i);Push(&fstack, f);}if (isOper(exp[i])){if (!isEmpty(&cstack)){while (!isEmpty(&cstack) && Priority(exp[i]) <= Priority(GetTop(&cstack))){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Push(&cstack, exp[i]);}else{Push(&cstack, exp[i]);}}else if (exp[i] == '('){Push(&cstack, exp[i]);}else if (exp[i] == ')'){while (GetTop(&cstack) != '(' && !isEmpty(&cstack)){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Pop(&cstack);}}while (!isEmpty(&cstack)){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}printf("\nThe result is:%f\n", GetTop(&fstack));Pop(&fstack);}。

C语言简单计算器实现四则运算可带括号```c#include <stdio.h>#include <stdlib.h>int priority(char op)if (op == '+' ， op == '-')return 1;else if (op == '*' ， op == '/')return 2;else if (op == '(')return 0;elsereturn -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);}opTop--;}expr++;}numStack[++numTop] = num * sign;while (opTop >= 0)calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}return numStack[0];int maichar expr[100];printf("请输入表达式：");scanf("%s", expr);int result = eval(expr);printf("计算结果：%d\n", result);return 0;```以上是一个简单的C语言四则运算计算器的实现。

求简单的四则运算c语言求解简单的四则运算是C语言中常见的任务之一。

四则运算包括加法、减法、乘法和除法，是数学运算中最基本的运算形式。

在C语言中，可以使用算术运算符来进行四则运算。

我们来看一下加法运算。

加法运算是将两个数值相加，得到它们的和。

在C语言中，使用加号（+）来表示加法运算。

例如，表达式1 + 2的结果是3。

接下来是减法运算。

减法运算是将一个数值减去另一个数值，得到它们的差。

在C语言中，使用减号（-）来表示减法运算。

例如，表达式3 - 2的结果是1。

然后是乘法运算。

乘法运算是将两个数值相乘，得到它们的积。

在C语言中，使用星号（*）来表示乘法运算。

例如，表达式2 * 3的结果是6。

最后是除法运算。

除法运算是将一个数值除以另一个数值，得到它们的商。

在C语言中，使用斜杠（/）来表示除法运算。

例如，表达式6 / 2的结果是3。

除了以上四种基本的四则运算，C语言还提供了取余运算。

取余运算是将一个数值除以另一个数值后得到的余数。

在C语言中，使用百分号（%）来表示取余运算。

例如，表达式7 % 3的结果是1，因为7除以3的余数是1。

在C语言中，进行四则运算的语法非常简单。

只需要将运算符放置在两个运算数之间，就可以得到运算结果。

例如，表达式2 + 3的结果是5。

除了基本的四则运算外，C语言还提供了一些扩展的数学函数，用于处理更复杂的数学运算。

这些函数包括求幂函数（pow）、求平方根函数（sqrt）、求绝对值函数（abs）等等。

通过使用这些函数，可以实现更加复杂的数学运算。

总结一下，C语言提供了简单而强大的工具来进行四则运算。

通过使用加法、减法、乘法和除法运算符，可以实现基本的数学运算。

此外，还可以利用扩展的数学函数来处理更复杂的数学问题。

无论是简单的加减乘除，还是更复杂的数学运算，C语言都能够轻松应对。

希望本文对大家学习四则运算有所帮助。

C语言中的四则运算符包括加法运算符（+）、减法运算符（-）、乘法运算符（*）和除法运算符（/）。

以下是它们的基本用法：
1. 加法运算符（+）：用于将两个数值相加。

示例：`int sum = 3 + 5; // 结果为8`
2. 减法运算符（-）：用于将一个数值减去另一个数值。

示例：`int difference = 10 - 4; // 结果为6`
3. 乘法运算符（*）：用于将两个数值相乘。

示例：`int product = 6 * 7; // 结果为42`
4. 除法运算符（/）：用于将一个数值除以另一个数值，得到商（整数相除时结果为整数，浮点数相除时结果为浮点数）。

示例：`float quotient = 10 / 3; // 结果为3.3333...`
此外，还有取模运算符（%），用于求两个整数相除的余数。

示例：`int remainder = 10 % 3; // 结果为1`
需要注意的是，当进行多个运算符混合使用时，C语言会根据运算符优先级和结合性来确定运算顺序。

可以使用括号来改变运算次序。

希望以上解答能对你有所帮助！如果还有其他问题，请随时提问。

1。

四则运算（c语⾔）博客班级作业要求作业⽬标能够实现四则运算⼩程序的基本需求，同时练习写博客（排版等）学号3190704217⼆. 题⽬要求写⼀个能⾃动⽣成⼩学四则运算题⽬的程序，然后在此基础上扩展：1）除了整数以外，还要⽀持真分数的四则运算，例如：1/6+1/8=7/242）程序要求能处理⽤户的输⼊，判断对错，累积分数3）程序⽀持可以由⽤户⾃⾏选择加、减、乘、除运算4）使⽤-n参数控制⽣成题⽬的个数，例如Myapp.exe -n 10，将⽣成10个题⽬三. 代码#include <stdio.h>#include <stdlib.h>#include <time.h>#include <math.h>int s;//答对的题⽬数量float score;//得分(百分制)//判断答案是否正确void judge0(float a,float ta) //专为除法提供判断函数{float error=a-ta;//计算结果与真正答案的误差⼩于⼀定值if((error<=0.005)&&(error>=-0.004)){printf("回答正确！\n");s++;}elseprintf("回答错误，正确答案是 %.2f\n",ta);}void judge(int a,int ta) //加法减法，乘法的判断函数{if(a==ta){printf("回答正确！\n");s++;}elseprintf("回答错误，正确答案是 %d\n",ta);}void judge1(int a1,int a2,float ta) //真分数运算的判断函数{float a=(float)a1/(float)a2;if(a==ta){printf("回答正确！\n");s++;}elseprintf("回答错误，正确答案是 %.2f\n",ta);}//真分数的随机运算int random0(){int num,i=0;printf("请输⼊题⽬数量\n");scanf("%d",&num);srand(unsigned(time(NULL)));while(i<num){int type;//运算类型，加减乘除int left1,left2,right1,right2;int answer1,answer2;float trueanswer;left1= rand() % 100;left2= rand() % 100;type = rand() % 4;if(left1>left2) //转化为真分数{int t;t=left1;left2=left1;left1=t;}right1 = rand() % 100;right2 = rand() % 100;if(right1>right2)//转化为真分数{int t;t=right1;right2=right1;right1=t;}switch(type){case 0:trueanswer=((float)left1/(float)left2)+((float)right1/(float)right2); printf("%d/%d + %d/%d = ", left1, left2,right1,right2);scanf("%d/%d",&answer1,&answer2);judge1(answer1,answer2,trueanswer);break;case 1:trueanswer=((float)left1/(float)left2)-((float)right1/(float)right2); printf("%d/%d - %d/%d = ", left1, left2,right1,right2);scanf("%d/%d",&answer1,&answer2);judge1(answer1,answer2,trueanswer);break;case 2:trueanswer=((float)left1/(float)left2)*((float)right1/(float)right2); printf("%d/%d * %d/%d = ", left1, left2,right1,right2);scanf("%d/%d",&answer1,&answer2);judge1(answer1,answer2,trueanswer);break;case 3:trueanswer=((float)left1/(float)left2)/((float)right1/(float)right2); printf("%d/%d / %d/%d = ", left1, left2,right1,right2);scanf("%d/%d",&answer1,&answer2);judge1(answer1,answer2,trueanswer);break;}i++;}return num;}// 整数的随机运算int random(){int num,i=0;printf("请输⼊题⽬数量\n");scanf("%d",&num);srand(unsigned(time(NULL)));while(i<num){int type;//运算类型int left, right;int answer,trueanswer;left = rand() % 100;type = rand() % 4;right = rand() % 100;switch(type){case 0:trueanswer=left+right;printf("%d + %d = ", left, right); scanf("%d",&answer);judge(answer,trueanswer); break;case 1:trueanswer=left-right;printf("%d - %d = ", left, right); scanf("%d",&answer);judge(answer,trueanswer); break;case 2:trueanswer=left*right;printf("%d * %d = ", left, right); scanf("%d",&answer);judge(answer,trueanswer); break;case 3:float answer0,trueanswer0; trueanswer0=((float)left)/((float)right); printf("%d /%d = ", left, right);scanf("%f",&answer0);judge0(answer0,trueanswer0); break;}i++;}return num;}//加法int add(){int num,i=0;printf("请输⼊题⽬数量\n");scanf("%d",&num);srand(unsigned(time(NULL))); while(i<num){int left, right,answer,trueanswer;left = rand() % 100;right = rand() % 100;trueanswer=left+right;printf("%d +%d = ", left, right); scanf("%d",&answer);judge(answer,trueanswer);i++;}return num;}//减法int subtract(){int num,i=0;printf("请输⼊题⽬数量\n");scanf("%d",&num);srand(unsigned(time(NULL))); while(i<num){int left, right,answer,trueanswer; left = rand() % 100;right = rand() % 100; trueanswer=left-right;printf("%d -%d = ", left, right); scanf("%d",&answer);judge(answer,trueanswer);i++;}return num;}//乘法int multiply(){int num,i=0;printf("请输⼊题⽬数量\n");scanf("%d",&num);srand(unsigned(time(NULL))); while(i<num){int left, right,answer,trueanswer; left = rand() % 100;right = rand() % 100; trueanswer=left*right;printf("%d *%d = ", left, right); scanf("%d",&answer);judge(answer,trueanswer);i++;}return num;}//除法int divide(){int num,i=0;printf("请输⼊题⽬数量\n");scanf("%d",&num);srand(unsigned(time(NULL))); while(i<num){int left, right;float answer,trueanswer;left = rand() % 100;right = rand() % 100; trueanswer=((float)left)/((float)right); printf("%d /%d = ", left, right); scanf("%f",&answer);judge0(answer,trueanswer);i++;}return num;}//打印界⾯提⽰信息void main(){printf("welcome！\n");printf("\n");int choose,t;do{s=0;score=0;int n;printf("********************四则运算********************\n");printf("\n");printf(" 1.随即题⽬\n");printf(" 2.加法题⽬\n");printf(" 3.减法题⽬\n");printf(" 4.乘法题⽬\n");printf(" 5.除法题⽬\n");printf(" 6.分数运算\n");printf(" 7.退出\n");printf("\n");printf("******************Designed by 吴⼭茶******************\n");printf("\n");printf("请选择计算类型：");scanf("%d",&t);choose=t;printf("%d",choose);printf("\n");system("cls");switch(choose){case 1:n=random();printf("\n");break;case 2:n=add();printf("\n");break;case 3:n=subtract();printf("\n");break;case 4:n=multiply();printf("\n");break;case 5:n=divide();printf("\n");break;case 6:n=random0();printf("\n");break;default:break;}score=(float)s/(float)n;printf("得分：%.2f\n",score);}while(choose!=7);exit(0);}三.运⾏结果1.显⽰界⾯2.加法运算3.随机运算4.真分数运算任务内容计划完成需要的时间（min）实际完成需要的时间（min）计划1020任务内容计划完成需要的时间（min）实际完成需要的时间（min）估计这个任务需要多少时间，并规划⼤致⼯作步骤55开发00需求分析（包括学习新技术）1010⽣成设计⽂档00设计复审1530代码规范55具体设计2020具体编码150180代码复审1010报告00测试报告00计算⼯作量300330+事后总结，并提出过程改进计划2010。

c语言中加减乘除加、减、乘、除是C语言中常用的四则运算操作符。

它们在C语言中具有重要的作用，用于对数值进行加减乘除运算。

下面将分别介绍这四个运算符的用法和特点。

一、加法运算符（+）：加法运算符用于将两个数值相加，并返回它们的和。

例如，表达式a + b表示将变量a和b的值相加，并将结果赋给另一个变量或用于其他计算。

加法运算符还可用于字符串的连接。

例如，通过表达式strcat(str1, str2)可以将字符串str2连接到字符串str1的末尾。

二、减法运算符（-）：减法运算符用于将一个数值减去另一个数值，并返回它们的差。

例如，表达式a - b表示将变量b的值从变量a中减去，并将结果赋给另一个变量或用于其他计算。

减法运算符也可用于指针的运算。

例如，通过表达式ptr2 = ptr1 - 3可以将指针ptr1向前移动3个位置，并将结果赋给ptr2。

三、乘法运算符（*）：乘法运算符用于将两个数值相乘，并返回它们的积。

例如，表达式a * b表示将变量a和b的值相乘，并将结果赋给另一个变量或用于其他计算。

乘法运算符还可用于指针的运算。

例如，通过表达式ptr2 = ptr1 * 2可以将指针ptr1的值乘以2，并将结果赋给ptr2。

四、除法运算符（/）：除法运算符用于将一个数值除以另一个数值，并返回它们的商。

例如，表达式a / b表示将变量a的值除以变量b的值，并将结果赋给另一个变量或用于其他计算。

除法运算符还可用于求余数。

例如，通过表达式remainder = a % b可以将变量a除以变量b的余数赋给变量remainder。

总结：加、减、乘、除是C语言中常用的四则运算操作符。

它们分别用于数值的相加、相减、相乘和相除。

除法运算符还可用于求余数。

这些运算符在C语言中使用广泛，能够实现各种数值计算和操作。

在编写程序时，合理使用这些运算符可以提高程序的效率和准确性。

因此，熟练掌握加、减、乘、除的使用方法对于C语言程序员来说是非常重要的。

c语言四则运算程序本文将介绍一个简单的C语言程序，它可以实现四则运算。

四则运算是数学学科中最基础的计算方法之一，包括加、减、乘、除四个运算符。

通过本程序，您可以输入两个数和运算符，程序将自动计算并输出结果。

具体实现方法如下：1.首先，我们需要定义三个变量，分别代表输入的两个数和运算符。

这里我们使用float类型，以支持小数计算。

2.接着，我们需要使用scanf函数从键盘读入这三个变量的值。

scanf函数可以将输入的字符转换为相应的数据类型，这里我们可以使用“%f”读取浮点数，使用“%c”读取字符。

3.接下来，我们使用switch语句对输入的运算符进行判断。

根据不同的运算符，我们执行相应的计算，最终将结果输出到屏幕上。

4.在程序的结尾，我们可以使用return 0;语句来结束程序的执行。

下面是完整的C语言四则运算程序代码：#include <stdio.h>int main() {float num1, num2, result;char op;printf('请输入两个数和运算符，用空格隔开：');scanf('%f %f %c', &num1, &num2, &op); switch (op) {case '+':result = num1 + num2;printf('%.2f + %.2f = %.2f', num1, num2, result);break;case '-':result = num1 - num2;printf('%.2f - %.2f = %.2f', num1, num2, result);break;case '*':result = num1 * num2;printf('%.2f * %.2f = %.2f', num1, num2, result);break;case '/':if (num2 == 0) {printf('除数不能为0！');} else {result = num1 / num2;printf('%.2f / %.2f = %.2f', num1, num2, result);}break;default:printf('运算符错误！');}return 0;}通过以上程序，您可以轻松地进行四则运算，提高计算效率。

C（一）语言编写四则运算#include<stdio.h>//计算器#include<malloc.h>#define STACK_SIZE100//max size of the stack#define STACK_INCREMENT10//realloc sizetypedefstruct FStack//stack of int{float* base;float* top;int stacksize;}FStack;void Init(FStack* s){s->base = (float*)malloc(STACK_SIZE * sizeof(FStack));if (!s->base){printf("overflow!\n");return;}s->top = s->base;s->stacksize = STACK_SIZE;}bool isEmpty(FStack* s){if (s->top == s->base){returntrue;}else{returnfalse;}}void Push(FStack* s, float e){if (s->top - s->base >= s->stacksize){printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);s->base = (float*)realloc(s->base, (s->stacksize + sizeof(FStack))); if (!s->base){printf("overflow!\n");return;s->top = s->base + s->stacksize;s->stacksize += STACK_INCREMENT;}*(s->top) = e;(s->top)++;}float GetTop(FStack* s){if (s->top == s->base){printf("stack is empty!\n");return 0;}float e = *(s->top - 1);return e;}void Pop(FStack* s){if (s->top == s->base){printf("stack is empty!\n");return;}s->top--;}typedefstruct CStack//stack of char{char* base;char* top;int stacksize;}CStack;void Init(CStack* s){s->base = (char*)malloc(STACK_SIZE * sizeof(CStack)); if (!s->base){printf("overflow!\n");return;}s->top = s->base;s->stacksize = STACK_SIZE;}bool isEmpty(CStack* s)if (s->top == s->base){returntrue;}else{returnfalse;}}void Push(CStack* s, int e){if (s->top - s->base >= s->stacksize){printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);s->base = (char*)realloc(s->base, (s->stacksize + sizeof(CStack))); if (!s->base){printf("overflow!\n");return;}s->top = s->base + s->stacksize;s->stacksize += STACK_INCREMENT;}*(s->top) = e;(s->top)++;}char GetTop(CStack* s){if (s->top == s->base){printf("stack is empty!\n");return 0;}char e = *(s->top - 1);return e;}void Pop(CStack* s){if (s->top == s->base){printf("stack is empty!\n");return;}s->top--;}bool isOper(char ch){if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%') {returntrue;}else{returnfalse;}}int Priority(char ch){int p;switch(ch){case'(':p = 0;break;case'+':case'-':p = 1;break;case'*':case'/':case'%':p = 2;break;}return p;}float Calculate(float f1, float f2, char oper){float f3;switch(oper){case'+':f3 = f1 + f2;break;case'-':f3 = f1 - f2;break;case'*':f3 = f1 * f2;break;case'%':f3 = (float)((int)f1 % (int)f2);break;case'/':if (f2 == 0){printf("\nDevided by zero!");exit(1);}else{f3 = f1 / f2;}break;}return f3;}float StrtoFloat(char* str, int* pos){float fRes;int i = *pos;int k;char n[50];for (k = 0; str[i] >= '0' && str[i] <= '9' || str[i] == '.'; i++, k++) {n[k] = str[i];}n[k] = '\0';*pos = i;fRes = atof(n);return fRes;}bool Check(char* str){int i = 0;while (str[i] != '\0'){if (str[i] != '+' && str[i] != '-' && str[i] != '*' && str[i] != '/'&& str[i] != '%' && str[i] != '.' && str[i] != '(' && str[i] != ')'&& (str[i] < '0' || str[i] > '9')){returnfalse;}i++;}returntrue;}void main(){char exp[100];int i;float f, f1, f2;char oper;FStackfstack;CStackcstack;Init(&fstack);Init(&cstack);printf("The expression is:");gets(exp);if (!Check(exp)){printf("input error! exit now!\n");exit(1);}for (i = 0; exp[i] != '\0' && exp[i] != -52; i++) {if (!isOper(exp[i])){f = StrtoFloat(exp, &i);Push(&fstack, f);}if (isOper(exp[i])){if (!isEmpty(&cstack)){while (!isEmpty(&cstack) && Priority(exp[i]) <= Priority(GetTop(&cstack))){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Push(&cstack, exp[i]);}else{Push(&cstack, exp[i]);}}elseif (exp[i] == '('){Push(&cstack, exp[i]);}elseif (exp[i] == ')'){while (GetTop(&cstack) != '(' && !isEmpty(&cstack)) {oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Pop(&cstack);}}while (!isEmpty(&cstack)){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}printf("\nThe result is:%f\n", GetTop(&fstack)); Pop(&fstack);}。

四则运算（C语⾔）源代码：include<stdio.h>include<stdlib.h>include<math.h>include<time.h>int right=0;int wrong=0;int sum,s=0;//真分数void zhen(){int e,f,k,c,d,n,p;//输⼊要⽣成的题⽬数量printf("\t请输⼊要⽣成的题⽬数量：");scanf("%d",&n);while(s<n){e=rand()%100+1;f=rand()%100+1;k=rand()%4+1;if(e>=f){p=e;e=f;f=p;}c=rand()%100+1;d=rand()%100+1;if(c>=d){p=c;c=d;d=p;}switch(k){case 1:printf("%d/%d+%d/%d",e,f,c,d);break;case 2:printf("%d/%d-%d/%d",e,f,c,d);break;case 3:printf("%d/%d*%d/%d",e,f,c,d);break;case 4:printf("%d/%d/%d/%d",e,f,c,d);break;}s++;}printf("\t答对了%d题，打错了%d题\n",right,wrong);}//加法运算void add(){int a,b,c,n;//输⼊要⽣成的题⽬数量printf("\t请输⼊要⽣成的题⽬数量：");scanf("%d",&n);while(s<n){a=rand()%101;b=rand()%101;c = a + b ;printf("\t%d+%d=",a,b);scanf("%d",&sum);if(sum==c){printf("\t答对啦!\n");right++;}else{printf("\t答错了!\n");wrong++;}s++;}printf("\t答对了%d题，打错了%d题\n",right,wrong); }//减法运算void sub(){int a,b,c,n,q;//输⼊要⽣成的题⽬数量printf("\t请输⼊要⽣成的题⽬数量：");scanf("%d",&n);while(s<n){a=rand()%101;b=rand()%101;if(a<b){q=a;a=b;b=q;}c = a - b ;printf("\t%d-%d=",a,b);scanf("%d",&sum);if(sum==c){printf("\t答对啦!\n");right++;}else{printf("\t答错了!\n");wrong++;}s++;}printf("\t答对了%d题，打错了%d题\n",right,wrong); }//乘法运算void mul(){int a,b,c,n;//输⼊要⽣成的题⽬数量printf("\t请输⼊要⽣成的题⽬数量：");scanf("%d",&n);while(s<n){a=rand()%11;b=rand()%11;c = a * b;printf("\t%d*%d=",a,b);scanf("%d",&sum);if(sum==c){printf("\t答对啦!\n");right++;}else{printf("\t打错了!\n");wrong++;}s++;}printf("\t答对了%d题，打错了%d题\n",right,wrong);}//除法运算void chu(){int a,b,n,q;float c;//输⼊要⽣成的题⽬数量printf("\t请输⼊要⽣成的题⽬数量：");scanf("%d",&n);while(s<n){a=rand()%101;b=rand()%101;if(a<b){q=a;a=b;b=q;}c = a / b;printf("\t%d/%d=",a,b);scanf("%d",&sum);if(sum==c){printf("\t答对啦!\n");right++;}else{printf("\t打错了!\n");wrong++;}s++;}printf("\t答对了%d题，打错了%d题\n",right,wrong);}void main(){int n,t;//n 题数 t 运算类型编号//输⼊产⽣的运算类型printf("\t**四则运算⽣成器**\n");printf("\t请输⼊你要做的运算类型编号：\n");printf("\t0 加法\n\t1 减法\n\t2 乘法\n\t3 除法\n\t4 真分数运算\n\t5 退出四则运算程序\n"); scanf("%d",&t);while(t!=4){switch(t){case 0:add();break;case 1:sub();break;case 2:mul();break;case 3:chu();break;case 4:zhen();break;}}}在写程序的时候复习了遗忘的知识，也收获了许多，代码还不是很完善，真分数部分还⽆法运⾏，接下来要更加全⾯的去学习代码的编写。

C语言编写四则运算#include<> ; i++, k++){n[k] = str[i];}n[k] = '\0';*pos = i;fRes = atof(n);return fRes;}bool Check(char* str){int i = 0;while (str[i] != '\0'){if(str[i] != '+'&& str[i] != '-'&& str[i] != '*'&& str[i] != '/' && str[i] != '%' && str[i] != '.' && str[i] != '(' && str[i] != ')' && (str[i] < '0' || str[i] > '9')){return false;}i++;}return true;}void main(){char exp[100];int i;float f, f1, f2;char oper;FStack fstack;CStack cstack;Init(&fstack);Init(&cstack);printf("The expression is:");gets(exp);if (!Check(exp)){printf("input error! exit now!\n");exit(1);}for (i = 0; exp[i] != '\0' && exp[i] != -52; i++){if (!isOper(exp[i])){f = StrtoFloat(exp, &i);Push(&fstack, f);}if (isOper(exp[i])){if (!isEmpty(&cstack)){while (!isEmpty(&cstack) && Priority(exp[i]) <= Priority(GetTop(&cstack))){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Push(&cstack, exp[i]);}else{Push(&cstack, exp[i]);}}else if (exp[i] == '('){Push(&cstack, exp[i]);}else if (exp[i] == ')'){while (GetTop(&cstack) != '(' && !isEmpty(&cstack)) {oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Pop(&cstack);}}while (!isEmpty(&cstack)){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}printf("\nThe result is:%f\n", GetTop(&fstack));Pop(&fstack);}。

C语言编写四则运算#include<stdio.h>//计算器#include<malloc.h>#define STACK_SIZE100 //max size of the stack#define STACK_INCREMENT10 //realloc sizetypedef struct FStack//stack of int{float* base;float* top;int stacksize;}FStack;void Init(FStack* s){s->base = (float*)malloc(STACK_SIZE * sizeof(FStack));if (!s->base){printf("overflow!\n");return;}s->top = s->base;s->stacksize = STACK_SIZE;}bool isEmpty(FStack* s){if (s->top == s->base){return true;}else{return false;}}void Push(FStack* s, float e){if (s->top - s->base >= s->stacksize){printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);s->base = (float*)realloc(s->base, (s->stacksize +sizeof(FStack)));if (!s->base){printf("overflow!\n");return;}s->top = s->base + s->stacksize;s->stacksize += STACK_INCREMENT;}*(s->top) = e;(s->top)++;}float GetTop(FStack* s){if (s->top == s->base){printf("stack is empty!\n");return 0;}float e = *(s->top - 1);return e;}void Pop(FStack* s){if (s->top == s->base){printf("stack is empty!\n");return;}s->top--;}typedef struct CStack//stack of char{char* base;char* top;int stacksize;}CStack;void Init(CStack* s){s->base = (char*)malloc(STACK_SIZE * sizeof(CStack));if (!s->base){printf("overflow!\n");return;}s->top = s->base;s->stacksize = STACK_SIZE;}bool isEmpty(CStack* s){if (s->top == s->base){return true;}else{return false;}}void Push(CStack* s, int e){if (s->top - s->base >= s->stacksize){printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);s->base = (char*)realloc(s->base, (s->stacksize +sizeof(CStack)));if (!s->base){printf("overflow!\n");return;}s->top = s->base + s->stacksize;s->stacksize += STACK_INCREMENT;}*(s->top) = e;(s->top)++;}char GetTop(CStack* s){if (s->top == s->base){printf("stack is empty!\n");return 0;}char e = *(s->top - 1);return e;}void Pop(CStack* s){if (s->top == s->base){printf("stack is empty!\n");return;}s->top--;}bool isOper(char ch){if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%') {return true;}else{return false;}}int Priority(char ch){int p;switch(ch){case'(':p = 0;break;case'+':case'-':p = 1;break;case'*':case'/':case'%':p = 2;break;}return p;}float Calculate(float f1, float f2, char oper) {float f3;switch(oper){case'+':f3 = f1 + f2;break;case'-':f3 = f1 - f2;break;case'*':f3 = f1 * f2;break;case'%':f3 = (float)((int)f1 % (int)f2);break;case'/':if (f2 == 0){printf("\nDevided by zero!");exit(1);}else{f3 = f1 / f2;}break;}return f3;}float StrtoFloat(char* str, int* pos){float fRes;int i = *pos;int k;char n[50];for(k= 0; str[i] >= '0'&& str[i] <= '9'|| str[i] == '.'; i++, k++) {n[k] = str[i];}n[k] = '\0';*pos = i;fRes = atof(n);return fRes;}bool Check(char* str){int i = 0;while (str[i] != '\0'){if (str[i] != '+' && str[i] != '-' && str[i] != '*' && str[i] != '/' && str[i] != '%' && str[i] != '.' && str[i] != '(' && str[i] != ')' && (str[i] < '0' || str[i] > '9')){return false;}i++;}return true;}void main(){char exp[100];int i;float f, f1, f2;char oper;FStack fstack;CStack cstack;Init(&fstack);Init(&cstack);printf("The expression is:");gets(exp);if (!Check(exp)){printf("input error! exit now!\n");exit(1);}for (i = 0; exp[i] != '\0' && exp[i] != -52; i++){if (!isOper(exp[i])){f = StrtoFloat(exp, &i);Push(&fstack, f);}if (isOper(exp[i])){if (!isEmpty(&cstack)){while (!isEmpty(&cstack) && Priority(exp[i]) <= Priority(GetTop(&cstack))){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Push(&cstack, exp[i]);}else{Push(&cstack, exp[i]);}}else if (exp[i] == '('){Push(&cstack, exp[i]);}else if (exp[i] == ')'){while (GetTop(&cstack) != '(' && !isEmpty(&cstack)){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}Pop(&cstack);}}while (!isEmpty(&cstack)){oper = GetTop(&cstack);Pop(&cstack);f2 = GetTop(&fstack);Pop(&fstack);f1 = GetTop(&fstack);Pop(&fstack);f = Calculate(f1, f2, oper);Push(&fstack, f);}printf("\nThe result is:%f\n", GetTop(&fstack));Pop(&fstack);}。