💻作 者 简 介：曾 与 你 一 样 迷 茫，现 以 经 验 助 你 入 门 C 语 言
💡个 人 主 页：@笑口常开xpr 的 个 人 主 页
📚系 列 专 栏：C 启 新 程
✨代 码 趣 语：最 开 始 的 90% 代 码 占 用 了 开 始 的 90% 的 开 发 时 间；剩 下 10% 代 码 同 样 需 要 90% 的 开 发 时 间。
💪代 码 千 行，始 于 坚 持，每 日 敲 码，进 阶 编 程 之 路。
📦gitee 链 接：gitee

       在 编 程 的 世 界 里，每 一 行 代 码 都 可 能 隐 藏 着 无 限 的 可 能 性 。你 是 否 想 过，一 个 小 小 的 程 序 究 竟 能 改 变 什 么？它 可 以 是 解 决 复 杂 问 题 的 工 具 ，也 可 以 是 实 现 梦 想 的 桥 梁。今 天，就 让 我 们 一 起 走 进 C 语 言 操 作 符 的 世 界，探 索 它 的 无 限 潜 力。

移 位 操 作 符

定 义

       在 C 语 言 里，移 位 操 作 符 用 于 对 二 进 制 位 进 行 移 动 操 作，主 要 有 左 移（<<）和 右 移（>>）两 种。

原 码 补 码 和 反 码

在 计 算 机 中，原 码、反 码 和 补 码 是 用 于 表 示 有 符 号 整 数 的 三 种 编 码 方 式

原 码

         原 码 是 一 种 最 简 单 的 机 器 数 表 示 法。最 高 位 作 为 符 号 位，0 表 示 正 数，1 表 示 负 数，其 余 位 表 示 数 值 的 绝 对 值。
例 如，在 8 位 二 进 制 表 示 中：
+5 的 原 码 是 0000 0101。
-5 的 原 码 是 1000 0101。

反码

         正 数 的 反 码 和 原 码 相 同；负 数 的 反 码 是 在 原 码 的 基 础 上，符 号 位 不 变，其 余 位 按 位 取 反。
例 如，在 8 位 二 进 制 表 示 中：
+5 的 原 码 是 0000 0101，反 码 同 样 是 0000 0101。
-5 的 原 码 是 1000 0101，反 码 则 是 1111 1010。

补 码

正 数 的 补 码 和 原 码 相 同；负 数 的 补 码 是 在 反 码 的 基 础 上 加 1。
例 如，在 8 位 二 进 制 表 示 中 ：
+5 的 原 码 是 0000 0101，补 码 同 样 是 0000 0101。
-5 的 原 码 是 1000 0101，反 码 是 1111 1010，补 码 是 1111 1011。

使 用 补 码 的 原 因

         内 存 中 存 储 补 码 的 二 进 制。使 用 补 码 能 够 简 化 计 算 机 的 运 算，因 为 可 以 把 减 法 运 算 转 化 为 加 法 运 算，进 而 减 少 计 算 机硬 件 的 复 杂 度。

总 结

正 数：

原 码 反 码 和 补 码 都 是 它 本 身。

负数：

补 码 —> 反 码 的 两 种 方 式：

反 码 和 补 码 都 是 符 号 位 不 变，也 就 是 第 1 位 不 变。

左 移（<<）

       将 操 作 数 的 二 进 制 位 向 左 移 动 指 定 的 位 数，右 边 空 出 的 位 用 0 填 充。

下 面 展 示代码示例。

