在C语言里，运算符优先级规定了表达式中运算符执行的先后顺序。当一个表达式包含多个运算符时，优先级高的运算符会先进行计算。下面我会详细介绍常见运算符的优先级，同时给出示例代码帮助你理解。

1. 最高优先级：括号和访问操作

圆括号 ()

圆括号的优先级是最高的，它可以改变运算的自然顺序。无论括号内是什么运算符，都会先计算括号里的内容。

#include <stdio.h>

int main() {
    int result;
    // 先计算括号内的 2 + 3，得到 5，再乘以 4，结果为 20
    result = (2 + 3) * 4;
    printf("(2 + 3) * 4 的结果是: %d\n", result);
    return 0;
}

数组下标 []

用于访问数组元素，也是高优先级操作。

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    // 直接访问数组 arr 中索引为 2 的元素，也就是 3
    int element = arr[2];
    printf("arr[2] 的值是: %d\n", element);
    return 0;
}

成员选择运算符 . 和 ->

用于访问结构体或联合体的成员。-> 用于通过指针访问，. 用于通过对象访问。

#include <stdio.h>

// 定义一个结构体
struct Student {
    int age;
};

int main() {
    struct Student s = {20};
    struct Student *p = &s;
    // 通过对象访问结构体成员
    int age1 = s.age;
    // 通过指针访问结构体成员
    int age2 = p->age;
    printf("通过对象访问的年龄: %d\n", age1);
    printf("通过指针访问的年龄: %d\n", age2);
    return 0;
}

2. 单目运算符

单目运算符只需要一个操作数，它们的优先级仅次于括号相关操作。

逻辑非 !

对操作数的逻辑值取反，非零值变为 0，0 变为 1。

#include <stdio.h>

int main() {
    int a = 5;
    // a 为非零值，逻辑非运算后为 0
    int result =!a;
    printf("!a 的结果是: %d\n", result);
    return 0;
}

按位取反 ~

对操作数的二进制位取反。

#include <stdio.h>

int main() {
    int a = 5;  // 二进制表示为 00000000 00000000 00000000 00000101
    // 按位取反后为 11111111 11111111 11111111 11111010
    int result = ~a;
    printf("~a 的结果是: %d\n", result);
    return 0;
}

自增 ++ 和自减 --

有前缀和后缀两种形式。前缀形式先改变变量的值，再使用变量；后缀形式先使用变量，再改变变量的值。

#include <stdio.h>

int main() {
    int a = 5;
    // 后缀自增，先使用 a 的值 5，然后 a 变为 6
    int b = a++;
    // 前缀自增，先将 a 变为 7，然后使用 a 的值 7
    int c = ++a;
    printf("b 的值是: %d\n", b);
    printf("c 的值是: %d\n", c);
    return 0;
}

负号 -

将操作数变为其相反数。

#include <stdio.h>

int main() {
    int a = 5;
    // 将 a 变为其相反数 -5
    int result = -a;
    printf("-a 的结果是: %d\n", result);
    return 0;
}

强制类型转换 (类型)

将一个表达式的值转换为指定的类型。

#include <stdio.h>

int main() {
    float a = 5.5;
    // 将浮点数 a 强制转换为整数 5
    int result = (int)a;
    printf("(int)a 的结果是: %d\n", result);
    return 0;
}

指针解引用 * 和取地址 &

* 用于获取指针指向的值，& 用于获取变量的地址。

#include <stdio.h>

int main() {
    int a = 5;
    // 获取变量 a 的地址
    int *p = &a;
    // 通过指针 p 获取其指向的值 5
    int result = *p;
    printf("*p 的结果是: %d\n", result);
    return 0;
}

sizeof 运算符

用于计算数据类型或变量所占用的字节数。

#include <stdio.h>

int main() {
    int a;
    // 计算 int 类型变量所占用的字节数，通常为 4
    int size = sizeof(a);
    printf("sizeof(a) 的结果是: %d\n", size);
    return 0;
}

3. 算术运算符

乘法 *、除法 / 和取模 %

它们的优先级相同，高于加法和减法。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 先计算乘法 2 * 3，再计算加法 5 + 6，结果为 11
    int result1 = a + b * 3;
    // 计算 5 除以 2 的商，结果为 2
    int result2 = a / b;
    // 计算 5 除以 2 的余数，结果为 1
    int result3 = a % b;
    printf("a + b * 3 的结果是: %d\n", result1);
    printf("a / b 的结果是: %d\n", result2);
    printf("a % b 的结果是: %d\n", result3);
    return 0;
}

加法 + 和减法 -

优先级低于乘法、除法和取模。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 先计算 2 + 3，再计算 5 - 5，结果为 0
    int result = a - (b + 3);
    printf("a - (b + 3) 的结果是: %d\n", result);
    return 0;
}

4. 移位运算符

左移 << 和右移 >>

用于对二进制位进行移动操作。

#include <stdio.h>

int main() {
    int a = 5;  // 二进制表示为 00000000 00000000 00000000 00000101
    // 左移 2 位，变为 00000000 00000000 00000000 00010100，即 20
    int result1 = a << 2;
    // 右移 1 位，变为 00000000 00000000 00000000 00000010，即 2
    int result2 = a >> 1;
    printf("a << 2 的结果是: %d\n", result1);
    printf("a >> 1 的结果是: %d\n", result2);
    return 0;
}

5. 关系运算符

小于 <、小于等于 <=、大于 >、大于等于 >=

用于比较两个操作数的大小关系。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 判断 a 是否大于 b，结果为真，用 1 表示
    int result = a > b;
    printf("a > b 的结果是: %d\n", result);
    return 0;
}

等于 == 和不等于 !=

用于判断两个操作数是否相等。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 判断 a 是否不等于 b，结果为真，用 1 表示
    int result = a != b;
    printf("a != b 的结果是: %d\n", result);
    return 0;
}

6. 按位运算符

按位与 &

对两个操作数的对应二进制位进行与运算。

#include <stdio.h>

int main() {
    int a = 5;  // 二进制表示为 00000000 00000000 00000000 00000101
    int b = 3;  // 二进制表示为 00000000 00000000 00000000 00000011
    // 按位与运算后为 00000000 00000000 00000000 00000001，即 1
    int result = a & b;
    printf("a & b 的结果是: %d\n", result);
    return 0;
}

按位异或 ^

对两个操作数的对应二进制位进行异或运算。

#include <stdio.h>

int main() {
    int a = 5;  // 二进制表示为 00000000 00000000 00000000 00000101
    int b = 3;  // 二进制表示为 00000000 00000000 00000000 00000011
    // 按位异或运算后为 00000000 00000000 00000000 00000110，即 6
    int result = a ^ b;
    printf("a ^ b 的结果是: %d\n", result);
    return 0;
}

按位或 |

对两个操作数的对应二进制位进行或运算。

#include <stdio.h>

int main() {
    int a = 5;  // 二进制表示为 00000000 00000000 00000000 00000101
    int b = 3;  // 二进制表示为 00000000 00000000 00000000 00000011
    // 按位或运算后为 00000000 00000000 00000000 00000111，即 7
    int result = a | b;
    printf("a | b 的结果是: %d\n", result);
    return 0;
}

7. 逻辑运算符

逻辑与 &&

只有当两个操作数都为真时，结果才为真。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 判断 a > 0 且 b > 0，结果为真，用 1 表示
    int result = a > 0 && b > 0;
    printf("a > 0 && b > 0 的结果是: %d\n", result);
    return 0;
}

逻辑或 ||

只要有一个操作数为真，结果就为真。

#include <stdio.h>

int main() {
    int a = 5, b = 0;
    // 判断 a > 0 或 b > 0，结果为真，用 1 表示
    int result = a > 0 || b > 0;
    printf("a > 0 || b > 0 的结果是: %d\n", result);
    return 0;
}

8. 条件运算符 ?:

这是 C 语言中唯一的三目运算符，根据条件表达式的值选择不同的结果。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 如果 a > b 为真，结果为 a，否则为 b
    int result = a > b ? a : b;
    printf("a > b ? a : b 的结果是: %d\n", result);
    return 0;
}

9. 赋值运算符

简单赋值 =

将右侧表达式的值赋给左侧的变量。

#include <stdio.h>

int main() {
    int a;
    // 将 5 赋值给变量 a
    a = 5;
    printf("a 的值是: %d\n", a);
    return 0;
}

复合赋值 +=、-=、*=、/=、%= 等

是算术运算符和赋值运算符的结合。

#include <stdio.h>

int main() {
    int a = 5;
    // 等价于 a = a + 3，结果为 8
    a += 3;
    printf("a += 3 后 a 的值是: %d\n", a);
    return 0;
}

10. 逗号运算符 ,

用于将多个表达式连接成一个表达式，从左到右依次计算每个表达式的值，整个逗号表达式的值是最后一个表达式的值。

#include <stdio.h>

int main() {
    int a = 5, b = 2;
    // 先计算 a + 1，再计算 b + 2，整个逗号表达式的值为 b + 2 的结果 4
    int result = (a + 1, b + 2);
    printf("(a + 1, b + 2) 的结果是: %d\n", result);
    return 0;
}

总结

在编写 C 语言代码时，要特别留意运算符的优先级，不然可能会因为运算顺序出错而导致结果不符合预期。要是不确定运算顺序，就可以使用括号来明确指定，这样既能提高代码的可读性，又能保证正确性。