操作符核心知识点梳理
一、核心定位
操作符是编程的 “基础工具”，贯穿变量运算、逻辑判断、代码简化、内存访问的全过程，本次复习重点是理清分类、吃透用法、掌握底层逻辑、规避常踩坑点。
回顾编程知识点时，发现自身对不少操作符的用法仍有混淆，尤其是位操作、移位操作的底层逻辑掌握不扎实，还有操作符优先级、表达式求值经常出错，因此特意梳理这份复习笔记，吃透二进制及位操作相关底层知识，掌握操作符属性及表达式求值规则，为后续编程实战（表达式编写、bug 排查、底层优化）筑牢基础，也方便后续快速回顾。
结合自身复习节奏，全文按基础铺垫→分类梳理→重点突破→底层逻辑→属性与求值→坑点避坑→实战复盘展开，覆盖 11 个核心要点，兼顾基础与难点，以复习视角记录梳理过程和易错点，适合需要系统复习操作符的小伙伴参考。
二、基础铺垫
2.1 二进制和进制转换
- 核心基础：计算机底层是以二进制（0、1）存储数据的，所有操作符对数据的运算，本质都是对二进制位的操作 —— 这是理解移位、位操作符的前提，需重点牢记。
- 重点进制转换：主要梳理十进制与二进制（整数 + 小数简要梳理）、二进制与十六进制的转换方法；其中十六进制主要用于简化二进制书写，在后续位操作场景中高频使用，是重点记忆内容。
- 复习技巧：无需死记复杂推导，重点牢记十进制转二进制除 2 取余、二进制转十进制按位加权求和，结合 1-2 个简单示例辅助记忆，比如将十进制 5 转为二进制，反复练 2 遍即可熟练掌握。
二进制转化成十进制
二进制：1 0 1 1
十进制：1*2^3 + 0*2^2 + 1*2^1 + 1*2^0 = 11
十进制转化为二进制
十进制：15 → 除 2 取余得二进制：01111 → 简化为1111（去除高位无意义 0）。
二进制转八进制
二进制每三位对应一位八进制；原因是八进制基数 8 是二进制基数 2 的 3 次方（8=2³），3 位二进制数的取值范围，能完整覆盖 1 位八进制数的所有可能，二者一一对应，转换时直接按位映射即可。示例：二进制101 010 111 → 按三位分组直接转换为八进制。
二进制转十六进制
与转八进制逻辑完全相同；核心原因是十六进制基数 16 是二进制基数 2 的 4 次方（16=2⁴）。转换规则：二进制每四位对应一位十六进制，4 位二进制数的所有取值，能完整覆盖 1 位十六进制数的全部可能，二者一一对应，转换时直接按位映射即可。
2.2 原码、反码、补码
- 核心用途：解决计算机中负数的表示与运算问题，移位、位操作符的运算均基于补码进行，属于底层关键知识点，必须吃透，否则位运算易出错。
- 三者定义（以整数为例）：结合理解整理易懂定义，方便回顾：
- 原码：符号位（0 正 1 负）+ 数值的二进制绝对值，简单直观但无法直接用于负数运算，这是反码、补码出现的原因。
- 反码：正数反码 = 原码；负数反码 = 符号位不变，数值位按位取反。
- 补码：正数补码 = 原码；负数补码 = 反码 + 1（重点）；计算机实际存储和运算的是补码，所有整数运算都要基于补码分析。
易错点：负数补码转原码易出错，总结两种通用方法，可交叉验证：
- 补码 - 1 得反码，反码按位取反得原码；
- 补码直接按位取反 + 1 得原码。
无符号数：无符号位，每一位都是数值位，原码、反码、补码的二进制表示完全相同。
三、操作符整体分类
核心原则：按功能用途分类，每个类别明确「核心作用 + 典型代表 + 使用场景」，拒绝孤立记忆，衔接底层基础知识点，确保知识串联而非零散记忆。
3.1 移位操作符（单独分类，重点突破薄弱点）
- 核心定义：操作二进制位，将数据的二进制补码位向左 / 向右移动指定位数；仅适用于整数，浮点数使用会报错，运算基于补码进行。
- 核心代表及用法：结合示例记忆，避免混淆：
- 左移
<<：左边舍弃，右边补 0；等价于整数乘以 2 的 n 次方，效率高于乘法，无符号 / 有符号整数通用该规则。示例代码：#include <stdio.h> int main() { int num = 4; int n = num << 1; // 仅返回移位结果，不修改num本身 printf("n = %d\n", n); // 输出8 printf("num = %d\n", num); // 输出4，原值不变 // 若要修改原值，写num = num << 1 或 num <<= 1 return 0; } 
- 右移
>>：分两种实现，主流编译器默认算术右移：- 算术右移（主流）：左边补符号位，右边舍弃；
- 逻辑右移：左边补 0，右边舍弃。需注意编译器差异，避免结果异常。
- 左移
易错点：
- 移位位数不能为负数（C 语言标准未定义，不同编译器行为不一致）；
- 有符号数右移的符号位补位规则需牢记，否则易出现运算结果异常。
建议：自行推导int a=4（二进制 100）左移 1 位、int b=-4右移 1 位的补码运算过程，掌握移位底层逻辑。
3.2 位操作符（&、|、^、~）
注：操作数必须是整数，运算基于补码进行。
- 核心定义：直接操作数据的二进制补码位，仅适用于整数；常用于底层优化、进制转换、状态判断等场景。
- 核心代表及用法：
&（按位与）：对应位均为 1，结果为 1；否则为 0；常用用途：判断某一位是否为 1、清零指定位。|（按位或）：对应位有一个为 1，结果为 1；否则为 0；常用用途：置 1 指定位。^（按位异或）：重点复习操作符；对应位不同为 1，相同为 0；核心特性：a^a=0、a^0=a；基于特性可实现交换两个数、翻转指定位。(结尾有重点补充)无临时变量交换两个整数代码：#include <stdio.h> int main() { int a = 10; int b = 20; a = a ^ b; b = a ^ b; a = a ^ b; printf("a = %d b = %d\n", a, b); // 输出a=20 b=10 return 0; }~（按位非）：对应位按位取反（0 变 1，1 变 0）；注意：负数补码取反后符号位会变化，运算时需关注符号位。
关键区分：易混淆位操作符（&、|）与逻辑操作符（&&、||），前者操作二进制位，后者操作逻辑值；比如判断两个数是否都为非 0，应使用&&而非&。
3.3 单目操作符
- 核心定义：只有一个操作数，用于对单个数据进行运算；易和双目操作符混淆，需逐一梳理。
- 核心代表及用法：
- 算术类：
++（前置 / 后置自增）、--（前置 / 后置自减）、+（正号，可省略）、-（负号，对补码取反 + 1）；前置 / 后置自增自减为重点复习内容，后续单独深度拆解。 - 逻辑类：
!（逻辑非）；规则：将非 0 值转为 0，0 转为 1；示例：!5=0、!0=1。 - 取值 / 取地址：
&（取地址，获取变量内存地址）、*（取值，通过地址获取变量值）；需结合指针基础理解，避免误用。 - 强制转换：
(类型)（将一个数据强制转为指定类型）；注意：浮点数转整数会舍弃小数部分，存在精度丢失问题，需谨慎使用。 - sizeof：计算变量 / 类型所占内存大小（单位：字节）；易混点：与
strlen区分 ——sizeof计算内存大小，strlen计算字符串长度（不包含结束符'\0'）。
- 算术类：
3.4 逗号表达式（单独分类，明确用法，记录易错点）
- 核心定义：用逗号
,连接多个表达式，从左到右依次执行，整个表达式的结果是最后一个表达式的值。 - 核心特性：优先级最低，常用于简化代码（如 for 循环的初始化 / 更新部分）。
- 示例：
int a=1, b=2; int c = (a++, b++, a+b); // 执行顺序：a=2→b=3→c=5，最终结果为5 - 易错点：易误将前面表达式的结果作为最终结果；前面的表达式仅执行，不影响最终结果，最终结果仅由最后一个表达式决定。
3.5 访问类操作符（下标 + 函数调用 + 结构成员，结合实战梳理）
3.5.1 下标访问[]
- 用于访问数组元素，格式：
数组名[下标]；核心知识点：本质等价于*(数组名+下标)，结合指针基础理解数组访问逻辑。 - 易错点：下标从 0 开始，编译器不检查下标越界，运行时易出现异常，需注意判断下标范围。
3.5.2 函数调用()
- 用于调用函数，格式：
函数名(参数列表)；参数列表可为空（无参函数），但必须保留括号，遗漏会导致编译报错。
3.5.3 结构成员访问操作符（两种形式）
两种形式易混淆，结合示例记忆，核心用于访问自定义结构体的成员属性；先明确结构体的基础概念：
结构体基础
- 核心作用：把不同类型的变量打包成一个整体，解决普通变量只能单独存储单一类型数据的问题；比如描述学生（学号 int、姓名 char []、成绩 float），可将多个不同类型属性整合为 “学生类型”，方便管理。
- 定义原因：实际编程中描述的事物均为多属性，普通变量会让属性相互独立，无法体现 “属于同一事物” 的关联，结构体可解决该问题。
- 核心定义：关键字
struct，分两步：先声明结构体类型（告诉编译器自定义类型的结构），再定义该类型的变量（与int a定义格式一致）。
结构体完整示例代码：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h> // 字符串赋值需用到strcpy函数
// 声明书本结构体（用于嵌套）
struct Book
{
// 书本属性
char bname[20]; // 书名
float price; // 价格
}B1; // 声明类型同时定义全局变量B1
// 声明学生结构体（嵌套Book结构体）
struct MyStruct
{
// 学生属性
char name[20]; // 名字
short age; // 年龄
char sex[10]; // 性别
char id[20]; // 学号
struct Book b; // 支持嵌套结构体
}A1; // 声明类型同时定义全局变量A1
int main()
{
// 定义局部结构体变量并整体初始化（成员顺序需与声明一致）
struct MyStruct A2 = { "zhangsan",19,"男","2025345",{"C语言",22.0}};
printf("学生A2的信息：\n");
printf("A2学生的书本名称：%s\n", A2.b.bname); // 嵌套结构体成员访问：变量.嵌套结构体.成员
// 给全局结构体变量A1赋值并读取
printf("请输入A1学生信息：\n");
printf("姓名：");
scanf("%s", A1.name); // 字符数组直接传名，无需&
printf("年龄：");
scanf("%hd", &A1.age); // short类型用%hd格式符
printf("性别：");
scanf("%s", A1.sex);
printf("A1的性别：%s\n",A1.sex);
return 0;
}
结构体使用关键注意点：
- 字符串成员必须用字符数组（如
char name[20]），新手阶段暂不使用char *name（涉及指针）； - 字符数组赋值不能直接用
=（如A1.name = "张三"是错误的），需用strcpy函数，且必须包含头文件#include <string.h>。
结构体成员访问操作符详解
.（点操作符）：用于结构体变量访问成员；格式：结构体变量.成员名；示例：stu.name、A2.b.price。- ->（箭头操作符）：用于结构体指针访问成员；格式：
结构体指针->成员名；等价于：(*结构体指针).成员名；示例：p->name等价于(*p).name（p 为结构体指针）。
3.6 其他常用操作符（补充完善，避免遗漏）
- 赋值操作符：
=（基础赋值）、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=（复合赋值）；等价规则：复合赋值 = 运算 + 赋值，如a += b等价于a = a + b，简化代码书写。 - 关系操作符：
>、<、>=、<=、==（等于判断）、!=（不等于）；作用：判断大小 / 相等关系，返回布尔值（0 或非 0），用于条件判断；易混点：==（判断相等）与=（赋值），后续重点梳理。 - 逻辑操作符：
&&（逻辑与）、||（逻辑或）；用于组合条件判断，具有短路求值特性（可简化代码、避免无效运算），后续单独拆解。 - 三元运算符：
condition ? expr1 : expr2；用于简化简单的 if-else 语句；规则：condition 为真，执行 expr1；为假执行 expr2；示例：求两数最大值max = a > b ? a : b。
四、操作符的核心属性（重点补充：优先级、结合性）
核心意义：优先级和结合性直接决定表达式的运算顺序，是表达式求值经常出错的核心原因；复习重点是牢记高频优先级 + 结合性规则，避免写错表达式。
4.1 优先级
- 定义：多个操作符共存于一个表达式时，优先级高的先运算；类比数学中的 “先乘除后加减”。
- 高频优先级梳理（从高到低）：
- 最高优先级：
()（括号，可强制改变运算顺序）、[]、->、.（访问类操作符）；技巧：不确定运算顺序时，加括号即可，安全且清晰。 - 核心顺序：单目操作符 > 算术操作符 > 关系操作符 > 逻辑操作符 > 赋值操作符 > 逗号表达式（最低）。
- 最高优先级：
- 易错点：
- 单目操作符优先级高于算术操作符（如
!a + b，先算!a再算加法）； - 赋值操作符优先级低于关系操作符（如
a = b == c，先算b==c再将结果赋值给 a）。
- 单目操作符优先级高于算术操作符（如
4.2 结合性
- 定义：多个优先级相同的操作符共存时，结合性决定运算方向（从左到右 / 从右到左）；与优先级共同决定表达式运算顺序，缺一不可。
- 高频结合性规则：
- 从左到右（左结合）：算术、关系、逻辑、逗号、访问类、大部分双目操作符；示例：
a + b + c、a > b > c，按从左到右运算。 - 从右到左（右结合）：单目操作符、赋值操作符、三元运算符；示例：
a = b = c（先算b=c再算a=b）、+++a（等价于++(+a)）。
- 从左到右（左结合）：算术、关系、逻辑、逗号、访问类、大部分双目操作符；示例：
实用技巧：不确定运算顺序时，直接加括号（()优先级最高），避免依赖优先级和结合性记忆出错，这是写代码的通用规范。
五、表达式求值
核心：基于操作符的优先级、结合性，结合底层逻辑（补码运算），分析表达式的执行顺序和结果；重点解决 “求值异常” 问题，避免逻辑错误。
5.1求值的三大依据
- 操作符优先级；
- 操作符结合性；
- 操作数的求值顺序；重点：多数操作符未定义操作数求值顺序（如
a++ + ++a），不同编译器运算结果不同，需避免写出此类代码。
5.2重点梳理不同类型表达式求值
- 含单目操作符的表达式：结合优先级、结合性分析执行顺序；示例：
++a + b，先算++a再算加法。 - 含位操作、移位操作的表达式：核心步骤 —— 先将操作数转为补码，再按位 / 移位规则运算，最后转回原码得到结果；需结合补码知识分步推导。
- 含逗号、赋值操作的表达式：明确逗号表达式 “从左到右执行，结果为最后一个表达式的值”；牢记赋值操作的右结合特性；示例：
a = (b++, c++, b+c)，先执行逗号表达式，再将结果赋值给 a。
5.3关键易错点
避免写出 “操作数求值顺序未定义” 的表达式（如a = ++a + 1、a++ + ++a），此类代码可移植性差，不同编译器运行结果不同，极易出现 bug。
六、重点操作符深度拆解
原则：聚焦移位、位、单目、访问类等薄弱、易出错的操作符，结合底层基础和操作符属性，搭配 “用法 + 示例 + 易错点”，确保吃透核心逻辑。
6.1 移位操作符 & 位操作符深度拆解
- 移位操作符：补充负数移位示例（如
int a=-4，a>>1的补码运算过程），分步推导补码移位逻辑，明确算术右移的符号位补位规则，理解原理而非死记结果。 - 位操作符：重点拆解
^（按位异或），梳理核心应用场景：- 交换两个数（无临时变量）；
- 翻转指定位；
- 实战延伸：位操作符的底层优化技巧，示例：判断奇数用
a & 1（效率高于a % 2 == 1），因位运算是 CPU 直接支持的底层运算，速度更快。
6.2 单目操作符深度拆解（易混淆点突破）
- 自增自减（++/--）：核心区分 ——前置先运算再使用，后置先使用再运算；示例：
int a=2; int b=a++ + ++a;，不同编译器因操作数求值顺序未定义，结果不同，避免依赖固定结果写代码。 - sizeof 与 * 的区别：示例：
int a[5];，sizeof(a)为数组总大小（5*4=20 字节，int 占 4 字节），sizeof(*a)为首元素大小（4 字节），明确二者计算对象的差异。 - 强制转换：演示风险点 —— 精度丢失（
int a=3.14;结果为 3）、指针强制转换风险（(int*)100;将数值转为指针），提醒自己谨慎使用。
6.3 结构成员访问操作符拆解（贴合实战，解决混淆）
- 核心示例：定义学生结构体，分别用结构体变量和结构体指针访问成员，验证等价关系：
p->name≡(*p).name（p 为结构体指针）。 - 核心规则：结构体变量用.，结构体指针用 ->，牢记无混淆。
- 易错点：结构体指针访问成员时误用.（如
p.name），会直接编译报错，写代码时需反复检查。
七、高频坑点 & 易错点总结
核心：梳理写代码、复习时经常用错、混淆的点，每个坑点搭配 “错误示例 + 正确用法”，结合底层逻辑和操作符属性加深记忆，减少 bug。
坑点 1：混淆位操作符（&、|）与逻辑操作符（&&、||）
- 错误示例：
if(a & b)（本意判断 a、b 均非 0）； - 正确用法：
if(a && b)； - 核心区别：前者操作二进制位，后者操作逻辑值（0 / 非 0）。
坑点 2：移位操作符的误用
- 错误行为：移位位数为负数、忽略有符号数右移的符号位补位规则；
- 后果：不同编译器行为不一致，运算结果异常；
- 规避：移位位数为非负整数，有符号数右移牢记算术右移规则。
坑点 3：原码、反码、补码混淆
- 错误行为：用原码直接进行负数运算；
- 正确用法：所有整数运算（移位、位操作、算术运算）均基于补码进行；
- 规避：运算前先将操作数转为补码，运算后再转回原码得到结果。
坑点 4：操作符优先级 / 结合性记忆错误
- 错误示例：
a = b + c * d误先算b+c； - 解决方案：不确定运算顺序时，直接加括号，安全且清晰。
坑点 5：单目操作符与双目操作符混用
- 错误示例：
++a + b误先算a+b再自增； - 规避：牢记单目操作符优先级高于算术等双目操作符。
坑点 6：结构成员访问操作符误用
- 错误示例：结构体指针用.（
p.name）、结构体变量用 ->（stu->name）； - 核心规则：指针用 ->，变量用.。
坑点 7：逗号表达式结果误用
- 错误示例：
int c = (a++, b++);误将a++结果作为 c 的值； - 核心规则：逗号表达式结果为最后一个表达式的值（此例为
b++）。
坑点 8：写出操作数求值顺序未定义的表达式
- 错误示例：
a++ + ++a、a = ++a + 1； - 后果：不同编译器结果不同，代码可移植性差；
- 规避：坚决避开此类表达式，拆解为多条语句书写。
八、复习复盘 & 实战小练习
8.1 核心知识点复盘
- 底层基础：二进制转换、原码 / 反码 / 补码是移位、位操作符的核心前提，补码运算规则为底层运算基础，需牢记。
- 操作符分类：掌握移位、位、单目、访问类、逗号表达式的用法，能区分易混淆类别，快速选择合适的操作符。
- 核心属性：优先级、结合性决定表达式运算顺序，记住高频规则，不确定时加括号。
- 表达式求值：掌握求值方法，避开未定义求值顺序的陷阱，结合底层逻辑分步分析。
8.2 简单实战练习
- 练习 1：进制转换 + 补码运算；将十进制 - 5 转为二进制补码，计算补码左移 1 位、右移 1 位的结果，再转回十进制，检验补码和移位操作的掌握程度。
- 练习 2：位操作符应用；用按位异或交换两个整数，用按位与判断一个数是否为奇数，手写代码检验用法，熟悉底层优化技巧。
- 练习 3：单目操作符 + 表达式求值；分析
int a=3; int b=++a + a-- + sizeof(a);的结果，结合优先级、结合性分步推导。 - 练习 4：访问类操作符；定义结构体指针，用
.和->两种方式访问其成员并赋值，检验结构成员访问操作符的掌握。 - 练习 5：优先级 / 结合性；修正表达式
int a=2+3*4>5&&6;的写法，明确运算顺序并计算结果。 - 练习 6：坑点排查；手写一段包含位操作符、结构成员访问、表达式求值陷阱的错误代码，找出错误并修正，检验高频坑点的掌握。
九、总结
- 延伸思考：操作符不仅是编程的基础工具，其底层逻辑（补码、位运算）更是后续学习指针、内存优化、底层开发的核心；本次复习到位，能大幅提升后续编程效率和代码健壮性，为更难的知识点学习筑牢基础。
- 如果在操作符复习中也有混淆的知识点、常踩的坑，欢迎补充交流，分享位操作符、表达式求值的实用技巧，互相巩固复习、查漏补缺、共同进步。
补充：按位异或交换两个数的底层逻辑解析
要理解异或交换代码，需先掌握异或运算的3 个核心特性（交换逻辑的基础）：
异或运算（^）的核心特性
异或运算规则：两个二进制位相同，结果为 0；两个二进制位不同，结果为 1（简单记：同 0 异 1）。基于规则推导的 3 个关键特性（对任意整数 x、y 都成立）：
- 自反性：
x ^ x = 0（一个数和自己异或，结果一定是 0）； - 恒等性：
x ^ 0 = x（一个数和 0 异或，结果还是它自己）； - 交换律 / 结合律：
x ^ y = y ^ x、x ^ y ^ z = x ^ (y ^ z)（异或的运算顺序不影响结果）。
逐行拆解交换逻辑（带变量值推导）
初始值：a = 10，b = 20；用A表示初始 a (10)，B表示初始 b (20)，区分 “原始值” 和 “更新后的值”。
- 第一步：
a = a ^ b执行后：a = A ^ B（10^20），b 仍为原始值 B (20)，未被修改； - 第二步：
b = a ^ b代入 a 的新值：b = (A^B) ^ B→ 结合结合律 + 自反性：A ^ (B^B) = A ^ 0 = A；本质：将原始 a 的值 (10) 赋给了 b，此时 b=10（A），a=10^20（A^B）； - 第三步：
a = a ^ b代入当前 a 和 b：a = (A^B) ^ A→ 结合交换律 + 自反性：B ^ (A^A) = B ^ 0 = B；本质：将原始 b 的值 (20) 赋给了 a，此时 a=20（B），b=10（A），交换完成。
具体数值验证（十进制）
已知：10 ^ 20 = 30、30 ^ 20 = 10、30 ^ 10 = 20；
- 第一步：
a = 10^20 = 30→ a=30，b=20； - 第二步：
b = 30^20 = 10→ a=30，b=10； - 第三步：
a = 30^10 = 20→ a=20，b=10。
异或交换的特点
-
优点
- 无临时变量：不需要定义第三个变量（如 temp），节省少量内存空间；
- 运算效率高：位运算是 CPU 直接支持的底层运算，比普通临时变量交换法速度更快。
-
注意点
交换的两个变量必须是不同的内存地址！如果 a 和 b 指向同一块内存（如数组中交换同一个下标元素、a = &b），执行后变量值会变为 0（第一步a=a^b就成了x^x=0，后续步骤均为 0）。
-
开发建议
实际开发中，临时变量交换法（temp=a;a=b;b=temp）可读性更高，无内存地址限制，是更通用的方式；异或交换法仅适用于追求极致性能的场景。
拓展：位操作符经典笔试应用
n = n & (n - 1)是二进制位操作的经典技巧，核心作用：消除数字 n 的二进制补码中「最右侧的那个 1」，每执行一次消去一个 1，直到 n 变为 0。
应用 1：统计二进制中 1 的个数
方法一（基础版）：
就像求一个十位数的方法一样，通过不断/10的方法，我们不断/2，直到余数为0（有局限，适用于正数）
#include <stdio.h>
int main() {
int a = 10;
scanf("%d", &a);
int sum = 0;
while (a)
{
if (a % 2 == 1)
{
sum ++;
}
a /= 2;
}
printf("Sum: %d\n", sum);
return 0;
}
输入一个正数5（101，原码等于补码），结果为2是正确的
如果输入-1呢？
原码：1000 0000 0000 0000 0000 0000 0000 0001（最高位 1 是负号，其余是数值位）
反码：1111 1111 1111 1111 1111 1111 1111 1110（符号位不变，数值位取反）
补码：1111 1111 1111 1111 1111 1111 1111 1111（反码 + 1）
代码在逻辑和实际运行显然都是错误的！
方法二（改进局限版）
任何一个数&1得到二进制最低位，然后>>1是计算机中提取二进制每一位的经典方法，核心是通过 &1 取二进制最低位、>>1 右移舍弃最低位，循环执行就能从低位到高位依次拿到一个数的所有二进制位，不管正数还是负数（按补码处理）都适用。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//方法二
int main() {
int a = 0;
scanf("%d", &a);
int count = 0;
for (int i = 0; i < 32; i++) //考虑负数的情况，循环32次
{
if (a & 1) //if((a & 1) == 1)
{
count++;
}
a >>= 1;
}
printf("Sum: %d\n", count);
return 0;
}
那么这样每次就要循环一遍，效率低下！
方法三（效率最高）
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//方法三：n = n & (n-1) 消去最右侧1，循环次数=1的个数
int main() {
int a = 0;
scanf("%d", &a);
int count = 0;
while (a) {
a = a & (a - 1); // 每次消去最低位的1
count++; // 消去一次则计数+1
}
printf("Sum: %d\n", count);
return 0;
}
应用 2：判断一个数是否是 2 的次方数
核心原理：2 的次方数的二进制补码中仅有 1 个 1；若 n 是 2 的次方数，则n & (n - 1) == 0（唯一的 1 被消去，结果为 0）。判断条件：if ((n & (n - 1)) == 0) → 成立则为 2 的次方数。
拓展：二进制位置 0 / 置 1 的实现
需求：将 13 的二进制序列的第 5 位修改为 1，再改回 0（位序从 0 开始计数）。
步骤分析
- 13 的 32 位二进制（原 / 反 / 补码）：
0000 0000 ... 0000 1101； - 第 5 位置 1：需构造掩码
B=1<<4=16（二进制0000 0000 ... 0001 0000），通过a |= B置 1（按位或可保留原有位，指定位置 1）； - 第 5 位改回 0：构造掩码
~B（二进制1111 1111 ... 1110 1111），通过a &= ~B置 0（按位与可保留原有位，指定位置 0）。
实现代码
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 13;
printf("原数为%d\n", a); // 输出13
int b = 1 << 4; // 构造第5位为1的掩码，16
a |= b; // 第5位置1
printf("第5位修改为1后为%d\n", a); // 输出29
a &= (~b); // 第5位改回0
printf("第5位改回0后为%d\n", a); // 输出13
return 0;
}运行结果
本文部分代码：Luminous/Luminousbegin - Gitee.com
我的代码仓库（练习仓库）：Luminous/Luminousbegin - Gitee.com
完......
1025
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
