computer-basic on 风酥糖

大小端序存储

Wed, 25 Feb 2026 15:46:39 +0800

端序概念

端序（Endianness)主要定义了多字节数据在内存地址中的存放顺序.

大端模式 (Big-Endian): 数据的高位字节（MSB)存放在内存的低地址端.
- 符合人类从左到右的阅读习惯.
小端模式 (Little-Endian): 数据的低位字节（LSB)存放在内存的低地址端.
- 符合计算机逻辑运算的处理习惯.

记忆口诀:

大端: 高位在低址

小端: 低位在低址

存储示例

以十进制数字 44033 为例, 其十六进制值为 0x0000AC01（32位整数, 4字节).

假设内存地址从左向右依次增大（低地址 -> 高地址):

模式	内存布局 (地址: 低 -> 高)	说明
大端存储	`00` `00` `AC` `01`	`01`是最低位, 放在最高地址
小端存储	`01` `AC` `00` `00`	`01`是最低位, 放在最低地址

常见标准与应用场景

大小端模式的存在, 主要是因为不同 CPU 架构的设计理念不同. 为了在不同的软硬件环境中准确地传递和解析数据, 形成了以下几个层面的标准与应用规范:

物理硬件与操作系统 (系统端序)

这一层决定了数据在物理内存条中真实的摆放顺序.

小端序 (Little-Endian) - 当前绝对主流:
- 架构: Intel/AMD 的 x86/x64 架构, 以及大部分移动设备使用的 ARM 架构.
- 操作系统: Windows, Linux, Android, iOS, 以及现代的 macOS (Intel 和 Apple Silicon 芯片).
- 优势: CPU 从低地址读取低位字节, 方便在读取的同时进行进位运算, 硬件电路设计相对简单高效.
大端序 (Big-Endian) - 历史与特定设备:
- 架构: 早期的 PowerPC 架构, SPARC 架构, 以及 IBM 大型机.
- 操作系统: 早期的 Mac OS (基于 PowerPC 芯片时代).

编程语言层面的处理 (语言端序)

不同编程语言对底层硬件的抽象程度不同, 导致它们对待端序的策略也不同:

C / C++ (贴近硬件的 Native 语言):
- 策略: 完全映射底层硬件. 硬件是小端, 程序内存里就是小端.
- 特点: 允许通过指针直接访问物理内存布局, 因此可以用 C 语言代码准确检测出当前系统的端序.
Java (自带虚拟机的跨平台语言):
- 策略: 强制统一标准, 屏蔽硬件差异.
- 特点: Java 虚拟机 (JVM) 规范要求其类文件结构, 字节流解析默认统一使用 大端序 (Big-Endian) . 底层运行时, JVM 会自动将宿主机的小端数据翻转为大端供 Java 程序使用. 因此, Java 程序员通常不需要感知底层硬件的端序.
Go / Rust: 类似于 C, 默认采用宿主机的字节序（通常是小端), 但在标准库中提供了显式处理大端/小端的包（如 Go 的 encoding/binary), 方便编写网络协议.
Python: 纯解释型语言. 整数在 Python 内部是一个复杂的对象（PyObject), 根本看不到它底层的字节序. 只有当使用 struct 模块把数字转成二进制流时, 才需要指定 < (小端) 或 > (大端).

网络数据传输 (TCP/IP 协议标准)

这是端序转换最核心的应用场景.

痛点: 如果一个运行在 x86 系统 (小端) 的电脑, 给一个运行在老式 IBM 主机 (大端) 的设备发送数据, 由于双方解析字节流的顺序相反, 数据就会出错.
统一标准 (网络字节序): 为了解决异构平台的通信问题, TCP/IP 协议强制规定: 在网络上传输的多字节数据, 必须统一采用大端模式 (Big-Endian) .
转换规则:
- 单字节数据 (char): 只占 1 个字节, 不存在顺序问题, 直接传输.
- 多字节数据 (int, short, float等):
  - 发送端: 必须先将数据从主机字节序转换为网络字节序 (大端) 后, 再发送到网络上.
  - 接收端: 收到网络数据后, 必须将其从网络字节序转换回当前环境对应的主机字节序, 然后再进行处理.

在实际工作中, 我们在定消息协议时, 可以提前定义好字节序与对齐方式, 之后网络两端的程序都按照规定的方式解析

比如某个消息按照二进制传输, 约定字节按照1字节对齐(无空白字节填充), 小端序传输, 只要保证所有网络端的程序都按照相同约定的方式处理数据即可

字节端序源码示例

以下代码演示了 Python 中如何使用大端或小端打包数据, 并按字节输出, 与之前的结论示例对应

import struct

# 数字 44033 (0x0000AC01)

print("--- 小端模式 (<) ---")
# pack('<i'): 小端打包成 int
# unpack('<BBBB'): 按小端解包成 4 个 unsigned char
result = struct.unpack('<BBBB', struct.pack('<i', 44033))
print('0x', end='')
for b in result:
    print(f'{b:02X}', end='')
