python逗号运算符_C 语言-运算符(算术运算符,类型转换,赋值运算符,自增,自减,sizeof 运算符,逗号运算符,关系运算符,逻辑运算符,三目运算符)...-CSDN博客

运算符划分

按照功能划分：

算术运算符

关系运算符

逻辑运算符

按位运算符

按照参与运算的操作个数进行划分

单目运算符

只有一个操作数如：i++

双目运算符

有两个操作数如：a+b

三目运算符

有三个操作数如：a > b ? 1:0如果a>b时，a = 1，如果a

运算符的优先级表

运算符的优先级分为15级别，1级最高，15级最低

在表达式中优先级高的优先于优先级低的先运算

在一个运算量两侧的，优先级一样时按照运算符的结合性所规定的方向进行运算

优先级

运算符

名称或含义

使用形式

结合方向

说明

[]

数组下标

数组名[常量表达式]

左到右

()

圆括号

(表达式)/函数名(形参表)

成员选择(对象)

对象.成员名

成员选择(指针)

对象指针->成员名

负号运算符

-表达式

右到左

单目运算符

(类型)

强制类型转换

(数据类型)表达式

自增运算符

++变量名/变量名++

单目运算符

自减运算符

--变量名/变量名--

单目运算符

取值运算符

*指针变量

单目运算符

取地址运算符

&变量名

单目运算符

逻辑非运算符

!表达式

单目运算符

按位取反运算符

~表达式

单目运算符

sizeof

长度运算符

sizeof(表达式)

除

表达式/表达式

左到右

双目运算符

乘

表达式*表达式

双目运算符

余数(取模)

整型表达式/整型表达式

双目运算符

加

表达式+表达式

左到右

双目运算符

减

表达式-表达式

双目运算符

左移

变量<

左到右

双目运算符

右移

变量>>表达式

双目运算符

大于

表达式>表达式

左到右

双目运算符

大于等于

表达式>=表达式

双目运算符

小于

表达式

双目运算符

小于等于

表达式<=表达式

双目运算符

等于

表达式==表达式

左到右

双目运算符

不等于

表达式!= 表达式

双目运算符

按位与

表达式&表达式

左到右

双目运算符

按位异或

表达式^表达式

左到右

双目运算符

按位或

表达式|表达式

左到右

双目运算符

逻辑与

表达式&&表达式

左到右

双目运算符

逻辑或

表达式||表达式

左到右

双目运算符

条件运算符

表达式1? 表达式2: 表达式3

右到左

三目运算符

赋值运算符

变量=表达式

右到左

除后赋值

变量/=表达式

乘后赋值

变量*=表达式

取模后赋值

变量%=表达式

加后赋值

变量+=表达式

减后赋值

变量-=表达式

<<=

左移后赋值

变量<<=表达式

>>=

右移后赋值

变量>>=表达式

按位与后赋值

变量&=表达式

按位异或后赋值

变量^=表达式

按位或后赋值

变量|=表达式

逗号运算符

表达式,表达式,…

左到右

从左向右顺序运算

虽然说运算符有很多，但是不用记住，使用小括号()扩起来就好了

结合性简单介绍

c语言中有两种结合性，一种是左结合型，一种是右结合性

左结合性--自左至右运算，右结合性--自右至左运算

左结合性例如：x + y -z，先计算x+y，计算后的结果再减z

右结合性例如：x = y = z，将z的值赋值给y，再将y的值赋值给x

算数运算符表

运算符

术语

示例

结果

正号

负号

-3

加

10 + 5

减

10 - 5

乘

10 * 5

除

10 / 5

取模(取余)

10 % 3

前自增

a=2; b=++a;

a=3; b=3;

后自增

a=2; b=a++;

a=3; b=2;

前自减

a=2; b=--a;

a=1; b=1;

后自减

a=2; b=a--;

a=1; b=2;

#include

int main(int argc, const char * argv[]) {

+ 加法

- 减法

* 乘法

/ 除法

% 取模(取余)

int result;

result = 1 + 1;

printf("加法结果：result = %i\n",result);

result = 1 - 1;

printf("减法结果：result = %i\n",result);

result = 2 * 3;

printf("乘法结果：result = %i\n",result);

result = 10 / 2;

printf("除法结果：result = %i\n",result); // result = 5

result = 10 % 3;

printf("取模结果：result = %i\n",result); // result = 1

return 0;

}