#include <stdio.h>
int main() 
{int num1 = 5; //整型是4个字节,所以是32个比特位//00000000000000000000000000000101 --- 5的原码//00000000000000000000000000000101 --- 5的反码//00000000000000000000000000000101 --- 5的补码int result1 = num1 << 1; //左移1位,结果为10//00000000000000000000000000001010 --- 左边去掉1个0,右边补1个0int num2 = -5;//10000000000000000000000000000101 --- -5的原码//11111111111111111111111111111010 --- -5的反码//11111111111111111111111111111011 --- -5的补码int result2 = num2 << 1;//左移1位,结果为-10//11111111111111111111111111110110 --- 左边去掉1个1,右边补1个0//10000000000000000000000000001001 --- 取反//10000000000000000000000000001010 --- +1,结果为-10int num3 = -5;//10000000000000000000000000000101 --- -5的原码//11111111111111111111111111111010 --- -5的反码//11111111111111111111111111111011 --- -5的补码int result3 = num3 << 2;//左移2位,结果为-20//11111111111111111111111111101100 --- 左边去掉2个1,右边补2个0//10000000000000000000000000010011 --- 取反//10000000000000000000000000010100 --- +1,结果为-20printf(" 5左移1位是:%3d\n", result1);printf("-5左移1位是:%3d\n", result2);printf("-5左移2位是:%3d\n", result3);return 0;
}

运 行 结 果 是 ：

总 结：

         左 移 n 位 相 当 于 乘 以 2 的 n 次 方。
         将 操 作 数 的 二 进 制 位 向 左 移 动 指 定 的 位 数，如 果 是 正 数，左 边 去 掉 几 个 0，如 果 是 负 数，左 边 去 掉 几 个 1，右 边 空 出 的 位 用 0 填 充。

右 移（>>）

         把 操 作 数 的 二 进 制 位 向 右 移 动 指 定 的 位 数。右 移 分 为 逻 辑 右 移 和 算 术 右 移：
逻 辑 右 移：左 边 空 出 的 位 用 0 填 充。
算 术 右 移：左 边 空 出 的 位 用 原 符 号 位 填 充。

         对 于 有 符 号 整 数 的 右 移 操 作 采 用 的 是 算 术 右 移。无 符 号 整 数 的 右 移 操 作 采 用 的 是 逻 辑 右 移。

算 术 右 移

有 符 号 数 右 移 许 多 次 后，正 数 变 为 0，负 数 成 -1。
只 有 -1 的 补 码 全 是 1。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = -1;//只有-1的补码全是1;//10000000000000000000000000000001 - 原码//11111111111111111111111111111110 - 反码//11111111111111111111111111111111 - 补码int b = a >> 1;//11111111111111111111111111111111 - 补码//10000000000000000000000000000000 - //10000000000000000000000000000001 - 原码int c = 1;//00000000000000000000000000000001 - 原码int d = c >> 1;//00000000000000000000000000000000 - 补码printf("%d\n", b);printf("%d\n", d);return 0;
}

逻 辑 右 移

         在 逻 辑 右 移 中，将 二 进 制 数 整 体 向 右 移 动 指 定 的 位 数，右 边 移 出 的 位 直 接 舍 弃，而 左 边 空 出 的 位 用 0 来 填 充。

特 点

• 数 值 缩 小：每 右 移 一 位，相 当 于 该 无 符 号 数 除 以 2 并 向 下 取 整。不 断 右 移，数 值 会 逐 渐 变 小，最 终 变 为 0。
• 不 改 变 符 号 性 质：由 于 无 符 号 数 本 身 就 不 存 在 正 负 之 分，右 移 操 作 不 会 改 变 其 无 符 号 的 性 质。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{unsigned int num = 100;//00000000000000000000000001100010//32+64int right = num >> 4;//00000000000000000000000000000110 --- 6printf("%u\n", right);return 0;
}

注 意 事 项

操 作 数 类 型

         逻 辑 右 移 主 要 用 于 无 符 号 整 数。如 果 操 作 数 是 有 符 号 整 数，右 移 操 作 可 能 是 算 术 右 移（ 高 位 补 符 号 位），具 体 取 决 于 编 译 器 和 平 台。

右 移 位 数

       右 移 的 位 数 不 能 超 过 操 作 数 的 位 数，否 则 结 果 是 未 定 义 的。例 如，对 于 32 位 无 符 号 整 数，右 移 位 数 应 在 0 到 31 之 间。

按 位 与、按 位 或、和 按 位 异 或

按 位 与

定 义

在 C 语 言 里，按 位 与 是 一 种 基 本 的 位 操 作，使 用 & 运 算 符 来 实 现。

