C语言操作符详解

C 语言操作符详解：从表达式构成到求值顺序

在 C 语言中，操作符是连接数据与逻辑的桥梁。一个看似简单的表达式，往往同时涉及运算规则、类型转换、优先级、结合性以及求值顺序。真正掌握操作符，不只是记住符号的含义，更要学会判断表达式的结果是否明确、代码是否安全、写法是否便于维护。

本文从常见操作符出发，系统梳理 C 语言表达式的组成，并重点讨论最容易出错的优先级与求值顺序问题。

一、操作符的主要类别

C 语言中的操作符大致可以分为以下几类：

• 算术操作符：+、-、*、/、%
• 移位操作符：<<、>>
• 位操作符：&、|、^
• 赋值操作符：= 以及各种复合赋值操作符
• 单目操作符：!、~、++、--、&、*、sizeof 等
• 关系操作符：>、>=、<、<=、==、!=
• 逻辑操作符：&&、||、!
• 条件操作符：? :
• 逗号操作符：,
• 其他运算形式：下标引用、函数调用、结构体成员访问等

不同类别的操作符解决的问题不同：算术操作符处理数值计算，位操作符处理二进制位，逻辑操作符组织条件判断，而赋值和自增自减则经常会改变对象的值。

二、算术操作符：先分清整数与浮点数

1. 基本运算

+、-、*、/ 可以用于整数和浮点数；% 只能用于整数。

int a = 7;
int b = 3;

printf("%d\n", a / b);  // 2，整数除法
printf("%d\n", a % b);  // 1，取余

只要除法表达式中至少有一个操作数是浮点数，就会进行浮点除法：

double result = 7 / 3.0;  // 约为 2.333333

因此，7 / 3 与 7 / 3.0 的结果完全不同。进行除法时，要先确认参与运算的数据类型。

2. 取余运算的用途

取余常用于判断奇偶、循环计数、分解数字等场景：

if (number % 2 == 0) {
    printf("偶数\n");
}

需要注意，% 的两个操作数都必须是整数，不能直接用于浮点数。

三、移位操作符：把运算落实到二进制

移位操作符只能用于整数。

1. 左移 <<

左移的基本效果是：二进制位整体向左移动，右侧补 0，左侧超出范围的位被丢弃。

int value = 5;       // 二进制可看作 0101
int result = value << 1;

在满足类型和溢出条件时，左移一位通常相当于乘以 2，左移两位通常相当于乘以 4。但不要把这种关系机械地应用到所有整数，尤其要注意有符号数、溢出和位宽问题。

2. 右移 >>

右移时，右侧的位被丢弃，左侧如何补位取决于具体情况：

• 逻辑右移：左侧补 0，常见于无符号数。
• 算术右移：左侧补原来的符号位，常见于某些有符号数实现。

对于移位运算，要特别注意以下问题：

• 移位量不能为负数。
• 移位量不能大于或等于被移位类型的位宽。
• 对有符号数进行移位时，要考虑标准规则、实现差异以及溢出风险。
• 不要依赖编译器之间可能不同的行为。

四、位操作符：直接处理每一个二进制位

位操作符的操作数必须是整数，主要包括：

操作符	名称	作用
&	按位与	两个位都为 1，结果才为 1
		按位或
^	按位异或	两个位不同为 1，相同为 0
~	按位取反	每一位 0、1 互换

例如：

int x = 1;
int y = 2;

int and_result = x & y;
int or_result  = x | y;
int xor_result = x ^ y;

位操作广泛用于标志位管理、权限控制、嵌入式开发、压缩存储和底层数据处理。

1. 使用异或交换两个整数

异或具有以下性质：

• a ^ a 等于 0
• a ^ 0 等于 a
• a ^ b ^ a 等于 b

因此，可以利用异或完成两个整数的交换：

int a = 10;
int b = 20;

a = a ^ b;
b = a ^ b;
a = a ^ b;

这种写法可以展示异或的性质，但在实际业务代码中，直接使用临时变量通常更清晰，也更不容易受到别名问题影响。如果 a 与 b 实际指向同一个存储位置，异或交换可能把结果变成 0，所以不能盲目使用。

2. 统计整数二进制中 1 的个数

一种直观方法是不断查看最低位，再将数字右移：

int count_ones_basic(unsigned int value)
{
    int count = 0;

    while (value != 0) {
        if (value % 2 == 1) {
            count++;
        }
        value = value / 2;
    }

    return count;
}

也可以逐位检查：

int count_ones_by_bit(unsigned int value)
{
    int count = 0;

    for (int bit = 0; bit < 32; bit++) {
        if (value & (1u << bit)) {
            count++;
        }
    }

    return count;
}