取模运算符的注意点

注意：取模运算只能对整数取模，不能对实数取模

// 注意取模运算只能是整数取模不能是实数取模

// result = 10.5 % 3; // 直接报错

注意：取模运算的正负性，取决于左边的操作数

// 取模运算的正负性，取决于左边的操作数

result = 10 % -3;

printf("取模正负性结果：result = %i\n",result); // result = 1

result = -10 % -3;

printf("取模正负性结果：result = %i\n",result); // result = -1

result = -10 % 3;

printf("取模正负性结果：result = %i\n",result); // result = -1

result = -0 % -3;

printf("取模正负性结果：result = %i\n",result); // result = 0

注意：如果取模运算中，左边操作数小于右边操作数，那结果直接就是左边操作数，不会进行计算了

// 如果取模运算中，左边操作数小于右边操作数，那结果直接就是左边操作数，不会进行计算了

result = 10 % 100;

printf("取模结果：result = %i\n",result); // result = 10

算术运算符的结合性

// 算术运算符的结合性

result = 3 + 4 + 5 + 6;

printf("result的值是%i",result);

算术运算符的优先级和结合性同时存在时

先优先级，再按照结合性

// 优先级+结合性

result = 2 + 3 * 4 -4;

printf("result的值是%i\n",result); // 先计算乘法，再从左至右的结合性计算

类型转换

隐式转换

// 系统自动进行的转换

int number = 10.8;

printf("number的值是%i\n",number); // number = 10,

// 大类型的转换成小类型的，系统会自动进行转换，由大类型转换为小类型，丢失精度

显式转换

// 显式转换-只需要在值前面加(类型)

int value = (int)10.8;

printf("value的值是%i\n",value); // 10;

// 大类型的转换成小类型的，系统会自动进行转换，由大类型转换为小类型，丢失精度

在算术运算中，类型不一致时，系统会先将类型统一，统一成大类型进行计算

// 在算术运算中，类型不一致时，系统会先将类型统一，统一成大类型进行计算

int value2 = 10 + 9.9;

// 10是int类型，9.9是double类型，int类型占4个字节，9.9占8个字节，所以先将int转为double类型

// int value2 = 10.0 + 9.9

// int value2 = 19.9

// value2 是一个int类型，但是右边的19.9是double类型，这时候系统会做隐式转换，大类型转为小类型，既结果为19

printf("value2的值是%i\n",value2); // 19;

算术运算符的注意点-参与运算的操作数是什么类型，那么计算出来的结果就是什么类型

// 算术运算符的注意点-参与运算的操作数是什么类型，那么计算出来的结果就是什么类型

int value3 = 1 / 2;

printf("value3的值是%i\n",value3); // 打印出来的是0

// 此时你会不会觉得是因为定义的变量是int类型导致的呢？那我就换成double类型的看看

double value3 = 1 / 2;

printf("value3的值是%lf\n",value3); // 打印出来的是0.000000 此时还是0

// 是因为右侧参与运算的都是整数，那么计算的结果肯定是整数

// 那么如果需要打印出0.5该怎么办呢？

double value4 = 1.0 / 2; // 此时一个double除以int类型，肯定是都先转换为doublee类型，计算出的结果就是double类型，i定义的变量也是double类型不需要转换所以打印出的是0.500000

printf("value4的值是%.1lf\n",value4);

int value5 = 1.0 / 2;

printf("value5的值是%i\n",value5); // 0

新手注意常犯的错误

// 新手注意饭的错误

double value6 = (double)(1 / 2);

// 右边先计算括号中的1 / 2，那么两个整数相除，结果肯定是整数，所以是0 ，由强转为double类型，为0.000000

printf("value6的值是%lf",value6); // 0.000000

在算术运算符中，实数的计算都是double类型，不是float类型

赋值运算符

最简单的赋值运算符，将等号右边的值赋值给等号左边的变量

赋值运算符的结合性是右结合性

int main(int argc, const char * argv[]) {

// 最简单的赋值运算符，将等号右边的值赋值给等号左边的变量

// 赋值运算符的结合性是右结合性

int number = 10;

int a;

int b;

a = b = 5;

printf("a的值是%i,b的值是%i\n",a,b);

return 0;

}

符合赋值运算符

定义：在赋值符“=”加上其他的二目运算符可构成复合赋值运算符

赋值运算符的作用是将常量、变量或表达式的值赋给某一个变量。

运算符

术语

示例

结果

赋值

a=2; b=3;

加等于

a=0; a+=2; a = a + 2

a=2;

减等于

a=5; a-=3; a = a - 3

a=2;

乘等于

a=2; a*=2; a = a * 2

a=4;

除等于

a=4; a/=2; a = a / 2

a=2;

模等于

a=3; a%2; a = a % 2

a=1;

int a = 0;

a += 3; // 这种是直接进行赋值，运算效率要好

a = a +3; // 这一种是不是先计算再赋值给a

printf("a的结果是%i\n",a);

// 复合赋值运算，会先进行右边的表达式得到的值在赋值给左边的变量

自增，自减运算符

自增自减的第一种写法：变量++，变量--

int result = 10;

result++;

printf("变量++，自增后的result值为：%i\n",result); // 12

// 如果想让某一个数减1，可以使用变量--，--变量

int value = 5;

value--;

printf("变量--，自增后的value值为：%i\n",value); // 4

自增自减的第二种写法： --变量，++变量

// 第二种写法：++变量，--变量

int result1 = 10;

++result1;

printf("++变量，自增后的result1值为：%i\n",result1); // 11

int result2 = 5;

--result2;

printf("++变量，自增后的result1值为：%i\n",result2); // 4

++,-- 在变量前面和++，-- 在变量后面的区别(在变量之前先运算再自增,在变量之后先自增再运算)

// ++,-- 在变量前面和++，-- 在变量后面的区别

// ++ , -- 在后面时，先参与运算然后再自增

int a = 10;

int b = a++;

printf("a的值是%i，b的值是%i\n",a,b);// a的值是11，b的值是10 注意看b的值是10,而不是11,这里是a先赋值给b,然后再自增的

// ++ --在变量之前时,是先自增再赋值

int c = 10;

int d = ++c;

printf("c的值是%i，d的值是%i\n",c,d); // c的值是11,d的值是11 注意看这里d的值同样是11,所以c是先自增再赋值给d

自增,自减练习

// 练习

int a = 10;

int b = (a++) + (++a);

// b = a++ ,此时a++的结果是11, 后面++a在a=11的基础上再自增,那么a的值就是12了,10+12

// a =12

printf("b的值是%i,a的值是%i\n",b,a);

int a = 10;

int b = (a++) + (a++);

printf("b的值是%i,a的值是%i\n",b,a); // b = 10 + 11 , a = 12

int a = 10;

int b = (++a) + (++a);

printf("b的值是%i,a的值是%i\n",b,a); // b = 11 + 12 ,a = 12

int a = 10;

int b = (++a) + (a++);

printf("b的值是%i,a的值是%i\n",b,a); // b = 11 + 11, a = 12

int a = 10;

int b = (a++) + (a--);

printf("b的值是%i,a的值是%i\n",b,a); // b = 10 + 11 , a = 10

自增的拆分

// 自增的拆分

int a = 10;

int b = a++;

// 拆分:

// 1, int b = a;

// 2, int a = a+1;

printf("b的值是%i,a的值是%i\n",b,a); // b = 10,a = 11

int c = 10;

int d = ++c;

// 拆分

// 1,int c = c + 1;

// 2,int d = c;

printf("d的值是%i,c的值是%i\n",d,c);

// 拆分之后,只是两个表达式的顺序反了. 如果有时确实难懂的话不妨拆分一下

sizeof运算符

介绍:sizeof运算符可以用来计算一个变量或一个常量,一种数据类型所占的内存节数

格式:sizeof(变量/常量/数据类型)

注意:sizeof 不是一个函数而是一个运算符(只要是运算符就会有一个返回值)

计算常量的内存字节

// 使用 sizeof 计算常量的内存字节

int number = sizeof(10.9);

printf("10.9的e内存字节是%i\n",number); // 8

计算变量的内存字节

int a = 10;

// int number = sizeof(a); // 只要是运算符就会有返回值

int number = sizeof a; // 不加s括号e也可以

printf("a的内存字节是%i\n",number);

计算数据类型的内存字节(sizeof的括号不能省略)

// 使用 sizeof 计算数据类型的内存字节

int numChar = sizeof(char);