原 理

         按 位 与 操 作 会 对 两 个 操 作 数 的 对 应 二 进 制 位 进 行 逐 位 比 较，当 且 仅 当 两 个 对 应 位 都 为 1 时，结 果 的 该 位 才 为 1，否 则 为 0。

口 诀

同 为 1 则 1，否 则 为 0

解 释

         在 按 位 与 操 作 里，对 两 个 操 作 数 的 每 一 对 对 应 的 二 进 制 位 进 行 比 较。只 有 当 这 两 个 对 应 的 二 进 制 位 都 为 1 时，结 果 的 对 应 位 才 会 是 1；只 要 有 一 个 位 是 0，结 果 的 对 应 位 就 为 0。

真 值 表：

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 3;//00000000000000000000000000000011 --- 补码int b = -5;//10000000000000000000000000000101 --- 原码//11111111111111111111111111111010 --- 反码//11111111111111111111111111111011 --- 补码int c = a & b;//a和b的补码//00000000000000000000000000000011 --- a的补码//11111111111111111111111111111011 --- b的补码//00000000000000000000000000000011 --- a & bprintf("%d\n", c);return 0;
}

注 意

         在 进 行 按 位 与 运 算 完 之 后，如 果 最 高 位 为 1，则 需 要 将 补 码 转 化 为 原 码。如 果 最 高 位 为 0，则 不 需 要 转 化 为 原 码，直 接 化 成 十 进 制 即 可。

按 位 或

定 义

在 C 语 言 中，按 位 或 是 一 种 基 本 的 位 操 作，使 用 | 运 算 符 实 现。

原 理

         按 位 或 操 作 会 对 两 个 操 作 数 的 对 应 二 进 制 位 进 行 逐 位 比 较，只 要 两 个 对 应 位 中 有 一 个 为 1 ，结 果 的 该 位 就 为 1；只 有 当 两 个 对 应 位 都 为 0 时，结 果 的 该 位 才 为 0。

口 诀

有 1 则 1，全 0 为 0

口 诀 解 释

         按 位 或 操 作 是 对 两 个 操 作 数 的 每 一 对 对 应 的 二 进 制 位 进 行 比 较。在 比 较 过 程 中，只 要 这 两 个 对 应 的 二 进 制 位 中 有 一 个 是 1，那 么 结 果 的 对 应 位 就 为 1；只 有 当 这 两 个 对 应 的 二 进 制 位 都 为 0 时，结 果 的 对 应 位 才 为 0。

真 值 表：

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 3;//00000000000000000000000000000011int b = -5;//10000000000000000000000000000101 --- b的原码//11111111111111111111111111111010 --- b的反码//11111111111111111111111111111011 --- b的补码int c = a | b;//00000000000000000000000000000011 --- a的反码//11111111111111111111111111111011 --- b的补码//11111111111111111111111111111011 --- a|b//10000000000000000000000000000100 --- 反码//10000000000000000000000000000101 --- 原码 --- -5printf("%d\n", c);return 0;
}

按 位 异 或

定 义

在 C 语 言 里，按 位 异 或 是 一 种 常 用 的 位 操 作，借 助 ^ 运 算 符 来 实 现。

原 理

         按 位 异 或 操 作 会 对 两 个 操 作 数 的 对 应 二 进 制 位 进 行 逐 位 比 较，当 两 个 对 应 位 不 同 时，结 果 的 该 位 为 1；当 两 个 对 应 位 相 同 时，结 果 的 该 位 为 0。

口 诀

相 同 为 0，不 同 为 1

口 诀 解 释

         在 按 位 异 或 操 作 中，会 对 两 个 操 作 数 对 应 的 每 一 对 二 进 制 位 进 行 比 较。当 这 两 个 对 应 的 二 进 制 位 数 值 一 样 时，结 果 的 对 应 位 就 为 0； 当 这 两 个 对 应 的 二 进 制 位 数 值 不 一 样 时，结 果 的 对 应 位 则 为 1。

