C语言——运算符

1.算术运算符

假设A=6，B=4。

运算符	描述	实例
+	两个数相加	A + B 结果为 10
-	第一个数减去第二个数	A - B 结果为 2
*	两个数相乘	A * B 结果为 24
/	第一个数除以第二个数	A / B 结果为 1
%	取模，第一个数除以第二个数的余数	A % B 结果为 2
++	自增运算符，值增加 1	A++ 结果为 7
--	自减运算符，值减少 1	B-- 结果为 3

示例代码：

#include<stdio.h>
int main()
{
    int a,b;
    a=6;
    b=4;

    //算术运算符
    printf("算术运算符\n");
    printf("a=%d，b=%d\n",a,b);//输出a,b的值
    printf("a+b=%d\n",(a+b));//相加
    printf("a-b=%d\n",(a-b));//相减
    printf("a*b=%d\n",(a*b));//相乘
    printf("a/b=%d\n",(a/b));//相除
    printf("a%%b=%d\n",(a%b));//取模
    a++;//自增：a++为先运算再自增，++a为先自增再运算
    printf("a++ :%d\n",a);
    b--;//自减：b++为先运算再自减，++b为先自减再运算
    printf("b-- :%d\n",b);
    printf("\n");
    return 0;
}

运行结果：

算术运算符
a=6，b=4
a+b=10
a-b=2
a*b=24
a/b=1
a%b=2
a++ :7
b-- :3

 

2.关系运算符

假设A=6，B=4。

运算符	描述	实例
==	判断两个值是否相等，相等则为真	A==B 返回假
!=	判断两个值是否相等，不相等则为真	A!=B 返回真
>	判断左边的值是否大于右边的值，是则为真	A>B 返回真
<	判断左边的值是否小于右边的值，是则为真	A<B 返回假
>=	判断左边的值是否大于等于右边的值，是则为真	A>=B 返回真
<=	判断左边的值是否小于等于右边的值，是则为真	A<=B 返回假

 

示例代码：

#include<stdio.h>
int main()
{
    int a,b;
    a=6;
    b=4;
    //关系运算符，0为假，1为真，非0为真
    printf("关系运算符，0为假，1为真，非0为真\n");
    printf("a=%d，b=%d\n",a,b);//输出a,b的值
    printf("a==b的值：%d\n",(a==b));//返回a==b的值
    printf("a!=b的值：%d\n",(a!=b));//返回a!=b的值
    printf("a>b的值：%d\n",(a>b));//返回a>b的值
    printf("a<b的值：%d\n",(a<b));//返回a<b的值
    printf("a>=b的值：%d\n",(a!=b));//返回a>=b的值
    printf("a<=b的值：%d\n",(a!=b));//返回a<=b的值
    printf("\n");
    return 0;
}

运行结果：

关系运算符，0为假，1为真，非0为真
a=6，b=4
a==b的值：0
a!=b的值：1
a>b的值：1
a<b的值：0
a>=b的值：1
a<=b的值：1

 

3.逻辑运算符

假设A=1（即值为真），B=0（即值为假）。

运算符	描述	实例
&&	逻辑与。如果两个值都非0，则为真。	(A && B) 为假。
||	逻辑或。如果两个值有一个非0，则为真。	(A || B) 为真。
!	逻辑非。真的逻辑非为假，假的逻辑非为真。	!A 为假  !B 为真

示例代码：

#include<stdio.h>
int main()
{
    //逻辑运算符，0为假，1为真，非0为真
    printf("逻辑运算符，0为假，1为真，非0为真\n");
    int a=1;
    int b=0;
    printf("a=%d，b=%d\n",a,b);//输出a,b的值
    printf("a&&b的值：%d\n",(a&&b));//逻辑与，返回a&&b的值
    printf("a||b的值：%d\n",(a||b));//逻辑或，返回a||b的值
    printf("!a的值：%d\n",(!a));//逻辑非，返回!a的值
    printf("\n");
    return 0;
}

运行结果：

逻辑运算符，0为假，1为真，非0为真
a=1，b=0
a&&b的值：0
a||b的值：1
!a的值：0

 

 4.位运算符

位运算符有&(位与AND)、|(位或OR) 、^(位异或XOR)、~(取反NOT)

A	B	A&B	A|B	A^B	~A
0	0	0	0	0	1
0	1	0	1	1	1
1	1	1	1	0	0
1	0	0	1	1	0

 

运算符	描述	实例
&	按位与操作，按二进制位进行"与"运算。运算规则： 0&0=0; 0&1=0; 1&0=0; 1&1=1;	(A & B) 将得到 12，即为 0000 1100
|	按位或运算符，按二进制位进行"或"运算。运算规则： 0|0=0; 0|1=1; 1|0=1; 1|1=1;	(A | B) 将得到 61，即为 0011 1101
^	异或运算符，按二进制位进行"异或"运算。运算规则： 0^0=0; 0^1=1; 1^0=1; 1^1=0;	(A ^ B) 将得到 49，即为 0011 0001
~	取反运算符，按二进制位进行"取反"运算。运算规则： ~1=-2; ~0=-1;	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。

 

5.移位运算符

运算符	描述	实例
<<	二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。	A >> 2 将得到 15，即为 0000 1111

示例代码：