更高效的写法利用了一个重要性质：value & (value - 1) 会消除最低位的那个 1。因此循环次数等于二进制中 1 的数量：

int count_ones(unsigned int value)
{
    int count = 0;

    while (value != 0) {
        count++;
        value = value & (value - 1);
    }

    return count;
}

这种方法不仅效率高，也体现了位运算在算法中的价值。

五、赋值操作符：给变量更新状态

最基本的赋值形式是：

int weight = 120;
weight = 89;

赋值表达式本身也有值，因此可以连续赋值：

int a = 0;
int x = 0;
int y = 20;

a = x = y + 1;

这种写法是合法的，但连续赋值会增加阅读和调试成本。很多时候，拆开写更直观：

x = y + 1;
a = x;

1. 复合赋值操作符

复合赋值可以把运算和赋值合并起来：

复合操作符	等价形式
+=	x = x + value
-=	x = x - value
*=	x = x * value
/=	x = x / value
%=	x = x % value
<<=	x = x << value
>>=	x = x >> value
&=	x = x & value
	=
^=	x = x ^ value

例如：

int score = 10;
score += 5;

需要留意的是，复合赋值表达式中的左操作数通常只求值一次，因此当左侧包含复杂表达式时，它不只是单纯的字符缩写。

六、单目操作符：一个操作数也能完成很多事情

单目操作符只需要一个操作数：

操作符	含义
!	逻辑非
-	取负值
+	取正值
&	取地址
*	解引用、间接访问
sizeof	获取对象或类型占用的字节数
~	按位取反
++	自增
--	自减
(类型)	强制类型转换

1. 逻辑非 !

在 C 语言中，0 表示假，非 0 表示真。逻辑非会把真变成假，把假变成真：

int value = 0;
if (!value) {
    printf("value 为假\n");
}

2. sizeof

sizeof 用于获取对象或类型所占的字节数：

int number = 0;
size_t size1 = sizeof(number);
size_t size2 = sizeof(int);

它的结果类型是 size_t。在使用 sizeof 的结果进行打印、比较或参与计算时，应注意类型匹配。

3. 自增与自减

++ 和 -- 都有前置与后置两种形式：

int value = 10;
int first = ++value;  // 先加 1，再使用新值
int second = value++; // 先使用旧值，再加 1

单独使用时，前置和后置通常都很容易理解；但如果把它们与同一个变量的其他读写混在一个复杂表达式中，就可能造成未定义行为或难以理解的结果。实际编程中，建议让一条语句只完成一个清晰的状态变化。

4. 取地址与解引用

& 可以获得对象的地址，* 可以通过指针访问地址对应的对象：

int value = 10;
int *pointer = &value;

*pointer = 20;

这里的 & 与按位与使用相同符号，但上下文不同，含义也不同；* 同时还可以表示乘法、指针声明和解引用，阅读代码时需要结合语境判断。

5. 强制类型转换

强制类型转换可以显式改变表达式的类型：

int total = 7;
int count = 2;
double average = (double)total / count;

如果不进行转换，total / count 会先执行整数除法，结果会丢失小数部分。

七、关系操作符与逻辑操作符

1. 关系操作符

关系操作符用于比较两个表达式：

• ：大于

• =：大于等于

• <：小于
• <=：小于等于
• ==：等于
• !=：不等于

关系表达式的结果为 0 或 1：

int result = (10 > 3);  // 1

判断相等时要使用 ==，不要误写成赋值操作符 =：

if (value == 10) {
    printf("value 等于 10\n");
}

2. 逻辑与、逻辑或

• &&：逻辑与，两边都为真时结果才为真。
• ||：逻辑或，只要有一边为真，结果就为真。
• !：逻辑非，真变假、假变真。

&& 和 || 具有短路求值特性：

• A && B 中，如果 A 为假，B 不再求值。
• A || B 中，如果 A 为真，B 不再求值。

if (pointer != NULL && *pointer == 10) {
    printf("指针有效且指向 10\n");
}

上例中，只有在 pointer != NULL 为真时，才会访问 *pointer，这正是短路求值的实际用途。

八、条件操作符：简洁表达二选一

条件操作符的形式是：

条件表达式 ? 真值表达式 : 假值表达式

例如：

int max = a > b ? a : b;

它适合表达简单的二选一逻辑。如果两个分支中包含复杂操作，或者嵌套层次过深，使用 if...else 往往更清晰。

九、逗号操作符：依次求值，结果取最后一项

逗号表达式会从左到右依次求值，整个表达式的结果是最后一个表达式的值：

int value = (a = 3, b = 4, a + b);