printf("char 数据类型占用%i个字节\n",numChar); // 1

int numInt = sizeof(int);

printf("int 数据类型占用%i个字节\n",numInt); // 4

int numDouble = sizeof(double);

printf("double 数据类型占用%i个字节\n",numDouble); // 8

int numFloat = sizeof(float);

printf("float 数据类型占用%i个字节\n",numFloat); // 8

逗号运算符

在 C 语言中逗号也是一个运算符,称之为逗号运算符,其功能是把多个表达式连接起来组成一个表达式,成为逗号表达式

格式: 表达式 1,表达式 2,表达式....表达式 n;

例如:a = a + 1,b = 3*4;

结合性:从左到右结合性

// 逗号运算符,从左到右依次计算表达式的结果,只要是运算符就会有结果,逗号运算符也不例外

int a = 10;

int b = 5;

int result;

a = a + 10,b = b - 1,result = a + b;

printf("a的值是%i,b的值是%i,result 的值是%i\n",a,b,result);

逗号表达式的结果是最后一个表达式的结果

// 定一个一个变量 number 来接收逗号表达式的结果,每个表达式用括号括起来,整体再括起来,逗号表达式的结果是最后一个逗号表达式的结果

int number = ((a = a + 10),(b = b - 1),(result = a + b));

printf("a 的值是%i,b 的值是%i,result 的值是%i,number 的值是%i\n",a,b,result,number);

关系运算符

在 c 语言中条件成立为真,条件不成立为假,判断条件是否成立就是判断条件的真假

怎么判断条件的真假呢? C 语言中规定任何数值都有自己的真假性,任何非 0 的都为真,也就是说 100,-50,2.3这些都是真,只有 0 是假的

关系运算符的结果只有两个结果,真和假

C 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。

运算符

术语

示例

结果

相等于

4 == 3

不等于

4 != 3

小于

4 < 3

大于

4 > 3

小于等于

4 <= 3

大于等于

4 >= 1

关系运算符的返回值要么真要么假

// > , < , >= , <= , == , !=

int a = 10;

int b = 5; // 怎么知道 a>b 呢? 任何的运算符都有结果

int c = 20;

int result = a > b;

int result1 = a > c;

printf("result的值是%i\n",result); // 1

printf("result1的值是%i\n",result1); // 0

关系运算符的优先级: > < >= <=的优先级大于 == , !=

// 关系运算符的优先级: > < >= <=的优先级大于 == , !=

int a = 10;

int b = 5;

int result = 1 == a > b; // 先计算 a 是否大于 b,再拿这个结果与 1 是否相等,

printf("result 的值是%i",result); // 1

算术运算符的优先级大于关系运算符(比较运算符)

// 算术运算符的优先级大于关系运算符

int result = 1 + 1 > 2+2;

printf("result 的值是%i\n",result); // 0,先计算 1+1,在计算 2+2,再拿 2>4?

关系运算符的结合性是左结合性

// 关系运算符的结合性是左结合性

int result = 10 > 5 > 20;

printf("result 的值是%i\n",result); // 0,先计算 10>5,再拿这个值与 20做比较

如果优先级和结合性同时存在,那就先优先级,再结合性

// 如果优先级和结合性同时存在,那就先优先级,再结合性

int result = 10 + 1 > 5 + 4 == 3 > 1;

// 先计算 10+1,再计算 5+4,这两个算术运算符,得出 11 > 9 == 3>1

// 再计算 11 > 9 ,和 3 > 1 这两个优先级比较高的比较运算符表达式,

// 最后计算 1 == 1 等于的表达式

printf("result 的值是%i\n",result); // 11 > 9 == 3 > 1 ---> 1 == 1 ---> 1

开发中没有人会按照上面那么写的

int result1 = (10+1) > (5+4) == (3>1);

printf("result1 的值是%i\n",result1); // h实际开发中为了阅读,还是加上括号

逻辑运算符

有时候我们需要满足多个条件同时成立才能执行代码,比如登录:需要输入正确的用户名,和正确的密码,才能登录.所以c 语言提供了逻辑运算符

C 语言中提供了三个逻辑运算符

&& 逻辑与表达式 1 && 表达式 2

|| 逻辑非表达式 1 || 表达式 2

! 逻辑非 ! 表达式 2

逻辑运算符的运算结果只有两个真和假

