syxdevcode博客

C-运算符

发表于 更新于 分类于
本文字数： 5.5k 阅读时长 ≈ 5 分钟

C运算符：

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 杂项运算符

算术运算符

假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符 描述 实例
+ 把两个操作数相加 A + B 将得到 30
- 从第一个操作数中减去第二个操作数 A - B 将得到 -10
* 把两个操作数相乘 A*B 将得到 200
/ 分子除以分母 B / A 将得到 2
% 取模运算符，整除后的余数 B % A 将得到 0
++ 自增运算符，整数值增加 1 A++ 将得到 11
-- 自减运算符，整数值减少 1 A-- 将得到 9

取余运算只能针对整数，% 的两边都必须是整数，不能出现小数，否则编译器会报错。
余数可以是正数也可以是负数，由 % 左边的整数决定：

  • 如果 % 左边是正数，那么余数也是正数；
  • 如果 % 左边是负数，那么余数也是负数；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
int main()
{
   int a = 21;
   int b = 21;
   int c ;
 
   c = a++;  // 赋值后再加 1 ，c 为 21，a 为 22
   printf("c = a++ ----> c = %d\n", c );
   //输出： c = a++ ----> c = 21

   c = ++b;  // 赋值后再加 1 ，c 为 21，a 为 22
   printf("c = ++b ----> c = %d\n", c );
   //输出： c = ++b ----> c = 22
}

关系运算符

假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符 描述 实例
== 检查两个操作数的值是否相等，如果相等则条件为真。 (A == B) 为假。
!= 检查两个操作数的值是否相等，如果不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (A > B) 为假。
< 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (A < B) 为真。
>= 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (A >= B) 为假。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (A <= B) 为真。

逻辑运算符

假设变量 A 的值为 1，变量 B 的值为 0，则：

&& ：逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。
|| ：逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。
! ：逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

位运算符

& 按位与运算符

按位与操作，按二进制位进行 与 运算。运算规则：

1
2
3
4
0&0=0;   
0&1=0;    
1&0=0;     
1&1=1;

| 按位或运算符

按位或运算符，按二进制位进行 或 运算。运算规则：

1
2
3
4
0|0=0;   
0|1=1;   
1|0=1;    
1|1=1;

^ 异或运算符

异或运算符（xor），按二进制位进行 异或 运算。运算规则：

1
2
3
4
0^0=0;   
0^1=1;   
1^0=1;  
1^1=0;

两个操作数的位中，相同则结果为0，不同则结果为1。

一个数和0异或还是自己，一个数和自己异或是0。

整型变量，利用异或 ^ 来交换两个数的值，而且不引入其他变量。(不能用于浮点型变量)

不推荐使用这种方式

原因：

对于临时变量法，每次赋值只要读取一个变量的值到寄存器，然后再从寄存器写回到另一个变量中即可，前后涉及两次内存写入操作；但是对于异或运算操作，每次都需要读取两个数据到寄存器中，再进行运算操作，之后把结果写回到变量中，前后共需要三次内存写入操作。另外一点，异或操作的代码可读性差。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>

int main( )
{
    unsigned int a=60;         // 0011 1100
    unsigned int b=13;         // 0000 1101
    printf("a=%d,b=%d",a,b);   //输出a，b的值
    printf("\n");
    a=a^b;                     //a=a^b=0011 0001
    b=a^b;                     //b=a^b=0011 1100 相当于b1=(a^b)^b
    a=a^b;                     //a=a^b=0000 1101 相当于a1=(a^b)^((a^b)^b)
    printf("a=%d,b=%d",a,b);   //输出a，b的值

    // 仅用一行代码实现的方法:
    //a^=b^=a^=b;
}

结果：

1
2
a=60，b=13；
a=13，b=60;

~ 取反运算符

取反运算符，按二进制位进行 取反 运算。运算规则：

1
2
~1=-2;   
~0=1;

<< 二进制左移运算符

二进制左移运算符。将一个运算对象的各二进制位全部左移若干位，左边的二进制位丢弃，右边补0。

设变量 A 的值为 60，变量 B 的值为 13

1
2
3
A = 0011 1100
B = 0000 1101
A << 2 将得到 240，即为 1111 0000

>> 二进制右移运算符

二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。

设变量 A 的值为 60，变量 B 的值为 13

1
2
3
A = 0011 1100
B = 0000 1101
A >> 2 将得到 15，即为 0000 1111

不同长度的数据进行位运算

如果两个不同长度的数据进行位运算时，系统会将二者按右端对齐，然后进行位运算。

以 与 运算为例说明如下：C 语言中 long 型占 4 个字节，int 型占 2 个字节，如果一个 long 型数据与一个 int 型数据进行 与 运算，右端对齐后，左边不足的位依下面三种情况补足:

  • （1）如果整型数据为正数，左边补 16 个 0。
  • （2）如果整型数据为负数，左边补 16 个 1。
  • （3）如果整形数据为无符号数，左边也补 16 个 0。

如：long a=123; int b=1; 计算 a & b。
如：long a=123; int b=-1; 计算 a & b。
如：long a=123; unsigned int b=1; 计算 a & b。

实例1

A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

1
2
3
4
5
6
7
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A  = 1100 0011

实例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
 
int main()
{
   unsigned int a = 60;    /* 60 = 0011 1100 */  
   unsigned int b = 13;    /* 13 = 0000 1101 */
   int c = 0;           
 
   c = a & b;       /* 12 = 0000 1100 */ 
   printf("Line 1 - c 的值是 %d\n", c );
 
   c = a | b;       /* 61 = 0011 1101 */
   printf("Line 2 - c 的值是 %d\n", c );
 
   c = a ^ b;       /* 49 = 0011 0001 */
   printf("Line 3 - c 的值是 %d\n", c );
 
   c = ~a;          /*-61 = 1100 0011 */
   printf("Line 4 - c 的值是 %d\n", c );
 
   c = a << 2;     /* 240 = 1111 0000 */
   printf("Line 5 - c 的值是 %d\n", c );
 
   c = a >> 2;     /* 15 = 0000 1111 */
   printf("Line 6 - c 的值是 %d\n", c );
}

结果：

1
2
3
4
5
6
Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

赋值运算符

1
2
3
4
5
6
7
8
9
10
11
=	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

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>
 
int main()
{
   int a = 21;
   int c ;
 
   c =  a;
   printf("Line 1 - =  运算符实例，c 的值 = %d\n", c );
 
   c +=  a;
   printf("Line 2 - += 运算符实例，c 的值 = %d\n", c );
 
   c -=  a;
   printf("Line 3 - -= 运算符实例，c 的值 = %d\n", c );
 
   c *=  a;
   printf("Line 4 - *= 运算符实例，c 的值 = %d\n", c );
 
   c /=  a;
   printf("Line 5 - /= 运算符实例，c 的值 = %d\n", c );
 
   c  = 200;
   c %=  a;
   printf("Line 6 - %%= 运算符实例，c 的值 = %d\n", c );
 
   c <<=  2;
   printf("Line 7 - <<= 运算符实例，c 的值 = %d\n", c );
 
   c >>=  2;
   printf("Line 8 - >>= 运算符实例，c 的值 = %d\n", c );
 
   c &=  2;
   printf("Line 9 - &= 运算符实例，c 的值 = %d\n", c );
 
   c ^=  2;
   printf("Line 10 - ^= 运算符实例，c 的值 = %d\n", c );
 
   c |=  2;
   printf("Line 11 - |= 运算符实例，c 的值 = %d\n", c );
}

结果：

1
2
3
4
5
6
7
8
9
10
11
Line 1 - =  运算符实例，c 的值 = 21
Line 2 - += 运算符实例，c 的值 = 42
Line 3 - -= 运算符实例，c 的值 = 21
Line 4 - *= 运算符实例，c 的值 = 441
Line 5 - /= 运算符实例，c 的值 = 21
Line 6 - %= 运算符实例，c 的值 = 11
Line 7 - <<= 运算符实例，c 的值 = 44
Line 8 - >>= 运算符实例，c 的值 = 11
Line 9 - &= 运算符实例，c 的值 = 2
Line 10 - ^= 运算符实例，c 的值 = 0
Line 11 - |= 运算符实例，c 的值 = 2

其他运算符

sizeof()：返回变量的大小。sizeof(a) 将返回 4，其中 a 是整数。

& 返回变量的地址。 &a; 将给出变量的实际地址。

* 指向一个变量。 *a; 将指向一个变量。

?: 条件表达式。如果条件为真 ? 则值为 X : 否则值为 Y

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
 
int main()
{
   int a = 4;
   short b;
   double c;
   int* ptr;
 
   /* sizeof 运算符实例 */
   printf("Line 1 - 变量 a 的大小 = %lu\n", sizeof(a) );
   printf("Line 2 - 变量 b 的大小 = %lu\n", sizeof(b) );
   printf("Line 3 - 变量 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 );
}

%lu 为 32 位无符号整数。

结果：

1
2
3
4
5
6
7
Line 1 - 变量 a 的大小 = 4
Line 2 - 变量 b 的大小 = 2
Line 3 - 变量 c 的大小 = 8
a 的值是 4
*ptr 是 4
b 的值是 30
b 的值是 20

运算符优先级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
括号成员是老大;      // 括号运算符 []() 成员运算符.  ->

全体单目排老二;      // 所有的单目运算符比如++、 --、 +(正)、 -(负) 、指针运算*、&

乘除余三,加减四;    // 这个"余"是指取余运算即%

移位五，关系六;     // 移位运算符：<< >> ，关系：> < >= <= 等

等与不等排行七;     // 即 == 和 !=

位与异或和位或;     // 这几个都是位运算: 位与(&)异或(^)位或(|)    

"三分天下"八九十;  

逻辑与，逻辑或;    // 逻辑运算符: || 和 &&

十一十二紧挨着;    // 注意顺序: 优先级(||)  底于 优先级(&&) 

条件只比赋值高,    // 三目运算符优先级排到 13 位只比赋值运算符和 "," 高

逗号运算最低级!    //逗号运算符优先级最低

C 运算符