数值数据类型及其内存存储实现简介（C&C++）

一、常见数值数据类型

1.1 整型类

类型	字节大小	取值范围	说明
char	1	-128 到 127	字符型，本质属于整数类型
unsigned char	1	0 到 255	无符号字符型
int	4	-2³¹ 到 2³¹-1	基本整型（主流平台）
unsigned int	4	0 到 2³²-1	无符号基本整型
short	2	-32,768 到 32,767	短整型（等价于 short int）
unsigned short	2	0 到 65,535	无符号短整型
long	4/8	-2³¹ 到 2³¹-1 /-2⁶³ 到 2⁶³-1	长整型，Windows 平台为 4 字节，Linux/macOS 平台为 8 字节
unsigned long	4/8	0 到 2³²-1 / 0 到 2⁶⁴-1	无符号长整型，字节数与 long 一致
long long	8	-2⁶³ 到 2⁶³-1	超长整型（C99 标准新增）
unsigned long long	8	0 到 2⁶⁴-1	无符号超长整型

1.2 浮点型类

类型	典型大小（字节）	取值范围	精度	说明
float	4	约 ±3.4×10±38	约 6-7 位有效数字	单精度浮点数
double	8	约 ±1.7×10±308	约 15-16 位有效数字	双精度浮点数（默认浮点类型）
long double	10/12/16	约 ±1.2×10-4932 到 ±1.1×104932	精度通常比 double 高	扩展精度浮点数，大小依赖编译器与系统

二、数值的内存存储规则

在 C/C++ 中，整型数值统一以补码形式存储，以简化硬件层面的加减运算；浮点型数值则遵循 IEEE 754 标准 存储，结构与整型完全不同。以下分类型详解存储逻辑。

2.1 整型数值的存储（补码规则）

补码的核心作用是将 “减法” 转化为 “加法”，无需单独处理符号位。其推导依赖 “原码” 和 “反码” 两个概念，不同符号的整数，补码计算方式不同。

2.1.1 正数的补码

正数的补码 = 原码（即该数的二进制表示），空位补 0。

示例：十进制 10 用 short（2 字节）存储
1. 十进制 10 转为二进制原码：1010
2. 补齐 16 位（short 长度）：0000 0000 0000 1010
3. 补码与原码一致，最终存储为 0000 0000 0000 1010

2.1.2 负数的补码

负数的补码 = 其相反数的原码 → 各位取反（反码）→ 尾位加 1。

示例：十进制 -10 用 char（1 字节）存储
1. 求相反数 10 的原码：0000 1010
2. 各位取反得到反码：1111 0101
3. 尾位加 1 得到补码：1111 0110
4. 最终存储为 1111 0110

2.1.3 十进制转二进制（正数）代码实现

以下代码将十进制正数转为二进制，并以 int（4 字节）格式输出，空位补 0。

cpp

运行

#include <iostream>
using namespace std;

int main() {
    int n;
    int dectobin[32] = {0};  // int 占 4 字节 = 32 位，初始化数组存每一位
    cin >> n;

    int i = 31;  // 从最高位（第31位）开始填充
    while (n != 0 && i >= 0) {  // 增加 i>=0 避免数组越界
        dectobin[i] = n % 2;
        n /= 2;
        i--;
    }

    // 输出 32 位二进制
    for (auto& k : dectobin) {
        cout << k;
    }
    return 0;
}

2.2 浮点型数值的存储

浮点型数值无法用 “补码” 存储，需按 IEEE 754 标准拆分为 符号位、指数位、尾数位 三部分，结构如下表所示：

类型	总位数	符号位（1 位）	指数位（n 位）	尾数位（m 位）	指数偏移值
float	32	第 31 位	第 30-23 位（8 位）	第 22-0 位（23 位）	127（2⁸⁻¹ - 1）
double	64	第 63 位	第 62-52 位（11 位）	第 51-0 位（52 位）	1023（2¹¹⁻¹ - 1）

2.2.1 存储核心规则

符号位：0 表示正数，1 表示负数。
指数位：用 “偏移值” 统一表示正负指数，计算方式为：实际指数 = 存储指数 - 偏移值（存储指数为无符号整数）。
尾数位：采用 “规格化表示”，默认整数部分为 1（不存储），仅存储小数部分，以节省空间。

2.2.2 示例：十进制 `-0.65` 以 `float` 存储

步骤 1：求绝对值的二进制小数十进制 0.65 转二进制（小数部分可能循环，需按 float 精度截断）：
- 0.65 × 2 = 1.3 → 整数 1（记为第 1 位），余小数 0.3
- 0.3 × 2 = 0.6 → 整数 0（记为第 2 位），余小数 0.6
- 0.6 × 2 = 1.2 → 整数 1（记为第 3 位），余小数 0.2
- 0.2 × 2 = 0.4 → 整数 0（记为第 4 位），余小数 0.4
- 0.4 × 2 = 0.8 → 整数 0（记为第 5 位），余小数 0.8
- 0.8 × 2 = 1.6 → 整数 1（记为第 6 位），余小数 0.6（开始循环）
- 最终二进制小数：0.101001 1001 1001...（循环节为 1001）
步骤 2：规格化与指数计算规格化要求小数点移到 “第一个 1 之后”：
- 原二进制：0.101001... → 右移 1 位 → 1.01001... × 2⁻¹
- 实际指数 = -1，存储指数 = 实际指数 + 偏移值（127）= 126 → 二进制 01111110
步骤 3：确定尾数位float 尾数位共 23 位，仅存储规格化后 “1.” 后的小数部分：
- 小数部分：01001 1001 1001 1001 1001 10（共 23 位，截断循环部分）
步骤 4：拼接三部分
- 符号位：-0.65 为负数 → 1
- 指数位：126 的二进制 → 01111110
- 尾数位：01001100110011001100110
- 最终 32 位存储：1 01111110 01001100110011001100110