逻辑与:只有表达式都为真,结果才是真,其余都是假

结合性:从左至右

// 逻辑与(一假则假)

int result = 10 > 7 && 5 > 3; // 10>7为真,5>3 为真

printf("result = %i\n",result); // 1

int result1 = 10 > 90 && 8 >1; // 10 > 90为假

printf("result1 = %i\n",result1); // 0

逻辑或:只要有一个表达式为真,结果就是真,如果表达式都是假,结果才是假

结合性:从左至右

// 逻辑或 (一真则真)

int result = 10 > 8 || 9 > 7;

printf("result = %i\n",result); // 都为真--真

int result1 = 10 > 8 || 9 > 10;

printf("result1 = %i\n",result1); // 一个为真--真

int result2 = 10 > 11 || 9 > 10;

printf("result2 = %i\n",result2); // 都为假--假

int result3 = 10 > 11 || 9 > 8; // 一个为真--真

printf("result3 = %i\n",result3);

逻辑非(如果表达式为真,则为假,如果表达式为假,则为真)---取反

结合性:从右至左

// 逻辑非

int result = ! 10; // 0

int result1 = ! 0; // 1

printf("result = %i\n",result);

printf("result1 = %i\n",result1);

注意点;C 语言规定,任何数值都有真假性,非 0 既真,所有的逻辑运算符可以直接约数值进行计算

逻辑与的特点是一假则假,所以如果前面的表达式是假的话,那么后面的表达式就不会计算了

int a = 10;

int result = 10 < 8 && a++ > 5; // a = 10,result = 0

// 由于 10 < 8 为假,所以后面的表达式就不会计算了,a++ 后,a 的值就没有自增

int b = 20;

int result1 = 10 > 8 && b++ >5; // 10 > 8 为真,后面的表达式继续计算,所以 b 的值是 21

printf("a = %i,result = %i\n",a,result);

printf("b = %i,result1 = %i\n",b,result1);

逻辑或的特点是一真则真,所以如果前面的表达式是真的话,那么后面的表达式就不会计算了

int a = 10;

int result = 10 > 8 || a++ > 5; // a = 10,result = 0

// 由于 10 > 8 为真,所以后面的表达式就不会计算了,a++ 后,a 的值就没有自增

int b = 20;

int result1 = 10 < 8 || b++ >5; // 10 < 8 为假,后面的表达式继续计算,所以 b 的值是 21

printf("a = %i,result = %i\n",a,result);

printf("b = %i,result1 = %i\n",b,result1);

以上两个逻辑运算符的特点称之为:逻辑运算符的短路

判断一个数值是否在一个范围内

int a = 10;

if (a > 3 && a < 100){

printf("a在 3-100 之间");

} else{

printf("a 不在 3-100 之间");

}

三目运算符

格式:条件表达式 ? 结果 A: 结果 B

如果表达式为真,返回结果 A,如果表达式为假,返回结果 B

结合性:左结合性

// 三目运算符

int a = 10;

int b = 20;

int result = a > b;

printf("result = %i\n",result);

// 如果我想获取两个数之间的最大数呢?

if (a>b){

printf("a 和 b 之间最大数是%i\n",a);

}else{

printf("a 和 b 之间最大数是%i\n",b);

}

// 可是上面的办法太麻烦了,x要写这么多行代码

int maxNum = a > b ? a:b; // 这句话的意思是,如果a> b,那就返回 a,如果 a 不大于 b 的话,那就返回 b

printf("a 和 b 之间最大数是%i\n",maxNum);

三目运算符练习

// 从控制台输入三个整数,返回最大的整数

printf("请输入三个整数以逗号隔开,回车结束\n");

int num1,num2,num3;

scanf("%i,%i,%i",&num1,&num2,&num3);

int temp = num1 > num2 ? num1 : num2; // 比较 num1 和num2 中的最大值

int maxNum = temp > num3 ? temp : num3; // 拿到 num1 和 num2 的最大值再与 num3 做比较,返回最大值

printf("num1,num2,num3 之间的最大值是:%i\n",maxNum);

int maxNum1 = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;

// 不推荐这种写法是因为,问号之前计算了一次num1 和num2 的最大值,问号表达式之后又计算了一次,无疑消耗了性能

printf("num1,num2,num3 之间的最大值是:%i\n",maxNum1);

哎呀妈呀,运算符终于写完了!