算数运算符

  1. 加减乘除 + - * /
1
2
3
4
int sum = a + b;
int sum = a - b;
int sum = a * b;
int sum = a / b; // int除法默认向下取整
  1. 取模运算 %
1
int p = a % b;

理解为做除法得到的余数，例如7 / 2 = 3…1,1 = 7 % 2

赋值运算符

  1. 直接赋值 =
1
int a = 1;

令a的值为1

  1. 复合赋值 += -= *= /=
1
2
3
4
x += 3;  // 等价于 x = x + 3
x -= 2;  // 等价于 x = x - 2
x *= 4;  // 等价于 x = x * 4
x /= 2;  // 等价于 x = x / 2

比较运算符

== != > < >= <=

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
等于 (==)：判断两个值是否相等。
if (a == b) { /* ... */ }

不等于 (!=)：判断两个值是否不相等。
if (a != b) { /* ... */ }

大于 (>)：判断左侧值是否大于右侧值。
if (a > b) { /* ... */ }

小于 (<)：判断左侧值是否小于右侧值。
if (a < b) { /* ... */ }

大于等于 (>=) 和 小于等于 (<=)：
if (a >= b) { /* ... */ }
if (a <= b) { /* ... */ }

逻辑运算符

&& || !

1
2
3
4
5
6
7
8
与 (&&)：当且仅当两个操作数都为真时，结果为真。
if (a > 0 && b > 0) { /* ... */ }

或 (||)：只要有一个操作数为真，结果就为真。
if (a > 0 || b > 0) { /* ... */ }

非 (!)：取反操作符，返回布尔值的相反值。
if (!isValid) { /* ... */ }

位运算符

  1. 按位与&
    对两个数在二进制下进行与运算，只有对应位都为1时结果才为1
1
2
3
int a = 13;  // 二进制：1101
int b = 11;  // 二进制：1011
int result = a & b;  // result 为 9，二进制：1001
  1. 按位或|
    对两个数在二进制下进行或运算，只要对应位与自身有一个为1，结果就为1
1
2
3
int a = 5;  // 二进制：0101
int b = 3;  // 二进制：0011
int result = a | b;  // result 为 7，二进制：0111
  1. 按位异或^
    对两个数在二进制下进行异或运算，当对应位不同时（一个为1一个为0）结果为1
1
2
3
int a = 5;  // 二进制：0101
int b = 3;  // 二进制：0011
int result = a ^ b;  // result 为 6，二进制：0110
  1. 左移<<
    将一个数的二进制数向左移动指定的位数，右侧补0
1
2
int a = 5; //二进制：0101
int result = a << 1;  // result 为 10，二进制：1010，相当于 a * 2
  1. 右移>>
    将一个数的二进制数向右移动指定的位数，右侧补0
1
2
int a = 5; //二进制：0101
int result = a >> 1;  // result 为 2，二进制：0010，相当于 a / 2 (向下取整)

三目运算符

?: 根据条件不同返回不同的值

1
2
int result = (a > b) ? a : b;  // 如果 a 大于 b，则 result 为 a，否则为 b
?前为一个布尔型变量进行真假判断，为真返回:前面的值，为假返回:后面的值

指针运算符

  1. 地址运算符 &
    获取变量的地址
1
2
int x = 10;
int* ptr = &x;  // ptr 指向 x 的地址
  1. 解引用运算符*
    访问指针所指向的变量的值
1
2
3
4
int x = 10;
int* ptr = &x;      // ptr 指向 x
int value = *ptr;   // value 为 10，解引用 ptr 获取 x 的值
*ptr = 20;          // 将 x 的值改为 20
  1. 指针的自加或自减++ --
1
2
3
4
int arr[] = {1, 2, 3, 4};
int* ptr = arr;       // ptr 指向数组的首元素
ptr++;                 // 现在 ptr 指向 arr[1]
int second = *ptr;    // second 为 2

其他运算符

  1. 自增++
    将变量加1
1
2
x++;  // 后缀自增
++x;  // 前缀自增

这里我们这样理解，一个是执行完之后自增，一个是先自增再执行

1
2
3
4
int a = 5;
int b = a++; //b = 5,a = 6;
int a = 5;
int b = ++a; //b = 6,a = 6;

所以我们定义一个cnt记录数组长度时，经常这样，cnt即为数组长度

1
2
int cnt = 0;
a[++cnt] = number;

当然你也可以这样，前后同一索引代表的元素一样，不过这里cnt-1为数组长度

1
2
int cnt = 1;
a[cnt++] = number;
  1. 自减少--
1
2
x--;  // 后缀自减
--x;  // 前缀自减