#include<stdio.h>
int main()
{
    //位运算符
    int  a = 60;    /* 60 = 0011 1100 */
    int b = 13;    /* 13 = 0000 1101 */
    printf("位运算符\n");
    printf("a=%d，b=%d\n",a,b);//输出a,b的值
    printf("a&b的值：%d\n",(a&b));//位与，返回a&b的值
    printf("a|b的值：%d\n",(a|b));//位或，返回a|b的值
    printf("a^b的值：%d\n",(a^b));//位异或，返回a^b的值
    printf("~a的十进制值：%d\n",(~a));//位取反，返回~a的值
    printf("\n");

    //移位运算符
    printf("移位运算符\n");
    printf("a=%d，b=%d\n",a,b);//输出a,b的值
    printf("a<<2的值：%d\n",(a<<2));//a的各位数全部向左移2位
    printf("a>>2的值：%d\n",(a>>2));//a的各位数全部向右移2位
    printf("\n");
    return 0;
}

运行结果：

位运算符
a=60，b=13
a&b的值：12
a|b的值：61
a^b的值：49
~a的十进制值：-61

移位运算符
a=60，b=13
a<<2的值：240
a>>2的值：15

 

 6.赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
|=	按位或且赋值运算符	C |= 2 等同于 C = C | 2

示例代码：

#include<stdio.h>
int main()
{
    //赋值运算符
    int a = 21;
    int c ;
    printf("赋值运算符\n");
    printf("a=%d\n",a);//输出a的值

    c =  a;
    printf("c=a运算，c 的值 = %d\n", c );

    c +=  a;
    printf("c+=a运算，c 的值 = %d\n", c );

    c -=  a;
    printf("c-=a运算，c 的值 = %d\n", c );

    c *=  a;
    printf("c*=a运算，c 的值 = %d\n", c );

    c /=  a;
    printf("c/=a运算，c 的值 = %d\n", c );
    printf("\n");

    c  = 200;
    printf("a=%d,c=%d\n",a,c);//输出a,c的值
    c %=  a;
    printf("c%%=a运算，c 的值 = %d\n", c );

    c <<=  2;
    printf("c<<=a运算，c 的值 = %d\n", c );

    c >>=  2;
    printf("c>>=a运算，c 的值 = %d\n", c );

    c &=  2;
    printf("c&=a运算，c 的值 = %d\n", c );

    c ^=  2;
    printf("c^=a运算，c 的值 = %d\n", c );

    c |=  2;
    printf("c|=a运算，c 的值 = %d\n", c );
    return 0;
}

运行结果：

赋值运算符
a=21
c=a运算，c 的值 = 21
c+=a运算，c 的值 = 42
c-=a运算，c 的值 = 21
c*=a运算，c 的值 = 441
c/=a运算，c 的值 = 21

a=21,c=200
c%=a运算，c 的值 = 11
c<<=a运算，c 的值 = 44
c>>=a运算，c 的值 = 11
c&=a运算，c 的值 = 2
c^=a运算，c 的值 = 0
c|=a运算，c 的值 = 2

 

7.其他运算符

运算符	描述	实例
sizeof()	返回变量的大小。	sizeof(a) 将返回 4，其中 a 是整数。
&	返回变量的地址。	&a; 将给出变量的实际地址。
*	指向一个变量。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则值为 :前的值 ； 否则值为 :后的值。

示例代码：

#include<stdio.h>
int main()
{
    //其他运算符
    int a = 4;
    short b;
    double c;
    int* ptr;

    /* sizeof 运算符实例 */
    printf("变量 a 的大小 = %lu字节\n", sizeof(a) );
    printf("变量 b 的大小 = %lu字节\n", sizeof(b) );
    printf("变量 c 的大小 = %lu字节\n", sizeof(c) );

    /* & 和 * 运算符实例 */
    ptr = &a;    /* 'ptr' 现在包含 'a' 的地址 */
    printf("a 的值是 %d\n", a);
    printf("*ptr 是 %d\n", *ptr);

    /* 三元运算符实例 */
    a = 10;
    b = (a == 1) ? 20: 30;
    printf( "b 的值是 %d\n", b );

    b = (a == 10) ? 20: 30;
    printf( "b 的值是 %d\n", b );
    return 0;
}

运行结果：

变量 a 的大小 = 4字节
变量 b 的大小 = 2字节
变量 c 的大小 = 8字节
a 的值是 4
*ptr 是 4
b 的值是 30
b 的值是 20

 

8.C语言中运算符优先级

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= |=	从右到左
逗号	,	从左到右

 

 

 

 

 

 

#include<stdio.h>
int main()
{
    int a,b;
    a=6;
    b=4;

    //算术运算符
    printf("算术运算符\n");
    printf("a=%d，b=%d\n",a,b);//输出a,b的值
    printf("a+b=%d\n",(a+b));//相加
    printf("a-b=%d\n",(a-b));//相减
    printf("a*b=%d\n",(a*b));//相乘
    printf("a/b=%d\n",(a/b));//相除
    printf("a%%b=%d\n",(a%b));//取模
    a++;//自增：a++为先运算再自增，++a为先自增再运算
    printf("a++ :%d\n",a);
    b--;//自减：b++为先运算再自减，++b为先自减再运算
    printf("b-- :%d\n",b);
    printf("\n");
    return 0;
}