真 值 表：

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 3;//00000000000000000000000000000011 --- a的补码int b = -5;//10000000000000000000000000000101 --- b的原码//11111111111111111111111111111010 --- b的反码//11111111111111111111111111111011 --- b的补码int c = a ^ b;//00000000000000000000000000000011 --- a的补码//11111111111111111111111111111011 --- b的补码//11111111111111111111111111111000 --- a ^ b//10000000000000000000000000000111 --- 反码//10000000000000000000000000001000 --- 原码 --- -8printf("%d\n", c);return 0;
}

使 用 按 位 异 或 交 换 两 个 数 的 值，不 使 用 临 时 变 量

下 面 展 示代 码 示 例。

#include <stdio.h>
int main()
{int a = 10;int b = 20;scanf("%d %d", &a, &b);a = a ^ b;b = a ^ b;a = a ^ b;printf("%d %d\n", a, b);return 0;
}

逻 辑 反 操 作

定 义

         在 C 语 言 里，逻 辑 反 操 作 也 被 叫 做 逻 辑 非 操 作，使 用 逻 辑 非 运 算 符 ! 来 实 现。

原 理

         逻 辑 反 操 作 是 一 种 单 目 操 作 符，它 作 用 于 一 个 布 尔 值（在 C 语 言 里，非 零 值 表 示 真，零 值 表 示 假），把 真 变 为 假，把 假 变 为 真。具 体 规 则 如下：
若 操 作 数 为 非 零 值（即 真），逻 辑 反 操 作 的 结 果 为 0（即 假）。
若 操 作 数 为 0（即 假），逻 辑 反 操 作 的 结 果 为 1（即 真）。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int flag = 0;printf("%d\n", flag);printf("%d\n", !flag);return 0;
}

负 值 操 作

减 法 运 算 符

         “-” 操 作 符 可 用 于 两 个 数 值 间 的 减 法 运 算。它 能 处 理 整 数、浮 点 数 等 不 同 类 型 的 数 据。

下 面 展 示代 码 示 例。

#include <stdio.h>int main() 
{int a = 10;int b = 5;int result = a - b;printf("%d\n", result);return 0;
}

负 号 运 算 符

“-” 操 作 符 还 能 作 为 负 号 运 算 符，用 来 改 变 一 个 数 值 的 正 负 性。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 10;printf("%d\n", a);printf("%d\n", -a);
}

复 合 赋 值 运 算 符

         “-” 可 以 和 “=” 结 合 形 成 复 合 赋 值 运 算 符 “ -= ”，其 作 用 是 从 变 量 里 减 去 一 个 值，再 把 结 果 赋 给 该 变 量。

下 面 展 示代 码 示 例。

#include <stdio.h>int main() 
{int num = 10;num -= 3; // 等价于num = num - 3;printf("%d\n", num);return 0;
}

按 位 取 反

定 义

         在 C 语 言 里，按 位 取 反 操 作 符 是 ~，它 属 于 单 目 操 作 符，也 就 是 只 需 一 个 操 作 数。该 操 作 符 会 对 操 作 数 的 每 一 位（包 含 符 号 位）。 进 行 取 反 操 作，即 把 0 变 为 1，把 1 变 为 0。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 10;//00000000000000000000000000001010 --- a的补码//11111111111111111111111111110101 --- 按位取反//10000000000000000000000000001010 --- 取反//10000000000000000000000000001011 --- 原码 --- -11printf("%d\n", ~a);return 0;
}

逻 辑 与

定 义

         在 C 语 言 中，逻 辑 与 操 作 是 一 种 布 尔 运 算，属 于 二 元 运 算 符，也 就 是 需 要 两 个 操 作 数。使 用 && 运 算 符 来 实 现。

原 理

         逻 辑 与 操 作 用 于 对 两 个 布 尔 表 达 式 进 行 运 算，只 有 当 两 个 表 达 式 的 值 都 为 真（在 C 语 言 里，非 零 值 表 示 真，零 值 表 示 假）时，整 个 逻 辑 与 表 达 式 的 结 果 才 为 真；只 要 有 一 个 表 达 式 的 值 为 假，结 果 就 为 假。