# 输出: 0X01AC0000 (低位 01 在前)

print("\n\n--- 大端模式 (>) ---")
# pack('>i'): 大端打包成 int
result = struct.unpack('>BBBB', struct.pack('>i', 44033))
print('0x', end='')
for b in result:
    print(f'{b:02X}', end='')
# 输出: 0X0000AC01 (高位 00 在前)

使用C语言检测系统端序

可以通过检查变量在内存中的首字节来判断当前环境的端序

方法一: 指针强制转换法

原理: 将 int 的地址强制转换为 char*, 只读取内存的第一个字节（低地址).

#include <stdio.h>

int test1_endian() {
    int i = 1; // 十六进制 0x00000001
    char *a = (char *)&i; // 获取低地址的值

    // 如果低地址存的是 1, 说明低位在低址 -> 小端
    if (*a == 1)
         printf("当前系统为: 小端\n");
    else
         printf("当前系统为: 大端\n");
    return 0;
}

方法二: 联合体法

原理: Union 的所有成员共用同一块内存首地址.

#include <stdio.h>

int test2_endian() {
     union {
            int i;
            char c;
     } un;

     un.i = 1; // 写入 0x00000001

     // 读取 c, 相当于读取 int 的低地址字节
     if(un.c == 1) {
            printf("当前系统为: 小端\n");
     }
     else {
            printf("当前系统为: 大端\n");
     }
     return 0;
}

IEEE 浮点数结构

Sun, 25 Jan 2026 00:00:00 +0000

浮点数在内存中的存储结构

基础概念

十进制整数转二进制为除 2 取余, 逆序排列
十进制小数转二进制为乘 2 取整, 顺序排列
二进制转十进制是每位加权求和

$$ 11.1101_2=1\times2^1+1\times2^0+1\times2^{-1}+1\times2^{-2}+0\times2^{-3}+1\times2^{-4} $$

n 进制的科学计数法 $a*n^b$ ($0<|a|<n$) 其中 a 和 b 都是 n 进制数字, 类比十进制, b 表示 n 进制指数 (小数点移动的位数)

例: 二进制 $10000_2=1*2^{100_2}$, 指数相当于十进制的 4, 也就是小数点向右移动 4 位

浮点数国际标准 IEEE 754

国际标准 IEEE 754 标准使用一个三元组 ${S, E, M}$ 表示一个浮点数N

S 符号位, 0 和 1 分别表示正和负
E 阶码, 用移码表示
M 尾码, 按照 IEEE 754 标准存储浮点数需要先规格化, 最后的尾码一定是 $(1.xxxxx)_2$ 的二进制格式, 第一位一定是1, 因此尾码存储时舍去了第1位的1, 只保存了二进制小数部分, 这样可以多表示一位

浮点数的规格化

同一个浮点数的表示规格并不统一, 比如 $(1.11)_2\times 2^0 = (0.111)_2\times 2^1 = (0.0111)_2\times 2^2$.

为了数据的表示精度, 就必须充分利用尾码的有效位数, IEEE 754 标准中当尾码大小不是 $(1.xxxx)_2$ 格式时就左右移动小数点并同时修改阶码大小, 直到达到要求, 该过程称为浮点数规格化

浮点数的表示

浮点数中的指数 e 可能有正有负, 为了方便表示, 将 e 增加一个固定的偏移量得到移码 E 作为阶码

移码 E 在浮点数中是一段二进制的无符号整数, 依据二进制位计算出 E 的值再去掉固定偏移量, 即可得到指数 e 的值

平常使用最多的是单精度(32位)和双精度(64位)浮点数, 尾码部分默认小数点前的一位1省去了, 后面不再赘述

单精度浮点数

符号位(S) 1位, 阶码(E) 8位, 尾码(M) 23位

其中阶码偏移量为 127 (0x7F), 尾码仅表示小数部分, 前面的1和小数点省略

真值表示: $X=(-1)^S\times (1.M) \times 2^{E - 127}$ $e=E-127$

由于 $2^{23}=8388608$ 最大可表示精度为 7 位, 但不能表示所有的 7 位数, 可保证 6 位精度

双精度浮点数

符号位(S) 1位, 阶码(E) 11位, 尾码(M) 52位

其中阶码偏移量为 1023 (0x3FF), 尾码仅表示小数部分, 前面的1和小数点省略

真值表示: $X=(-1)^S\times (1.M) \times 2^{E - 1023}$ $e=E-1023$

由于 $2^{52}=4503599627370496$ 最大表示精度为 16 位, 不能表示所有 16 位数字, 保证精度为 15 位

特殊值

在特殊情况下, 浮点数的计算不再按照常规的方式计算, 而是直接表示特殊的真值, 以下对于单精度和双精度都一样

