A. c语言中,有哪些算术运算符
C语言中算术运算符有以下这些
实例：
#include<stdio.h>
intmain()
{
inta=21;
intb=10;
intc;
c=a+b;
printf("Line 1 - c 的值是 %d ",c);
c=a-b;
printf("Line 2 - c 的值是 %d ",c);
c=a*b;
printf("Line 3 - c 的值是 %d ",c);
c=a/b;
printf("Line 4 - c 的值是 %d ",c);
c=a%b;
printf("Line 5 - c 的值是 %d ",c);
c=a++; // 赋值后再加 1 ，c 为 21，a 为 22
printf("Line 6 - c 的值是 %d ",c);
c=a--; // 赋值后再减 1 ，c 为 22 ，a 为 21
printf("Line 7 - c 的值是 %d ",c);
return0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 21
Line 7 - c 的值是 22
(1)c语言表达式中有乘有除扩展阅读：
C语言中，除了算数运算符，还提供以下运算符：
1、关系运算符
2、逻辑运算符
3、位运算符
4、赋值运算符
5、杂项运算符
运算符优先级：
C语言中，运算符的运算优先级共分为15 级。1 级最高，15 级最低。
在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的运算符 优先级相同时，则按运算符的结合性所规定的结合方向处理。
运算符结合性：
C语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。
如有表达式x-y+z 则y 应先与“-”号结合，执行x-y 运算，然后再执行+z 的运算。这种自左至右的结合 方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。
最典型的右结合 性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)运算。C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。
优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。
所有的优先级中，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。其它的都是从左至右结合。
具有最高优先级的其实并不算是真正的运算符，它们算是一类特殊的操作。()是与函数相关，[]与数组相关，而－>及.是取结构成员。
其次是单目运算符，所有的单目运算符具有相同的优先级，因此在我认为的 真正的运算符中它们具有最高的优先级，又由于它们都是从右至左结合的，因此*p++与*(p++)等效是毫无疑问的。
B. c语言中只含有乘除的表达式怎么判断合法
只含有乘和除，那么只要除数不为0，就可以计算，所以只要判断除数不为0就可以了。
C. 如何在c语言中输入一个算式的时候先除再乘再除
int a,=2,b=3,c=5,d=6,sum;
sum=a/困老b*c/d;//C语言乘除同级，从左向右，谁在前先执行谁；
sum=((a/b)*c)/d;//等价于上面汪丛升；郑空
D. 在C语言中表达式由那些组成
在C语言中，表达式是由操作数和操作符组成的组合，操作数是指参与运算的变量或常量，而困尘操作符则表示执行的运算操作。C语言中的操作符可以分为汪敬禅以下几类：
算术运算符，如加、减、乘、除、求余等；
关系运算符，如相等、不等、大于、小于、大于等于、小于等于；
逻辑运算符，如逻辑与（AND）、逻辑或（OR）、逻辑非（NOT）；
位运算符，如按位与（&）、按位或（|）、按位异或（^）、按位取反（~）等；
赋值运算符，如等号（=）、加等（+=）、减等（-=）等；
条件运算符，如三目运算符（?:）；
其他运算符，如逗稿闭号运算符（,）等。
在表达式中，操作符还有一个重要的概念，就是优先级，它决定了表达式中各个操作符执行顺序的顺序。在C语言中，优先级高的操作符会先被执行。如果需要改变操作符的执行顺序，可以使用括号来改变优先级。
E. c语言中整数小数乘除有何规定
在C语言中无论整型数还是浮点数，都可以进行乘法和除法操作。需要注意的是类型转换。比如:
printf("%f",3/2);输出的结果是0.000000。这并不是一个预期的运算结果。因为3、2这样的常量在C语言中默认是整型常量。3/2的结果是1。但是对于整数1来说，它的机器码
而浮点数的编码一般使用的IEEE754编码，上面的机器码用IEEE754编码表示，即为0。正确的写法应该是：
printf("%f",(float)3/2);
F. 用 C 语言编写一个具有加、减、乘、除计算功能的程序，代码语句后要写有正确注释。
#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 512
typedef struct /* 定义一个运算符栈 */
{
char * base; /*指向栈底的指针*/
char * top; /*指向栈顶的指针*/
}OPTR_Stack;
typedef struct /* 定义一个操作符栈 */
{
double * base;
double * top;
}OPND_Stack;
void OptrInIt(OPTR_Stack *s) /* 初始化运算符栈 */
{
s->base=(char*)malloc(STACK_SIZE*sizeof(char));/*分配内存*/
if(s->base==NULL) exit(0); /* 判断栈是否为空 */
s->top=s->base; /春裂* 初始化栈 */
}
int OptrEmpty(OPTR_Stack s) /* 定义栈空事件 */
{
if(s.top==s.base) /*判断栈空*/
return 1; /* 栈空返回1，否则为0 */
else
return 0;
}
void OptrPush(OPTR_Stack *s,char elem) /* 入栈操作符 */
{
if (s->top-s->base==STACK_SIZE) /* 判断栈满 */
{
printf("OPTR_Stack is full!\n"); /*栈满则打印*/
getch(); /*停止*/
exit(0);
}
else
*(s->top++)=elem; /*栈未满则elem入栈*/
}
char OptrPop(OPTR_Stack *s) /* 出栈 */
{
char elem; /*定义字符变量*/
if(OptrEmpty(*s)) /*判断栈是否为空*/
{
printf("Stack is empty\n"); /*栈空打印*/
getch(); /*停止*/
exit(0);
}
else
{
elem=*--s->top; /*出栈值传给elem*/
return elem;
}
}
char OptrGetTop(OPTR_Stack s) /* 获取栈顶元素扒态闭 */
{
char elem; /*定义字符变量*/
if(!OptrEmpty(s)) /*判断栈s是否为空*/
{
elem=*(s.top-1); /*将栈顶元素值传给elem*/
return elem;
}
}
void OpndInit(OPND_Stack *s) /* 初始化数栈 */
{
s->base=(double *)malloc(STACK_SIZE*sizeof(double));/*分配内闭乎存*/
if(s->base==NULL) exit(0); /* 判断栈是否为空 */
s->top=s->base; /* 初始化栈 */
}
int OpndEmpty(OPND_Stack s) /* 判断数栈是否为空 */
{
if(s.top==s.base)
return 1; /*栈为空则返回1*/
else
return 0; /*栈不为空则返回0*/
}
void OpndPush(OPND_Stack *s,double elem) /* 入栈 */
{
if (s->top-s->base==STACK_SIZE) /* 判断栈满 */
{
printf("OPND_Stack is full!\n"); /*栈满则打印*/
getch(); /*停止*/
exit(0);
}
else
*s->top++=elem; /*栈未满则elem入栈*/
}
double OpndPop(OPND_Stack *s) /* 出栈 */
{
double elem; /*定义字符变量*/
if(OpndEmpty(*s)) /*判断栈s是否为空*/
{
printf("OPND_Stack is empty\n"); /*栈空则打印*/
getch(); /*停止*/
exit(0);
}
else
{
elem=*--s->top; /*栈非空出栈*/
return elem;
}
}
double OpndGetTop(OPND_Stack s) /* 获取栈顶元素 */
{
double elem; /*定义字符变量*/
if(!OpndEmpty(s)) /*判断栈s是否为空*/
{
elem=*(s.top-1); /* 将栈顶值传给elem*/
return elem; /*返回值*/
}
}
int isoper(char c) /* 判断是否为运算符 */
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='%')
return 1; /*如果c是'+''-''/''*'中的一种则返回1*/
else
return 0; /*否则返回0*/
}
int priority(char c) /* 判断优先级 */
{
int p; /*定义一个整型数*/
switch(c)
{
case '+':
case '-': p=1;break; /* +-的优先级为1*/
case '*':
case '%':
case '/': p=2;break; /* '*''%''/'的优先级为2*/
case '(': p=0;break; /* （的优先级为0*/
}
return(p); /*返回值*/
}
double calculate(double s1,double s2,char oper) /* 计算表达式 */
{
double y; /*定义一个浮点型*/
switch(oper)
{
case '+': y=s2+s1;break;
case '-': y=s2-s1;break;
case '*': y=s2*s1;break;
case '%': y=(int)((int)s2%(int)s1); break;
case '/': /*情形为'/'时*/
if(s1==0) /*当除数为0时*/
{
printf("\nDevided by zero!"); /*打印除数为0*/
getch(); /*停止*/
exit(0);
}
y=s2/s1;break; /*除数不为0则定义y值为两数商*/
}
return(y); /*返回值*/
}
double StrTodouble(char *s,int *j) /* 将字符串转化成数字 */
{
int i,k; /*定义两个整型变量*/
char n[100]; /*定义一个数组*/
double f; /*定义一个浮点型*/
i=*j;
for(k=0;s[i]>='0' && s[i]<='9' || s[i]=='.';i++,k++) /*当数组里为0~9的数值或是小数点*/
{
n[k]=s[i]; /*将字符存入数组*/
}
n[k]='\0'; /*存入一个数值后数值间加空格*/
*j=i;
f=atof(n); /*将字符数组转换成浮点型数据*/
return(f); /*返回值*/
}
double compute(char *exp1)
{
char oper;
int i;
double OPND1,OPND2,result,f;
OPTR_Stack OPTR; /* 运算符栈OPTR*/
OPND_Stack OPND; /*操作数栈OPND */
OptrInIt(&OPTR); /*初始化符号栈*/
OpndInit(&OPND); /*初始化操作数栈*/
printf("\n你输入的表达式是 :");
puts(exp1); /*输出输入的表达式*/
for(i=0;exp1[i]!='\0' && exp1[i]!='\n';i++)
{
if(!isoper(exp1[i]) && exp1[i]>='0' && exp1[i]<='9' || exp1[i]=='.') /* 将字符型的操作数转化为数字，存入数栈中 */
{
f=StrTodouble(exp1,&i); /*将数组exp1中的字符型操作数转换为浮点型的数*/
OpndPush(&OPND,f); /*将转换后的数存入数栈中*/
}
if(isoper(exp1[i])) /* 为运算符时 */
{
if(!OptrEmpty(OPTR)) /*当符号栈不为空时*/
{
while(!OptrEmpty(OPTR) && priority(exp1[i])<=priority(OptrGetTop(OPTR)))
/* 比较优先级，栈顶运算符优先级高时，运算符出栈 */
{
oper=OptrPop(&OPTR); /*出栈将值传给oper*/
OPND1=OpndPop(&OPND); /*数栈中一个数出栈*/
OPND2=OpndPop(&OPND); /*数栈中下一个数出栈*/
result=calculate(OPND1,OPND2,oper); /*计算*/
OpndPush(&OPND,result); /*计算结果入栈*/
}
OptrPush(&OPTR,exp1[i]); /*栈顶运算符优先级低时，运算符入栈*/
}
else
OptrPush(&OPTR,exp1[i]); /*符号栈为空时，运算符入栈*/
}
else if(exp1[i]=='(') OptrPush(&OPTR,exp1[i]); /*'('入栈*/
else if(exp1[i]==')')
{
while(OptrGetTop(OPTR)!='(' && !OptrEmpty(OPTR))
/*运算符出栈，直到遇到')'或者栈空 */
{
oper=OptrPop(&OPTR); /*出栈将值传给oper*/
OPND1=OpndPop(&OPND); /*数栈中一个数出栈*/
OPND2=OpndPop(&OPND); /*数栈中下一个数出栈*/
result=calculate(OPND1,OPND2,oper); /*计算*/
OpndPush(&OPND,result); /*计算结果入栈*/
}
OptrPop(&OPTR); /*将栈内的'('丢掉*/
}
}
while(!OptrEmpty(OPTR)) /*符号栈不为空*/
{
oper=OptrPop(&OPTR); /*出栈将值传给oper*/
OPND1=OpndPop(&OPND); /*数栈中一个数出栈*/
OPND2=OpndPop(&OPND); /*数栈中下一个数出栈*/
result=calculate(OPND1,OPND2,oper); /*计算*/
OpndPush(&OPND,result); /*计算结果入栈*/
}
return result;
}
int main()
{
double result;
char exp1[100]; /*表达式*/
while(1) {
printf("请输入要计算的表达式 : ");
gets(exp1); /*输入值放入数组exp1中*/
result = compute(exp1);
printf("\n结果是 : %lf\n",result); /*打印结果*/
printf("回车继续，其他退出\n");
if(getch()!='\r') exit(0);
}
}
G. C语言中的 算术运算 关系运算 逻辑运算 分别怎么解释
算术运算是有加,减,乘,除组成敬睁穗的表达式;
关系运算是早铅有>,<,<=,>=,==,!=等关系运算符亮卜组成的表达式;
逻辑运算有与(&&),或(||),非(！)等逻辑运算符组成的表达式！
H. c语言运算优先级
优先级就是当表达式中有多个运算符时，先计算谁，后计算谁。打个比方，在四则运算中乘除的优先级就高于加减。
但是C语言中的运算符除了加减乘除还有很多，我们也没必要将所有运算符的优先级都记住，这里列出来各个运算符的优先级表，实在需要用到的时候查一下表就行了。而且实际上在编程的时候需要考虑优先级的情况很少，因为如果不知道优先级高低的话，加一个括号就行了，因为括号的优先级是最高的。
比如：
k = (j > i) && (8 == i)
根据优先级的高低，完全可以写成：
k = j > i && 8 == i
第一种写法是比较提倡的，因为一看就知道先计算谁后计算谁，节省了大家的时间还不容易出错。而且加圆括号也是一种编程规范，因为程序不只是写给自己看。
此外运算符还有“目”和“结合性”的概念。“目”就是眼睛的意思，一个运算符需要几个数参与就归为“几目”。C语言中大多数运算符都是双目的，比如 和 运算符；也有单目和三目的，单目运算符如逻辑非 ( !1 )；三目运算符即条件运算符，？：也是C语言中的唯一一个三目运算符。
说完了“目”的概念，再来说一说“结合性”。先来煮个栗子：
1 + 2 × 3 / 4
上式中乘法和除法的优先级相同，但计算的时候是从左往右，所以乘和除的结合性就是从左往右，so easy！
C语言中大多数运算符的结合性都是从左往右，只有三个运算符是从右往左的。一个是单目运算符，另一个是三目运算符，还有一个就是双目运算符中的赋值运算符 。运算符的“结合性”也不需要死记硬背，在不断使用中就记住了。
I. c语言中整数小数乘除有何规定
其实,整数没有除法,只有取商(/),取余(%),所以,也没有什么舍入
2/3=0
3.2/2=1.6(2也是浮点数,因为不同数据类型的数是不能参与运算的)
1.50000*6=9.0(同理,6也是浮点数)
J. c语言 加减乘除 顺序
先加减后乘除。
C语言中的加号、减号与数学中的一样，乘号、除号不同；另外C语言还多了一个求余数的运算符，就是 %。
不同类型的除数和被除数会导致不同类型的运算结果：
当除数和被除数都是整数时，运算结果也是整数；如果不能整除，那么就直接丢掉小数部分，只保留整数部分，这跟将小数赋值给整数类型是一个道理。一旦除数和被除数中有一个是小数，那么运算结果也是小数，并且是 double 类型的小数。
(10)c语言表达式中有乘有除扩展阅读
取余，也就是求余数，使用的运算符是 %。C语言中的取余运算只能针对整数，也就是说，% 的两边都必须是整数，不能出现小数，否则编译器会报错。
另外，余数可以是正数也可以是负数，由 % 左边的整数决定：
如果 % 左边是正数，那么余数也是正数；
如果 % 左边是负数，那么余数也是负数。