c语言运算符的题如何编程

A. c语言编程 求解简单表达式，输入一个形式如“操作数 运算符 操作数”的四则运算表达式，输出运算结果。

#include"stdio.h"
#include"math.h"
main()
{
int x,y;
char flag;
printf("请输入操作数1，运算符，操作数2\n")
scanf("%d%c%d",&x,&flag,&y);
switch(flag)
case +:printf("=%d\n",x+y); break;
case -:printf("=%d\n",x-y); break;
case *:printf("=%d\n",x*y); break;
case /:printf("=%d\n",x/y); break;
default: error;
}

B. c语言，采用条件运算符那道题怎么做

思路：使用三目运算符。

#include<stdio.h>
#include<math.h>
intmain()
{
	floatx=-0.5;
	floaty=(x>1)?(y=x*x):((x<-1)?(abs(x)+2):(sin(x)));

	printf("%.2f
",y);

	return0;
}

C. c语言位运算符的用法

c语言位运算符的用法1

c语言位运算符的用法如下：

一、位运算符C语言提供了六种位运算符：

& 按位与

| 按位或

^ 按位异或

~ 取反

<< 左移

>> 右移

1. 按位与运算

按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。

例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。

按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。

main(){

int a=9,b=5,c;

c=a&b;

printf("a=%d/nb=%d/nc=%d/n",a,b,c);

}

2. 按位或运算

按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。

例如：9|5可写算式如下： 00001001|00000101

00001101 (十进制为13)可见9|5=13

main(){

int a=9,b=5,c;

c=a|b;

printf("a=%d/nb=%d/nc=%d/n",a,b,c);

}

3. 按位异或运算

按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下： 00001001^00000101 00001100 (十进制为12)。

main(){

int a=9;

a=a^15;

printf("a=%d/n",a);

}

4. 求反运算

求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：1111111111110110。

5. 左移运算

左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如： a<<4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。

6. 右移运算

右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的`各二进位全部右移若干位，“>>”右边的数指定移动的位数。

例如：设 a=15，a>>2 表示把000001111右移为00000011(十进制3)。 应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。

main(){

unsigned a,b;

printf("input a number: ");

scanf("%d",&a);

b=a>>5;

b=b&15;

printf("a=%d/tb=%d/n",a,b);

}

请再看一例!

main(){

char a='a',b='b';

int p,c,d;

p=a;

p=(p<<8)|b;

d=p&0xff;

c=(p&0xff00)>>8;

printf("a=%d/nb=%d/nc=%d/nd=%d/n",a,b,c,d);

}

c语言位运算符的用法2

C语言位运算。所谓位运算，就是对一个比特(Bit)位进行操作。比特(Bit)是一个电子元器件，8个比特构成一个字节(Byte)，它已经是粒度最小的可操作单元了。

C语言提供了六种位运算符：

按位与运算(&)

一个比特(Bit)位只有 0 和 1 两个取值，只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似。

C语言中不能直接使用二进制，&两边的操作数可以是十进制、八进制、十六进制，它们在内存中最终都是以二进制形式存储，&就是对这些内存中的二进制位进行运算。其他的位运算符也是相同的道理。

例如，9 & 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)

也就是说，按位与运算会对参与运算的两个数的所有二进制位进行&运算，9 & 5的结果为 1。

又如，-9 & 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-9 & 5的结果是 5。

关于正数和负数在内存中的存储形式，我们已在教程《整数在内存中是如何存储的》中进行了讲解。

再强调一遍，&是根据内存中的二进制位进行运算的，而不是数据的二进制形式;其他位运算符也一样。以-9&5为例，-9 的在内存中的存储和 -9 的二进制形式截然不同：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (-9 的二进制形式，前面多余的 0 可以抹掉)

按位与运算通常用来对某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以进行n & 0XFFFF运算(0XFFFF 在内存中的存储形式为 0000 0000 -- 0000 0000 -- 1111 1111 -- 1111 1111)。

【实例】对上面的分析进行检验。

00001. #include

00002.

00003. int main(){

00004. int n = 0X8FA6002D;

00005. printf("%d, %d, %X ", 9 & 5, -9 & 5, n & 0XFFFF);

00006. return 0;

00007. }

运行结果：

1, 5, 2D

按位或运算(|)

参与|运算的两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为1，0|0为0，1|0为1，这和逻辑运算中的||非常类似。

例如，9 | 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 (13 在内存中的存储)

9 | 5的结果为 13。

又如，-9 | 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-----------------------------------------------------------------------------------

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-9 | 5的结果是 -9。

按位或运算可以用来将某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以进行n | 0XFFFF0000运算(0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000)。

【实例】对上面的分析进行校验。

00001. #include

00002.

00003. int main(){

00004. int n = 0X2D;

00005. printf("%d, %d, %X ", 9 | 5, -9 | 5, n | 0XFFFF0000);

00006. return 0;

00007. }

运行结果：

13, -9, FFFF002D

按位异或运算(^)

参与^运算两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为1，0^0为0，1^1为0。

例如，9 ^ 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 (12 在内存中的存储)

9 ^ 5的结果为 12。

又如，-9 ^ 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-----------------------------------------------------------------------------------

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 (-14 在内存中的存储)

-9 ^ 5的结果是 -14。

按位异或运算可以用来将某些二进制位反转。例如要把 n 的高 16 位反转，保留低 16 位，可以进行n ^ 0XFFFF0000运算(0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000)。

【实例】对上面的分析进行校验。

00001. #include

00002.

00003. int main(){

00004. unsigned n = 0X0A07002D;

00005. printf("%d, %d, %X ", 9 ^ 5, -9 ^ 5, n ^ 0XFFFF0000);

00006. return 0;

00007. }

运行结果：

12, -14, F5F8002D

取反运算(~)

取反运算符~为单目运算符，右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似。。

例如，~9可以转换为如下的运算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

-----------------------------------------------------------------------------------

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 (-10 在内存中的存储)

所以~9的结果为 -10。

例如，~-9可以转换为如下的运算：

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 (9 在内存中的存储)

所以~-9的结果为 8。

【实例】对上面的分析进行校验。

00001. #include

00002.

00003. int main(){

00004. printf("%d, %d ", ~9, ~-9 );

00005. return 0;

00006. }

运行结果：

-10, 8

左移运算(<<)

左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补0。

例如，9<<3可以转换为如下的运算：

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 (72 在内存中的存储)

所以9<<3的结果为 72。

又如，(-9)<<3可以转换为如下的运算：

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-----------------------------------------------------------------------------------

1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 (-72 在内存中的存储)

所以(-9)<<3的结果为 -72

如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。

【实例】对上面的结果进行校验。

00001. #include

00002.

00003. int main(){

00004. printf("%d, %d ", 9<<3, (-9)<<3 );

00005. return 0;

00006. }

运行结果：

72, -72

右移运算(>>)

右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0;如果最高位是 1，那么就补 1。

例如，9>>3可以转换为如下的运算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

-----------------------------------------------------------------------------------

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)

所以9>>3的结果为 1。

又如，(-9)>>3可以转换为如下的运算：

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-----------------------------------------------------------------------------------

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 (-2 在内存中的存储)

所以(-9)>>3的结果为 -2

如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方(但被移除的位中经常会包含 1)。

【实例】对上面的结果进行校验。

00001. #include

00002.

00003. int main(){

00004. printf("%d, %d ", 9>>3, (-9)>>3 );

00005. return 0;

00006. }

运行结果：

1, -2

c语言位运算符的用法3

一、位运算符

在计算机中，数据都是以二进制数形式存放的，位运算就是指对存储单元中二进制位的运算。C语言提供6种位运算符。

二、位运算

位运算符 & |~<< >> ∧ 按优先级从高到低排列的顺序是：

位运算符中求反运算“~“优先级最高，而左移和右移相同，居于第二，接下来的顺序是按位与 “&“、按位异或 “∧“和按位或 “|“。顺序为~ << >> & ∧ | 。

例1：左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。

例如：

a<<4

指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。

例2：右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。

例如：

设 a=15，

a>>2

表示把000001111右移为00000011(十进制3)。

应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。

例3：设二进制数a是00101101 ，若通过异或运算a∧b 使a的高4位取反，低4位不变，则二进制数b是。

解析：异或运算常用来使特定位翻转，只要使需翻转的位与1进行异或操作就可以了，因为原数中值为1的位与1进行异或运算得0 ，原数中值为0的位与1进行异或运算结果得1。而与0进行异或的位将保持原值。异或运算还可用来交换两个值，不用临时变量。

如 int a=3 , b=4;，想将a与b的值互换，可用如下语句实现：

a=a∧b;

b=b∧a;

a=a∧b;

所以本题的答案为： 11110000 。

D. 输入两个整数，进行加减乘除四则运算的c语言程序怎么写啊，拜托了~

代码抄

#include<stdio.h>

int main()

{

int a,b;

scanf("%d %d",&a,&b);

printf("%d ",a + b);

printf("%d ",a - b);

printf("%d ",a * b);

printf("%d ",a / b);

return 0;

}

运行截图

分析

C语言中的加减乘除和数学中的加减乘除一样，不同在于符号的表示问题，乘号需要用“*”表示。除号需要用“/”表示。新手学习C语言，很容易把除号和取余好混淆，强调一下，取余号是“%”，百分号就是取余的意思。因此在输入两个整数以后，按照数学方法就可以直接输出结果，整数的输入用scanf()函数。

E. c语言编程题，利用条件运算符的嵌套来完成，使用switch语句编程

参考代码如下：

#include<stdio.h>

intmain()
{
intd;
chars;
scanf("%d",&d);
if(d>100||d<0)
s=0;
else{
switch(d/10){
case10:
case9:s='A';break;
case8:
case7:
case6:s='B';break;
default:s='C';
}
}
if(s!=0)
printf("%c",s);
else
printf("错误的数据输入！");
return0;
}

F. 请问怎么用C语言编写四则运算的程序呢

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define size 20

typedef float NUM;

typedef struct
{
NUM data[size];
int top;
}*Space,Lnode;

void begin();
void initialize(Space x,Space y);
void input(Space x,Space y);
int is_operator(char a_operator);
int pushf(Space s,float x);
int pushc(Space s,char x);
int empty(Space s);
int priority(char o);
int popf(Space s,float *x);
int popc(Space s,int *x);
float result(int a_operator,float operand1,float operand2);

main()
{
begin();
system("pause");
}

void begin()
{
Lnode operand,a_operator;//定义两个指向结构体的指针
Space s_operand=&operand,s_operator=&a_operator;
initialize(s_operand,s_operator);//初始化
input(s_operand,s_operator);//开始
}

void initialize(Space s,Space t)//初始化数据栈、运算符栈
{
s->top=0;
t->top=0;
}

void input(Space x,Space y)
{
int i,j,position=0,op=0;
float operand1=0,operand2=0,evaluate=0;//用来储存两个计算数 和 一个结果
char string[50];//所输入的表达式
char temp[50];//用来临时存放小数

printf("请输入表达式: ");
gets(string);

while(string[position]!='\0'&&string[position]!='\n')
{
i=0;
strcpy(temp,"0");

if(is_operator(string[position]))//判断是否为运算符
{
if(!empty(y))
{
while(!empty(y)&&priority(string[position])<=priority(y->data[y->top-1]))//判断优先级
{
popf(x,&operand1);
popf(x,&operand2);
popc(y,&op);
pushf(x,result(op,operand1,operand2));//计算结果
}
}
pushc(y,string[position]);//运算符入栈
position++;
}

while((string[position]!='\0'&&string[position]!='\n')&&(!is_operator(string[position])))//数据存入temp数组
{
temp[i]=string[position];

i++;
position++;
}
pushf(x,atof(temp));//将数组强制转换为浮点型 然后进行入栈操作 x为指向数据栈的指针 atof函数即使强制转换类型
}

while(!empty(y))
{
popc(y,&op);
popf(x,&operand1);
popf(x,&operand2);

pushf(x,result(op,operand1,operand2));
}
popf(x,&evaluate);

printf("结果是 : %f",evaluate);
}

int pushf(Space s,float x)//数据入栈
{
if(s->top==size)
return 0;
s->data[s->top]=x;
s->top++;
return 1;
}

int pushc(Space s,char x)//运算符入栈
{
if(s->top==size)
return 0;
s->data[s->top]=x;
s->top++;
return 1;
}

int popf(Space s,float *x)//数据出栈
{
if(s->top==0)
return 0;
else
{
s->top--;
*x=s->data[s->top];
return 1;
}
}

int popc(Space s,int *x)//运算符出栈
{
if(s->top==0)
return 0;
else
{
s->top--;
*x=s->data[s->top];
return 1;
}
}

int empty(Space s)//判断栈空
{
if(s->top==0)
return 1;
else
return 0;
}

int is_operator(char Operator) //判断是否为运算符
{
switch(Operator)
{
case '+':
case '-':
case '*':
case '/':
return 1;
default:
return 0;
}
}

int priority(char o) //判断运算符的优先级别
{
switch(o)
{
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
default:
return 0;
}
}

float result(int a_operator,float operand1,float operand2)//计算结果
{
switch(a_operator)
{
case '+':
return operand2+operand1;
case '-':
return operand2-operand1;
case '*':
return operand2*operand1;
case '/':
return operand2/operand1;
}
}

这是用栈写的 没有写输入错误的判断 你自己添加一下吧
我是因为刚好有一个现成的程序

G. c语言怎么进行算术运算

#include "stdio.h" void main() { int a,b,c; scanf("%d%d",&a,&b); c=a+b; printf("%d\n",c); getch(); }

具体如下：
1、简介C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。尽管C语言提供了许多低级处理的功能，但仍然保持着良好跨平台的特性，以一个标准规格写出的C语言程序可在许多电脑平台上进行编译，甚至包含一些嵌入式处理器（单片机或称MCU）以及超级电脑等作业平台。
2、基本介绍
C语言，是一种通用的、过程式的编程语言，广泛用于系统与应用软件的开发。具有高效、灵活、功能丰富、表达力强和较高的移植性等特点，在程序员中备受青睐。最近25年是使用最为广泛的编程语言。
3、运算
C语言的运算非常灵活，功能十分丰富，运算种类远多于其它程序设计语言。在表达式方面较其它程序语言更为简洁，如自加、自减、逗号运算和三目运算使表达式更为简单，但初学者往往会觉的这种表达式难读，关键原因就是对运算符和运算顺序理解不透不全。当多种不同运算组成一个运算表达式，即一个运算式中出现多种运算符时，运算的优先顺序和结合规则显得十分重要。在学习中，对此合理进行分类，找出它们与数学中所学到运算之间的不同点之后，记住这些运算也就不困难了，有些运算符在理解后更会牢记心中，将来用起来得心应手，而有些可暂时放弃不记，等用到时再记不迟。

H. c语言编程题： 将123这个数的个位，十位，百位依次输出。（利用算数运算符）

像这种给你一个数让你去求它的每位数分别输出，主要使用/和%两种运算符，你只要深刻理解
两种运算符的含义，像这种题很简单。求最高位一般用/求个位一般用%；例如12345；
x=12345;
a=x/10000;
b=x=1000-a*10;
c=(x%100)/100;
d=(x%1000)/10;
e=x%10;
好好体会吧！

I. C语言编程：首先输入两个数和一个运算符号，然后根据运算符号来做相应的运算。

改正一楼的二个地方就是，
#include <stdio.h>

void main()
{
int n1,n2,result; /*result代表结果*/
char oper;
printf("请输入两个数: ");
scanf("%d%d",&n1,&n2);
fflush(stdin)/*此处清除键盘缓冲区，否则结果是错的*/
printf("\n请输入运算");/*此处是printf书写错误*/
scanf("%c",&oper);
switch(oper)
{
case '+':
result=n1+n2;
break;
case '-':
result=n1-n2;
break;
case '*':
result=n1*n2;
break;
case '/':
result=n1/n2;
break;
}
printf("\n%d %c %d = %d\n",n1,oper,n2,result);

}

J. C语言编程：首先输入两个数和一个运算符号，然后根据运算符号来做相应的运算。

标准做法是弄一个栈，如果是数字就进栈，如果遇到运算符就判断进行何种运算，然后出栈两个数，进行运算，把结果再送到栈中。这样可以进行嵌套的运算。
如果只要进行一次，就直接输入，判断运算符，进行相应的计算，输出结果就行了。