真值0: 当阶码E全0, 且尾数M全0时, 表示真值X为0, 由于符号位不同, 所以有正负0两种表示
无穷大: 当阶码E全1, 且尾码M全0时, 表示真值为无穷大, 符号位不同可以表示正负无穷大
NaN: 当阶码全1, 且尾码M非全0时, 全都表示NaN, NaN没有正负之分, 符号位0或1都是NaN

因为特殊值的存在, 所以浮点数在表示一般的数值时, 其实阶码E可用的范围需要去掉全0和全1的特殊情况, 在单精度浮点数中, 也就意味着E的取值范围是 [1, 254], 对应的指数 e 取值范围是 [-126, 127], 因此单精度浮点数表示范围为

$$ (-1)^1 \times (1.M_{max}) \times 2^{127} \approx -3.4028235 \times 10 ^ {38} $$

到

$$ (-1)^0 \times (1.M_{max}) \times 2^{127} \approx 3.4028235 \times 10 ^ {38} $$

在取最大/最小值时, 仅符号位不同, 尾码M为23位全1, 指数取最大127

当浮点数的绝对值非常小, 非常接近0, 连阶码取最小值都无法表达时, IEEE 754 允许它进入非规格化状态, 此时 $E = 0$, 并且默认隐含的最高位 1 变成了 0, 指数被固定为 -126, 此时的真值计算

$$ X = (-1)^S \times (0 + M) \times 2^{-126} $$

当 $E = 0$ 且 $M \neq 0$ 时, 则浮点数为非规格化表达, 默认隐含最高位为0

编码测试

编写一个函数, 用于将数值以二进制打印

const std = @import("std");

fn printBits(value: anytype) void {
    const T = @TypeOf(value);
    const bit_width = @bitSizeOf(T);
    const UnsignedT = std.meta.Int(.unsigned, bit_width);
    const bits: UnsignedT = @bitCast(value);
    std.debug.print("{d:<5} {s:<5}: ", .{ value, @typeName(T) });
    var i: usize = 0;
    while (i < bit_width) : (i += 1) {
        const ShiftType = std.math.Log2Int(UnsignedT);
        const shift_amt = @as(ShiftType, @intCast(bit_width - 1 - i));
        const bit = (bits >> shift_amt) & 1;
        std.debug.print("{d}", .{bit});
        // 每8位打印一个空格 (除了最后一位)
        if ((i + 1) % 8 == 0 and (i + 1) < bit_width) {
            std.debug.print(" ", .{});
        }
    }
    std.debug.print("\n", .{});
}

先看一下1.0的结果 printBits(@as(f32, 1.0))

输出为 1 f32 : 00111111 10000000 00000000 00000000

其中S=0, $E=(01111111)_2=127$, M=0

也就是 $1.0=(-1)^S\times (1.M) \times 2^{E-127}=1\times 1.0 \times 2^0$

再试试0.5, printBits(@as(f32, 0.5))

输出为 0.5 f32 : 00111111 00000000 00000000 00000000 与1.0的区别仅仅是阶码小了1

真值计算 $0.5=(-1)^(0)\times (1.0) \times 2^{126-127}=1\times 1.0 \times 2^{-1}$

用源码验证一下所有特殊值是否如我们所想

pub fn main() void {
    printBits(@as(f32, 0.0));
    printBits(-@as(f32, 0.0));
    printBits(@as(f32, 1.0));
    printBits(@as(f32, 0.5));
    const inf = std.math.inf(f32);
    printBits(inf);
    printBits(-std.math.inf(f32));
    printBits(std.math.nan(f32));
    printBits(-std.math.nan(f32));
    var nan_test = std.math.nan(f32);
    var nan_u32: u32 = @bitCast(nan_test);
    nan_u32 = (nan_u32 | (1 << 3));
    nan_test = @bitCast(nan_u32);
    printBits(nan_test);

    var inf_test: u32 = @bitCast(inf); // inf 按位转换为 u32, 方便位处理
    inf_test = (inf_test | (1 << 3));
    const value: f32 = @bitCast(inf_test); // 位处理之后转换回 f32
    printBits(value);
}

输出结果如下

0     f32  : 00000000 00000000 00000000 00000000
-0    f32  : 10000000 00000000 00000000 00000000
1     f32  : 00111111 10000000 00000000 00000000
0.5   f32  : 00111111 00000000 00000000 00000000
inf   f32  : 01111111 10000000 00000000 00000000
-inf  f32  : 11111111 10000000 00000000 00000000
nan   f32  : 01111111 11000000 00000000 00000000
-nan  f32  : 11111111 11000000 00000000 00000000
nan   f32  : 01111111 11000000 00000000 00001000
nan   f32  : 01111111 10000000 00000000 00001000

可以发现, 无穷大的阶码全1, 尾码全0, 改变符号位可得到正/负无穷大

NaN阶码全1, 尾码非0, 改变符号位依然是NaN

在NaN的基础上将尾码稍加改动, 只要不改为全0, 都是NaN (倒数第2行输出)

在无穷大的基础上, 将尾码倒数第4位(随机一位)设置为1, 输出为NaN, 符合预期 (最后一行输出)