真 值 表

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 0;int b = 5;if (a && b){printf("hehe\n");}return 0;
}

结 果 解 释

         这 段 代 码 中，因 变 量 a 为 0、b 为 5，二 者 按 位 与（&）结 果 在 逻 辑 判 断 中 为 假，致 使 if 条 件 不 成 立，其 语 句 块 代 码 不 执 行，程 序 无 输 出。

短 路 特 性

         逻 辑 与 运 算 符 具 有 短 路 特 性。也 就 是 说，当 计 算 表 达 式 1 && 表 达 式 2 时，如 果 表 达 式 1 的 值 为 假，那 么 就 不 会 再 计 算 表 达 式 2，因 为 无 论 表 达 式 2 的 值 是 什 么，整 个 逻 辑 与 表 达 式 的 结 果 都 已 经 确 定 为 假。

下 面 展 示代 码 示 例。

#include <stdio.h>
int main()
{int i = 0, a = 0, b = 2, c = 3, d = 4;i = a++ && ++b && d++;//左边为假,右边不计算printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);a = 1, b = 2, c = 3, d = 4;i = ++a && ++b && d++;//一直计算到真printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);return 0;
}

逻 辑 或

定 义

         在 C 语 言 中，逻 辑 或 操 作 是 一 种 布 尔 运 算，属 于 二 元 运 算 符，也 就 是 需 要 两 个 操 作 数。使 用 || 运 算 符 来 实 现。

原 理

         逻 辑 或 操 作 用 于 对 两 个 布 尔 表 达 式 进 行 运 算，只 要 两 个 表 达 式 中 有 一 个 的 值 为 真（在 C 语 言 中，非 零 值 代 表 真，零 值 代 表 假），整 个 逻 辑 或 表 达 式 的 结 果 就 为 真；只 有 当 两 个 表 达 式 的 值 都 为 假 时，结 果 才 为 假。

真 值 表

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 0;int b = 5;if (a || b){printf("hehe\n");}return 0;
}

结 果 解 释

         这 段 代 码 中，因 变 量 a 为 0、b 为 5，二 者 逻 辑 或（||）结 果 在 逻 辑 判 断 中 为 真，if 条 件 成 立，其 语 句 块 代 码 执 行，程 序 有 输 出。

短路特性

         逻 辑 或 运 算 符 具 有 短 路 特 性。也 就 是 说，当 计 算 表 达 式 1 | | 表 达 式 2 时，如 果 表 达 式 1 的 值 为 真，那 么 就 不 会 再 计 算 表 达 式 2，因 为 无 论 表 达 式 2 的 值 是 什 么，整 个 逻 辑 或 表 达 式 的 结 果 都 已 经 确 定 为 真。

下 面 展 示代 码 示 例。

#include <stdio.h>
int main()
{int i = 0, a = 0, b = 2, c = 3, d = 4;i = a++ || ++b || d++;//表达式1为假,表达式2为真,后边不计算printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);a = 1, b = 2, c = 3, d = 4;i = ++a || ++b || d++;//左边为真,右边不计算printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);return 0;
}

总 结

         在 逻 辑 与 短 路 特 性 的 表 达 式 中，表 达 式 一 直 计 算 到 真 停 止，如 果 表 达 式 是 假，则 停 止 计 算。在 逻 辑 或 短 路 特 性 的 表 达 式 中，如 果 表 达 式 是 假，则 一 直 计 算，到 真 停 止，后 面 的 表 达 式 不 计 算。

三 目 操 作 符

定 义

         在 C 语 言 里，三 目 操 作 符（ 也 叫 条 件 操 作 符）是 一 个 较 为 独 特 的 运 算 符，它 能 实 现 简 单 的 条 件 判 断，使 代 码 更 加 简 洁。

基 本 语 法

条件表达式 ? 表达式1 : 表达式2

• 条 件 表 达 式：这 是 一 个 布 尔 表 达 式，其 计 算 结 果 要 么 为 真（ 非 零 值 ），要 么 为 假（ 零 值 ）。
• 表 达 式 1：当 条 件 表 达 式 的 结 果 为 真 时，三 目 操 作 符 会 返 回 该 表达 式 的 值。
• 表 达 式 2：当 条 件 表 达 式 的 结 果 为 假 时，三 目 操 作 符 会 返 回 该 表 达 式 的 值。

执 行 流 程

• 首 先 计 算 条 件 表 达 式 的 值。
• 若 条 件 表 达 式 的 值 为 真，整 个 三 目 操 作 符 表 达 式 的 值 就 是 表 达 式 1 的 值。
• 若 条 件 表 达 式 的 值 为 假，整 个 三 目 操 作 符 表 达 式 的 值 就 是 表 达 式 2 的 值。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 0;int b = (a > 5 ? 3 : -3);printf("%d\n", b);return 0;
}

逗 号 表 达 式

定 义

         在 C 语 言 中，逗 号 表 达 式 是 一 种 较 为 特 殊 的 表 达 式，它 允 许 将 多 个表 达 式 组 合 在 一 起，按 顺 序 依 次 计 算 每 个 子 表 达 式 的 值，最 后 整 个 逗 号 表 达 式 的 值 是 最 后 一 个 子 表 达 式 的 值。

基 本 语 法

表达式1, 表达式2, ..., 表达式n

         其 中，表 达 式 1、表 达 式 2 一 直 到 表 达 式 n 是 任 意 合 法 的 C 语 言 表 达 式，它 们 之 间 用 逗 号 分 隔。

执 行 流 程

         逗 号 表 达 式 的 执 行 顺 序 是 从 左 到 右 依 次 计 算 各 个 子 表 达 式 的 值。也 就 是 说，先 计 算 表 达 式 1，接 着 计 算 表 达 式 2，以 此 类 推，直 到 计 算 完 表 达 式 n。整 个 逗 号 表 达 式 最 终 的 值 就 是 表 达 式 n 的 值。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 0;int b = 2;int c = (a > b, a = b + 10, a, b = a + 1);printf("%d\n", c);return 0;
}

逗 号 表 达 式

定 义

         在 C 语 言 中，逗 号 表 达 式 是 一 种 较 为 特 殊 的 表 达 式，它 允 许 将 多 个表 达 式 组 合 在 一 起，按 顺 序 依 次 计 算 每 个 子 表 达 式 的 值，最 后 整 个 逗 号 表 达 式 的 值 是 最 后 一 个 子 表 达 式 的 值。

基 本 语 法

表达式1, 表达式2, ..., 表达式n

         其 中，表 达 式 1、表 达 式 2 一 直 到 表 达 式 n 是 任 意 合 法 的 C 语 言 表 达 式，它 们 之 间 用 逗 号 分 隔。

执 行 流 程

         逗 号 表 达 式 的 执 行 顺 序 是 从 左 到 右 依 次 计 算 各 个 子 表 达 式 的 值。也 就 是 说，先 计 算 表 达 式 1，接 着 计 算 表 达 式 2，以 此 类 推，直 到 计 算 完 表 达 式 n。整 个 逗 号 表 达 式 最 终 的 值 就 是 表 达 式 n 的 值。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 0;int b = 2;int c = (a > b, a = b + 10, a, b = a + 1);printf("%d\n", c);return 0;
}

总结

       至 此，关 于 C 语 言 的 操 作 符 探 索 暂 告 一 段 落，但 你 的 编 程 征 程 才 刚 刚 启 航。写 代 码 是 与 机 器 深 度 对 话，过 程 中 虽 会 在 语 法、算 法 困 境 里 挣 扎，但 这 些 磨 砺 加 深 了 对 代 码 的 理 解。愿 你 合 上 电 脑 后，灵 感 不 断，在 C 语 言 的 世 界 里 持 续 深 耕，书 写 属 于 自 己 的 编 程 传 奇，下 一 次 开 启 ，定 有 全 新 的 精 彩 等 待。小 编 期 待 重 逢，盼 下 次 阅 读 见 你 们 更 大 进 步，共 赴 代 码 之 约！