执行顺序是先给 a 赋值，再给 b 赋值，最后计算 a + b。逗号在函数参数列表、变量声明等场景中还可能只是分隔符，不要把所有逗号都理解为逗号操作符。

十、下标、函数调用与结构体成员访问

这些形式虽然不一定单独写成传统意义上的运算符，但同样属于表达式构成的重要部分：

array[index];       // 下标引用
function(arg);      // 函数调用
object.member;      // 结构体成员访问
pointer->member;    // 指针访问结构体成员

其中，下标引用和函数调用的优先级较高。复杂表达式中如果同时出现指针、数组和函数调用，建议使用括号明确意图，避免依赖记忆。

十一、优先级、结合性与求值顺序不是一回事

这是 C 语言操作符中最容易混淆的部分。

1. 优先级决定如何分组

例如：

result = a + b * c;

由于乘法优先级高于加法，它等价于：

result = a + (b * c);

再如：

result = a * b + c * d + e * f;

优先级可以帮助编译器确定乘法和加法的分组关系，但不能保证所有子表达式按照人们想象的先后顺序执行。

2. 结合性决定同级操作符的结合方向

很多同级操作符具有从左到右的结合性，例如：

value = a - b - c;

通常按下面的方式理解：

value = (a - b) - c;

赋值操作符通常具有从右到左的结合性：

a = b = c;

相当于先完成 b = c，再把结果赋给 a。但结合性仍然只是表达式分组规则，并不等于完整的执行顺序。

3. 求值顺序由语言规则决定

优先级和结合性不能决定所有操作数的实际求值先后。尤其是函数参数、复杂算术表达式中的多个子表达式，执行顺序可能未被语言规定。

例如：

answer = fun() - fun() * fun();

我们可以确定乘法与减法的分组关系，但不能仅凭优先级确定三个 fun() 调用谁先执行。如果 fun() 会修改共享状态，程序结果就可能因编译器或优化方式不同而不同。

十二、复杂表达式中的未定义行为

如果一个变量在同一个完整表达式中被多次修改，且这些修改之间没有明确的求值顺序，就可能产生未定义行为。

例如：

c + --c;

这里既读取 c，又通过 --c 修改 c，读取和修改之间没有可靠的顺序关系，不能依赖任何特定结果。

下面这种写法更加危险：

i = i-- - --i * (i = -3) * i++ + ++i;

一个表达式里同时出现多次自增、自减、赋值和读取，已经无法建立唯一、清晰的求值路径。这类代码不应该通过"多运行几次"来猜结果，而应直接重写。

更安全的改写方式是拆分步骤：

int change = i--;
i = i - 1;
int reset = -3;
i = reset;

具体业务逻辑需要根据原意重新组织，但原则始终是：让变量的每次修改都具有明确的语句边界。

十三、常见优先级速查

下面给出一份从高到低的简化顺序，便于日常查阅：

优先级层次	操作符	结合性
高	()、\[\]、函数调用、成员访问	从左到右
	++、--、!、~、一元 +、一元 -、*、&、sizeof、类型转换	从右到左
	*、/、%	从左到右
	+、-	从左到右
	<<、>>	从左到右
	关系操作符	从左到右
	==、!=	从左到右
	&、^、
	&&、
	?:	从右到左
	赋值及复合赋值	从右到左
低	,	从左到右

这张表可以帮助我们理解表达式，但不建议在生产代码中依赖复杂优先级。只要存在阅读歧义，就主动加括号。

十四、写出可靠表达式的几个原则

1. 复杂表达式主动加括号：不要让读者依靠记忆猜优先级。
2. 一次只修改一个状态：避免在同一表达式中混合多次自增、自减和赋值。
3. 区分 = 与 ==：赋值是更新状态，比较是判断条件。
4. 区分 & 与 &&：前者按位运算，后者逻辑运算。
5. 区分 | 与 ||：前者按位或，后者逻辑或。
6. 移位前检查类型和移位量：尤其要注意有符号数、负数和位宽。
7. 不要把优先级当成执行顺序：表达式分组明确，不代表子表达式调用顺序明确。
8. 遇到副作用就考虑拆分：代码变长一点，通常能换来可读性和可移植性。

结语

操作符看起来只是一些符号，但它们决定了表达式如何计算、变量如何变化，以及程序是否具有确定行为。学习操作符时，不能只停留在"这个符号是什么意思"，还要进一步理解：它作用于什么类型、优先级如何、是否具有短路特性、是否会产生副作用，以及求值顺序是否被语言明确规定。

当一个表达式复杂到需要反复推演、依赖编译器输出或依赖运行结果猜测时，最好的解决方案通常不是继续寻找"正确答案"，而是把表达式拆开，使用更清晰、更可靠的代码表达意图。