C 语言 | 运算符及逻辑短路机制

斐夷所非2026-01-28 9:10

注：本文为 "C 语言 | 运算符" 相关合辑。

略作重排，未整理去重。

如有内容异常，请看原文。

C 语言中的运算符大全（内附优先级表）

「已注销」 2021-04-16 13:17:24

一、C 语言中的运算符总述

  1. 表达式定义：由一个或多个操作数（变量、常量、字面值）及运算符构成，且符合 C 语言语法规则的式子。

  2. 表达式的值：表达式经计算得到的结果。

  3. 左值与右值

    • 左值：可被写入数据的内存单元（如变量）。
    • 右值：可被读取数据的内存单元（如变量、常量、字面值）。

  4. 运算符完整分类

    运算符类别 具体形式
    算术运算符 +、-、*、/、%、++、--
    关系运算符 >、<、==、!=、>=、<=
    逻辑运算符 &&、`
    赋值运算符 基础：=；算术复合：+=、-=、*=、/=、%=；位复合：&=、`
    位运算符 &、`
    条件运算符 ?:（三元运算符）
    逗号运算符 ,
    指针运算符 &（取地址）、*（间接寻址）
    求字节运算符 sizeof
    特殊运算符 ()、[]、.

  5. 运算符三大属性

    • 优先级：运算符执行的先后次序，数值越高越先执行。
    • 结合性：优先级相同时，表达式的运算顺序由结合性确定。
    • 目数：参与运算的操作数个数，分为一元、二元、三元运算符。

二、各类运算符详细解析

（一）算术运算符

1. 基础算术运算符（+、-、*、/、%）

  • 均为二元运算符，运算规则与数学基本规则一致，结果为右值。

  • 类型规则 ：运算结果类型由操作数类型决定，两个int类型运算结果为int（除法为整除）。

    c 复制代码 
    int a = 10, b = 3;
double c = a/b;    // 结果为 3.000000（int 整除）
c = (double)a/b;   // 结果为 3.333333（强制类型转换）
c = 1.0*a/b;       // 结果为 3.333333（隐式类型转换）

  • 特殊规则 ：/和%的右操作数不能为 0；%要求操作数均为整数，结果符号由左操作数决定。

    c 复制代码 
    printf("%d\n",5%3);  // 2 | printf("%d\n",5%-3); // 2
printf("%d\n",-5%3); // -2| printf("%d\n",-5%-3);// -2

  • 跨语言差异：C 语言负数取余向 0 取整，Python 向负无穷取整，导致结果不同。

2. 自增自减运算符（++、--）

  • 均为一元运算符，--规则与++完全一致。

    • 前置：++i，先自增 1，再取值参与运算。
    • 后置：i++，先取值参与运算，再自增 1。
    c 复制代码 
    int i=0; printf("%d\n",++i); // 1，i 最终为 1
i=0;     printf("%d\n",i++); // 0，i 最终为 1

  • 使用建议：单个表达式中，同一变量仅执行一次自增/自减操作，避免未定义行为。

（二）赋值运算符

1. 简单赋值（=）

  • 二元运算符，优先级仅高于逗号运算符，结合性自右向左 。

    c 复制代码 
    int a,b; b = a = 10; // 先 a=10，后 b=a，均为 10
2. 复合赋值（op=）
  • op为算术/位运算符，是简化写法，a += 3 等价于 a = a + 3，同理-=、*=、&=等。

（三）关系运算符（>、<、==、!=、>=、<=）

  • 均为二元运算符，结合性自左向右。
  • 优先级 ：<、>=、<= 高于 ==、!=；整体低于算术运算符。
  • 结果规则 ：运算结果为整型，1表示真，0表示假。

（四）逻辑运算符（&&、||、!）

1. 基础规则

  • 逻辑判定：非 0 为真，0 为假；运算结果1为真，0为假。

  • 运算规则

    运算符 类型 规则 示例
    && 二元 全真为真，一假为假 真 && 假→假
    ` ` 二元
    ! 一元 逻辑取反，真变假，假变真 !0→1、!5→0
    c 复制代码 
    int num; scanf("%d",&num);
printf("%d\n",num>=1&&num<=99); // 判断[1,99]
printf("%d\n",num<1||num>99);   // 判断非[1,99]
2. 短路特性

  • ||：左操作数为真时，直接判定结果为真，右操作数不执行。

  • &&：左操作数为假时，直接判定结果为假，右操作数不执行 。

    c 复制代码 
    int a=1,b=1; printf("%d\n",++a||++b); // 1，a=2、b=1（短路）
int a=-1,b=-1;printf("%d\n",++a&&++b); //0，a=0、b=-1（短路）

（五）条件运算符（?:）

  • C 语言唯一的三元运算符 ，语法：操作数 1 ? 操作数 2 : 操作数 3。

  • 运算规则：操作数 1 为真，结果为操作数 2；操作数 1 为假，结果为操作数 3。

    c 复制代码 
    int num; scanf("%d",&num);
printf("%s\n",num%2?"奇数":"偶数"); // 判断奇偶并输出

（六）位运算符

1. 位逻辑运算符（&、|、~、^）

  • 运算对象为二进制位，无短路行为，左右操作数均执行。

    运算符 规则 异或特性
    & 对应位均 1 为 1，否则 0 -
    ` ` 对应位有 1 为 1，否则 0
    ~ 按位取反，0 变 1、1 变 0 -
    ^ 对应位不同为 1，相同为 0 a^b^b = a（左结合，b 值不变时异或两次还原原值；若 b 是变量且在运算中被改变，等式不成立）

  • 异或运算规则：
    0 ⊕ 0 → 0 0 \oplus 0 \rightarrow 0 0⊕0→0
    1 ⊕ 1 → 0 1 \oplus 1 \rightarrow 0 1⊕1→0
    0 ⊕ 1 → 1 0 \oplus 1 \rightarrow 1 0⊕1→1
    1 ⊕ 0 → 1 1 \oplus 0 \rightarrow 1 1⊕0→1

2. 位移运算符（<<、>>）

  • 通常操作无符号整型，操作数均为非负整数，无短路行为。

    c 复制代码 
    int a = 0x7fffffff; // 最大 int 正数
a <<= 1;            // 左移 1 位，变为负数
printf("%d\n",a);   // 输出负数结果

（七）逗号运算符（,）

  • 二元运算符，优先级最低 ，结合性自左向右。

  • 运算规则：依次执行所有操作数，整个表达式结果为最后一个操作数 的值。

    c 复制代码 
    int num;
num = 100,200;      // 赋值优先级高，num=100
num = (100,200);    // 括号提升优先级，num=200
num = (100,200,300);// 结果为最后一个，num=300

三、C 语言中的类型转换

  1. 显式类型转换（强制转换） ：语法(目标类型) 操作数，手动指定转换类型。

    c 复制代码 
    (double)10;  // 整型 10 转为浮点型
int a=20; (double)a; // 变量 a 转为浮点型

  2. 隐式类型转换（自动转换） ：编译器自动完成，向数据范围更大的类型靠拢 。

    • 算术运算要求操作数类型一致，整型与浮点型运算时，整型先提升为double。

四、运算符优先级表



注 ：本文内容基于河北师范大学丁盟老师课堂笔记整理。

上文截图中缺少口诀，可参考下文。

C 语言运算符优先级（记忆口诀）

稚枭天卓 于 2015-08-12 15:09:10 发布

本文系统阐述 C 语言中各类运算符及其优先级规则，并通过口诀辅助学习者完成记忆。内容覆盖从数组下标运算符至逗号运算符的 15 个优先级层级的运算符，明确各运算符的名称、使用形式及结合方向。

优先级 运算符 名称或含义 使用形式 结合方向 说明
1 [] 数组下标 数组名[常量表达式] 左到右
() 圆括号 (表达式)/函数名(形参表)
. 成员选择（对象） 对象.成员名
-> 成员选择（指针） 对象指针->成员名
2 - 负号运算符 -表达式 右到左 单目运算符
(类型) 强制类型转换 (数据类型)表达式
++ 自增运算符 ++变量名/变量名++ 单目运算符
-- 自减运算符 --变量名/变量名-- 单目运算符
* 取值运算符 *指针变量 单目运算符
& 取地址运算符 &变量名 单目运算符
! 逻辑非运算符 !表达式 单目运算符
~ 按位取反运算符 ~表达式 单目运算符
sizeof 长度运算符 sizeof(表达式)
3 / 除 表达式/表达式 左到右 双目运算符
* 乘 表达式*表达式 双目运算符
% 余数（取模） 整型表达式%整型表达式 双目运算符
4 + 加 表达式+表达式 左到右 双目运算符
- 减 表达式-表达式 双目运算符
5 << 左移 变量<<表达式 左到右 双目运算符
>> 右移 变量>>表达式 双目运算符
6 > 大于 表达式>表达式 左到右 双目运算符
>= 大于等于 表达式>=表达式 双目运算符
< 小于 表达式<表达式 双目运算符
<= 小于等于 表达式<=表达式 双目运算符
7 == 等于 表达式==表达式 左到右 双目运算符
!= 不等于 表达式!=表达式 双目运算符
8 & 按位与 表达式&表达式 左到右 双目运算符
9 ^ 按位异或 表达式^表达式 左到右 双目运算符
10 | 按位或 表达式|表达式 左到右 双目运算符
11 && 逻辑与 表达式&&表达式 左到右 双目运算符
12 || 逻辑或 表达式||表达式 左到右 双目运算符
13 ?: 条件运算符 表达式 1?表达式 2:表达式 3 右到左 三目运算符
14 = 赋值运算符 变量=表达式 右到左
/= 除后赋值 变量/=表达式
*= 乘后赋值 变量*=表达式
%= 取模后赋值 变量%=表达式
+= 加后赋值 变量+=表达式
-= 减后赋值 变量-=表达式
<<= 左移后赋值 变量<<=表达式
>>= 右移后赋值 变量>>=表达式
&= 按位与后赋值 变量&=表达式
^= 按位异或后赋值 变量^=表达式
|= 按位或后赋值 变量|=表达式
15 , 逗号运算符 表达式,表达式,... 左到右 按从左至右的顺序依次运算

说明

同一优先级的运算符，其运算次序由结合方向确定。

记忆口诀

括号成员第一; // 括号运算符 <> 成员运算符. ->

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

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

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

等于(与)不等排第七; // 即== 和!=

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

"三分天下"八九十;

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

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

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

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

改进版

  1. 括号成员居首；// 括号运算符 <>、成员运算符 . ->
  2. 所有单目次之；// 全部单目运算符，如 ++、--、+(正)、-(负)、指针运算 *、&
  3. 乘除取余为三，加减为四；// "余" 指代取余运算，即 %
  4. 移位为五，关系为六；// 移位运算符：<<、>>；关系运算符：>、<、>=、<= 等
  5. 等于与不等位列第七；// 即 == 和 !=
  6. 位与、异或、位或；// 均为位运算：位与 (&)、异或 (^)、位或 (|)
  7. 依次占据第八、九、十位；
  8. 逻辑与、逻辑或；// 逻辑运算符：&& 和 ||
  9. 分别为第十一位、第十二位；// 注意优先级次序：|| 优先级低于 &&
  10. 条件运算符优先级高于赋值运算符；// 三目运算符优先级为第十三位，仅高于赋值运算符与逗号运算符
  11. 逗号运算符优先级最低！

逻辑运算符 &&、|| 的短路运算机制

bulebin 2018-02-22 10:52:18

本文系统解析逻辑运算符&&与||的短路运算原理、应用价值及实践方法，结合多组 C 语言实例说明如何利用短路特性优化代码执行效率，规避逻辑异常。

一、短路运算的定义

  1. 逻辑运算符基础规则
    • 表达式 1 || 表达式 2：任意一个为真，整体为真；全假为假。
    • 表达式 1 && 表达式 2：所有为真，整体为真；一假为假。
  2. 短路运算特征 ：若左侧表达式结果已能确定整体结果，右侧后续表达式不再执行 。
    • ||短路规则：表达式 1 为真 → 整体为真，表达式 2~n 不执行；表达式 1 为假 → 依次判断后续。
    • &&短路规则：表达式 1 为假 → 整体为假，表达式 2~n 不执行；表达式 1 为真 → 依次判断后续。

二、短路运算的应用价值

  1. 风险规避 ：避免在&&/||表达式中直接嵌入赋值、自增/自减等带副作用的操作，防止因短路导致操作未执行，结果与预期不符。
  2. 性能优化：将能快速判定整体结果的表达式置于左侧，通过短路减少不必要的运算，降低处理器开销。

三、短路运算的实践方法（实例解析）

实例 1：|| 的基础短路（左侧为真）

c 复制代码 
#include <stdio.h>
int main() {
    int a=1,b=2,c=-3,d=-1;
    printf("before: a=%d b=%d c=%d d=%d\n",a,b,c,d);
    d = (a+1>0) || (++b>0) || (c-4)>0; // 左侧为真，短路后续
    printf("after:  a=%d b=%d c=%d d=%d\n",a,b,c,d); // b=2、c=-3、d=1
    return 0;
}

分析 ：a+1>0为真，触发短路，++b和c-4>0未执行，b、c值不变。

实例 2：|| 的连续判断（左侧为假）

c 复制代码 
#include <stdio.h>
int main() {
    int a=-1,b=2,c=-3,d=-1;
    printf("before: a=%d b=%d c=%d d=%d\n",a,b,c,d);
    d = (a+1>0) || (++b>0) || (c-4)>0; // 左侧假，执行下一个
    printf("after:  a=%d b=%d c=%d d=%d\n",a,b,c,d); // b=3、c=-3、d=1
    return 0;
}

分析 ：a+1>0为假，执行++b>0（结果为真），触发短路，c-4>0未执行，b自增为 3。

实例 3：|| 的副作用规避（强制执行所有操作）

c 复制代码 
#include <stdio.h>
int main() {
    int a=1,b=2,c=-3,d=-1,A=-1,B=-1,C=-1;
    printf("before: a=%d b=%d c=%d d=%d\n",a,b,c,d);
    A=a+1>0; B=++b>0; C=c-4>0; // 先计算所有结果，再逻辑运算
    d = A || B || C;
    printf("after:  a=%d b=%d c=%d d=%d\n",a,b,c,d); // b=3、d=1
    return 0;
}

分析：先独立计算所有带副作用的操作，再进行逻辑运算，确保所有操作均执行。

实例 4：&& 的基础短路（左侧为假）

c 复制代码 
#include <stdio.h>
int main() {
    int a=-1,b=2,c=-3,d=-1;
    printf("before: a=%d b=%d c=%d d=%d\n",a,b,c,d);
    d = (a+1>0) && (++b>0) && (c-4)>0; // 左侧为假，短路后续
    printf("after:  a=%d b=%d c=%d d=%d\n",a,b,c,d); // b=2、c=-3、d=0
    return 0;
}

分析 ：a+1>0为假，触发短路，++b和c-4>0未执行，b、c值不变。

实例 5：&& 的连续判断（左侧为真）

c 复制代码 
#include <stdio.h>
int main() {
    int a=1,b=-2,c=-3,d=-1;
    printf("before: a=%d b=%d c=%d d=%d\n",a,b,c,d);
    d = (a+1>0) && (++b>0) && (c-4)>0; // 左侧真，执行下一个
    printf("after:  a=%d b=%d c=%d d=%d\n",a,b,c,d); // b=-1、c=-3、d=0
    return 0;
}

分析 ：a+1>0为真，执行++b>0（结果为假），触发短路，c-4>0未执行，b自增为-1。

实例 6：&& 的副作用规避（强制执行所有操作）

c 复制代码 
#include <stdio.h>
int main() {
    int a=-1,b=2,c=-3,d=-1,A=-1,B=-1,C=-1;
    printf("before: a=%d b=%d c=%d d=%d\n",a,b,c,d);
    A=a+1>0; B=++b>0; C=c-4>0; // 先计算所有结果，再逻辑运算
    d = A && B && C;
    printf("after:  a=%d b=%d c=%d d=%d\n",a,b,c,d); // b=3、d=0
    return 0;
}

分析：先独立计算所有带副作用的操作，再进行逻辑运算，确保所有操作均执行。

详解 C 语言中运算符 || 和 && 的短路机制

d0ublecl1ck_ 2025-07-12 08:25:01

在 C 语言中，逻辑或||与逻辑与&&是组合多条件表达式的重要运算符，二者均具备短路机制------这是优化代码执行效率、规避运行时错误的关键特性，本文将深入剖析该机制的原理、规则及工程化应用场景。

一、逻辑或运算符（||）的短路机制

1. 基本定义

  • 二元运算符，语法：condition1 || condition2。
  • 运算规则：任意条件为真，整体为真；全假为假。

2. 短路规则

  1. 若左侧条件condition1为真 ，直接判定整体为真，右侧条件condition2不计算；
  2. 仅当左侧条件condition1为假 时，才计算右侧条件condition2：
    • condition2为真 → 整体为真；
    • condition2为假 → 整体为假。
  • 价值：避免无效运算，提升程序执行效率。

二、逻辑与运算符（&&）的短路机制

1. 基本定义

  • 二元运算符，语法：condition1 && condition2。
  • 运算规则：所有条件为真，整体为真；一假为假。

2. 短路规则

  1. 若左侧条件condition1为假 ，直接判定整体为假，右侧条件condition2不计算；
  2. 仅当左侧条件condition1为真 时，才计算右侧条件condition2：
    • condition2为真 → 整体为真；
    • condition2为假 → 整体为假。
  • 价值 ：与||互补，同样通过减少无效运算优化性能。

三、短路机制的工程化应用

应用 1：避免空指针引用（最常用场景）

访问指针成员/调用指针函数前，先校验指针是否为空，利用短路机制防止空指针访问崩溃。

c 复制代码 
// 若 ptr 为空，左侧为真，短路右侧 ptr->data，避免空指针引用
if (ptr == NULL || ptr->data == 42) {
    // 业务逻辑
}

// 若 ptr 为空，左侧为假，短路右侧 ptr->data，避免空指针引用
if (ptr != NULL && ptr->data == 42) {
    // 业务逻辑
}

应用 2：条件赋值优化

利用短路机制简化条件赋值，减少if-else分支语句的使用，让代码更简洁。

c 复制代码 
// 若 condition1 为真，短路 condition2，直接赋值 value1
int result = (condition1 || condition2) ? value1 : value2;

// 若 condition1 为假，短路 condition2，直接赋值 value2
int result = (condition1 && condition2) ? value1 : value2;

应用 3：简化复杂条件判断

在多条件组合判断中，将快速判定结果的条件置于左侧，通过短路减少运算开销，提升代码执行效率。

c 复制代码 
// 若用户是管理员，左侧为真，短路后续条件，直接执行逻辑
if (userIsAdmin || (userIsLoggedIn && hasPermission)) {
    // 管理员/有权限用户的业务逻辑
}

四、典型例题解析（短路机制综合应用）

例题 1


解析 ：x++逻辑值为真，触发||短路机制，y++和++z均不执行；逻辑真等价于1，z += 1，最终结果为6，7，9。

例题 2


解析：

  1. y++初始值为 0（逻辑假），触发&&短路机制，++z不执行；
  2. 假|| ++x，左侧为假，执行++x，x自增为 2；
  3. 最终结果：x=2，y=1（后置自增），z=2。

五、总结

  1. 短路机制是||和&&的固有特性，||左侧为真时短路，&&左侧为假时短路；
  2. 短路机制的价值是优化执行效率 （减少无效运算）和规避运行时错误（如空指针引用）；
  3. 工程实践中需注意：避免在短路区域嵌入带副作用的操作（赋值、自增/自减、函数调用），防止逻辑异常；
  4. 熟练掌握短路机制，可让代码更简洁、高效、健壮，是 C 语言程序员的必备技能。

【C 语言】搞懂 |、||、&、&& 的差异

hinacha_ 2024-01-04 16:37:44

本文系统解析 C 语言中位运算符|、&与逻辑运算符||、&&的工作原理、使用规则、差异及常见错误，结合实例说明工程应用场景，重点强调短路行为对代码效率与逻辑正确性的影响。

一、引言

|（位或）、||（逻辑或）、&（位与）、&&（逻辑与）是 C 语言高频运算符，但其功能、行为差异易被初学者混淆：

  • |、&是位运算符，操作二进制位，无短路行为；
  • ||、&&是逻辑运算符 ，操作逻辑值，具备短路行为。
    精准掌握四类运算符的差异，是编写正确、高效条件语句的基础。

二、四类运算符逐一解析

（一）|（位或）运算符

1. 定义
  • 二元位运算符 ，按二进制位 执行或运算，无短路行为，左右操作数均会执行。
  • 位运算规则：对应位至少有 1 个为 1，结果位为 1；全 0 为 0。
  • 逻辑判断规则：非 0 为真、0 为假，a | b等价于"a 真 或 b 真"。
2. 代码示例
c 复制代码 
int a = 1; // 二进制：0001（真）
int b = 0; // 二进制：0000（假）
if (a | b) { // 位或结果：0001（非 0，真）
    printf("The result is true\n"); // 执行该语句
}
3. 注意事项
  • 本质是位运算，非专门的逻辑运算符，无短路特性，效率低于||；
  • 逻辑判断中，仅当需要同时执行左右操作数 时使用，否则优先选||。

（二）||（逻辑或）运算符

1. 定义
  • 二元逻辑运算符 ，操作逻辑值 ，具备短路特性，是逻辑判断的首选运算符。
  • 运算规则：一真为真、全假为假。
  • 短路规则：左侧为真时，右侧操作数不执行。
2. 代码示例
c 复制代码 
int a = 0; // 逻辑假
int b = 1; // 逻辑真
if (a || b) { // 左侧假，执行右侧；右侧真，整体真
    printf("The result is true\n"); // 执行该语句
}
3. 注意事项
  • 逻辑判断的最优选择，短路特性可大幅提升效率；
  • 禁止在右侧嵌入带副作用的操作（赋值、自增/自减、函数调用），防止因短路未执行。

（三）&（位与）运算符

1. 定义
  • 二元位运算符 ，按二进制位 执行与运算，无短路行为，左右操作数均会执行。
  • 位运算规则：对应位均为 1，结果位为 1；有 0 为 0。
  • 逻辑判断规则：非 0 为真、0 为假，a & b等价于"a 真 且 b 真"。
2. 代码示例
c 复制代码 
int a = 1; // 二进制：0001（真）
int b = 0; // 二进制：0000（假）
if (a & b) { // 位与结果：0000（0，假）
    printf("The result is true\n");
} else {
    printf("The result is false\n"); // 执行该语句
}
3. 注意事项
  • 本质是位运算，非专门的逻辑运算符，无短路特性，效率低于&&；
  • 逻辑判断中，仅当需要同时执行左右操作数 时使用，否则优先选&&。

（四）&&（逻辑与）运算符

1. 定义
  • 二元逻辑运算符 ，操作逻辑值 ，具备短路特性，是逻辑判断的首选运算符。
  • 运算规则：全真为真、一假为假。
  • 短路规则：左侧为假时，右侧操作数不执行。
2. 代码示例
c 复制代码 
int a = 0; // 逻辑假
int b = 1; // 逻辑真
if (a && b) { // 左侧假，短路右侧；整体假
    printf("The result is true\n");
} else {
    printf("The result is false\n"); // 执行该语句
}
3. 注意事项
  • 逻辑判断的最优选择，短路特性可大幅提升效率；
  • 禁止在右侧嵌入依赖执行的副作用操作；
  • 复杂表达式中，用括号 明确优先级（如(a && b) || c），避免逻辑错误。

三、四类运算符差异总结

1. 分类差异

类别 运算符 本质 短路行为 操作对象 逻辑判断优先级
或运算系列 ` ` 位运算符 无 二进制位
` ` 逻辑运算符 有
与运算系列 & 位运算符 无 二进制位 低
&& 逻辑运算符 有 逻辑值 高

2. 运算规则差异

  • 或运算 ：|按位或（无短路），||逻辑或（左侧真短路），最终逻辑结果一致，执行效率不同；
  • 与运算 ：&按位与（无短路），&&逻辑与（左侧假短路），最终逻辑结果一致，执行效率不同。

3. 工程使用原则

  1. 纯逻辑判断 ：优先使用||、&&，利用短路特性提升效率，规避副作用风险；
  2. 需执行所有操作 ：若要求左右操作数均执行（如带副作用），使用|、&；
  3. 位运算场景 ：操作二进制位时（如寄存器操作、数据加密），必须使用|、&，||、&&不适用。

四、综合示例代码（四类运算符对比）

c 复制代码 
#include <stdio.h>
int main() {
    int a = 0;  // 逻辑假
    int b = 1;  // 逻辑真
    int c = 2;  // 逻辑真
    int d = 0;  // 逻辑假

    // 1. 位或|：无短路，所有操作数执行
    if (a | b | c | d) printf("至少一个真（|）\n");
    // 2. 逻辑或||：有短路，效率更高
    if (a || b || c || d) printf("至少一个真（||）\n");
    // 3. 位与&：无短路，所有操作数执行
    if (a & b & c & d) printf("所有都真（&）\n");
    else printf("非所有都真（&）\n");
    // 4. 逻辑与&&：有短路，效率更高
    if (a && b && c && d) printf("所有都真（&&）\n");
    else printf("非所有都真（&&）\n");

    return 0;
}

运行结果：

复制代码 
至少一个真（|）
至少一个真（||）
非所有都真（&）
非所有都真（&&）

结论 ：逻辑判断结果一致，但||、&&通过短路减少了运算，效率更高。

via：

热门推荐
01GitHub 镜像站点02【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆03OpenClaw 使用和管理 MCP 完全指南04OpenClaw + 飞书（Feishu）环境搭建指南05Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤06Window 10部署openclaw报错node.exe : npm error code 12807Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services08AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南09OpenClaw优化飞书API 额度已耗尽问题10AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot