数据和C

为什么 C 语言里要分这么多种"数字盒子"？

想象你在一个零件仓库里：螺丝钉要放在小格子里，螺母要放在中号抽屉，发动机要放在大货架上。如果所有零件都往同一个万能麻袋里塞——小螺丝淹没在角落里找不到、大发动机根本塞不进。

在 C 语言里，数据有自己的“规格”。char 的大小按定义是 1 个 C 字节，但一个字节有多少位由 CHAR_BIT 给出；short、int、long 和浮点类型的具体大小由实现选择，只需满足标准规定的范围与顺序。程序应查询目标实现，而不是把某台机器的常见结果当成语言规则。

如果所有数据都往同一种通用盒子里塞呢？ 电脑就帮不了你检查错误——省下的空间白浪费、该存的小数精确度悄悄丢失、输出的时候格式还跟你想象的不一样。这一章就来认识 C 里这些「盒子的种类」，学会怎么挑、怎么装、怎么取出来看得清清楚楚。

C 的数据类型家族

数据变量和常量（Data Variables and Constants）

变量表示可在生命周期中取得不同值的对象；常量、枚举常量和字符串字面量等则受各自语言规则约束。类型决定值域和操作，存储期决定对象存在多久，const 限定符限制通过该左值修改对象，但 C 中的 const 对象并不自动成为所有语境都可用的整数常量表达式。

在 C 语言中，类型（type） 是程序最基本的规矩。任何一个变量在声明的那一刻就定死了类型——编译器根据类型来分配内存空间、校验运算是否合法、在 printf 输出时决定该怎么解释那段二进制数据。

类型在 C 里扮演三个角色：① 占用多少存储（sizeof 告诉你）、② 能表示什么范围与精度、③ 允许哪些运算并如何解释对象表示。不同类型不能因为碰巧大小相同就随意互相重解释。

基本数据类型一览——C 里有哪几种盒子

C 语言提供了以下 基本数据类型（basic data type）：

• int 家族：short、int、long、long long——存整数，区别在于字节数和取值范围
• char 家族：char——存字符或小整数，占 1 字节
• 浮点与复数家族：float、double、long double 及其复数对应类型——区别在于范围、精度和运算语义

下面的图展示一种常见实现的相对布局，用于建立直觉；具体结果必须由当前实现的 sizeof 与标准限制宏确认：

类型决定了三件事，在写程序时时刻都要记住：

1. 内存大小：sizeof(char) 恒为 1，其他类型大小由实现给出，并满足标准规定的相对约束
2. 取值范围：UCHAR_MAX、INT_MIN、INT_MAX 等宏给出当前实现的精确边界
3. 运算行为：整数除法和浮点除法规则不同——3 / 2 得 1，3.0 / 2.0 才得 1.5

整数和浮点数（Integer Versus Floating-Point Types）

整数类型表示离散值，整数除法向零截断；无符号运算按模数回绕，而有符号溢出是未定义行为。浮点类型表示有限精度的实数近似，范围、精度和舍入特征由实现提供并可通过 <float.h> 查询。两类参与同一表达式时会经过整数提升和通常算术转换。

整型的修饰符——控制最小范围和符号

C 语言提供了四个 修饰符（modifier） 用来调整整型的大小和符号：

修饰符可以组合：unsigned short、unsigned long long 等都是合法的——你可以同时控制大小和符号。

下面这张图直观对比了不同位宽下 signed 和 unsigned 的取值范围：

在普通算术中可优先考虑 int；unsigned 适合模运算、位掩码或标准接口明确要求的无符号类型。仅因为业务值“不应为负”就改成无符号数，可能让减法和边界比较更难诊断。

可移植类型：stdint.h 与 inttypes.h

<Term def="stdint.h 提供按能力命名的整数类型和边界宏，包括精确宽度、最小宽度、最快类型、最大宽度类型以及可保存对象指针转换结果的整数类型。精确宽度类型只在实现确实提供时才定义。">可移植整数类型</Term> 让代码表达协议真正需要的能力。int32_t 若存在就恰好 32 位且无填充位；int_least32_t 至少 32 位；int_fast32_t 是满足下限的较快类型；intmax_t 是最宽有符号整数类型。

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
 
int32_t packet_id = INT32_C(2026);
uintmax_t total = UINTMAX_C(9000000000);
 
printf("packet=%" PRId32 "\n", packet_id);
printf("total=%" PRIuMAX "\n", total);

<inttypes.h> 的 PRI 宏把类型与 printf 转换说明绑定，避免猜测 int32_t 在某实现上是 int 还是 long。二进制协议还要显式处理字节序；固定宽度类型本身不决定网络字节顺序。

浮点类型——存小数靠它们

整数搞不定的任务交给 浮点类型（floating-point type）。C 提供了三种精度档次：

• float：至少 6 位十进制有效数字
• double：精度和范围至少不低于 float，标准最低为 10 位十进制有效数字
• long double：精度和范围至少不低于 double；具体表示由实现决定

浮点数有一个根本特性必须记住：它们是近似存储的。 就像十进制里 1/3 = 0.33333... 写不完，二进制里很多十进制小数也写不完——0.1 在二进制里就是一个无限循环小数。所以浮点运算会有舍入误差。下面这段代码展示了 float 和 double 在精度上的实际差别：

#include <stdio.h>
int main(void) {
    float  f = 1.0f / 3.0f;        // float 除法
    double d = 1.0  / 3.0;         // double 除法
 
    printf("float:  %.20f\n", f);   // float 先提升为 double，再格式化
    printf("double: %.20f\n", d);   // 尾部数字展示二进制近似误差
 
    // float:  0.33333334326744079590
    // double: 0.33333333333333331483
 
    return 0;
}

复数与虚数类型

C99 的 <complex.h> 提供 float _Complex、double _Complex 和 long double _Complex。宏 I 表示虚数单位，可用 creal、cimag、cabs 等函数读取分量和模。实现是否定义纯虚数类型属于可选能力，但复数类型是标准语言与库的一部分。

#include <complex.h>
#include <stdio.h>
 
double complex z = 3.0 + 4.0 * I;
printf("real=%.1f imag=%.1f abs=%.1f\n",
       creal(z), cimag(z), cabs(z));

复数不是两个随意拼接的 double 字段；应通过标准运算与 <complex.h> 函数保持类型语义。编译命令在某些 Unix 工具链上使用数学函数时可能还需链接数学库，例如 cc file.c -lm。

字符类型与转义序列

char 可保存基本执行字符集中的字符。字符常量具有对应执行字符集的整数值；许多平台采用 ASCII 码，但 C 语言本身不强制执行字符集必须是 ASCII。

char 属于整数类型。'A' 的数值由执行字符集决定；在 ASCII 兼容实现中是 65。用 %c 按字符输出，用 %d 查看提升后的整数值：

#include <stdio.h>
int main(void) {
    char ch = 'A';
 
    printf("字符: %c\n", ch);   // 输出 A
    printf("编码值: %d\n", ch); // ASCII 兼容实现通常输出 65
    return 0;
}

有些字符没法直接敲出来——比如换行、制表、双引号本身。这时就需要用到 转义序列（escape sequence）：

转义序列在日常编程中频繁出现——printf("Hello\nWorld"); 会在 "Hello" 和 "World" 之间换行。printf("He said \"Hi\""); 才能在双引号里再放双引号。

常量——"不变的值"怎么写

程序中经常需要表达固定值。<Term def="在翻译或执行中表示固定值的语言实体，包括字面量、枚举常量和宏替换产生的常量表达式。const 声明的是不可通过该左值修改的对象，不等同于所有语境中的整数常量表达式。">常量（constant）</Term> 与只读对象要按具体语言规则区分：

#define 是 C 语言的传统做法——简单粗暴，但没有类型检查，容易出问题。const 是更现代、更安全的方式——编译器知道它的类型，能帮你检查错误。

#include <stdio.h>
#define PI 3.14159           // 宏常量：纯文本替换，没有类型
const int days = 7;          // 有类型的只读对象
 
int main(void) {
    // days = 8;            // 约束违反：不能通过 const 左值修改
 
    enum { SUN, MON, TUE, WED, THU, FRI, SAT };
    // SUN=0, MON=1, TUE=2, ..., SAT=6
 
    printf("圆周率: %f\n", PI);       // PI 被替换成 3.14159
    printf("一周有 %d 天\n", days);
    printf("周三的枚举值是 %d\n", WED);  // 输出 3
    return 0;
}

printf() 格式占位符——输出时告诉电脑"怎么看这段数据"

printf() 的格式占位符跟你选择的类型是一一绑定的——用错占位符，输出不是你想要的结果。下面是最常用的几种：

输出何时出现：缓冲与刷新

标准输出可能是无缓冲、行缓冲或全缓冲。交互终端上的 stdout 常见为行缓冲，写入换行时通常会提交当前行；重定向到文件后常变成全缓冲。标准并不保证每次 printf 都立即出现在屏幕上。

printf("enter value: ");
fflush(stdout);           /* 提示没有换行，读取输入前显式提交 */

fflush(stdout) 请求把待输出字符交给宿主环境。不要对输入流调用 fflush(stdin) 来“清空输入”，标准 C 对这种用法没有定义相应清理语义；输入验证应读取并丢弃到行尾。

动手：认识不同数据类型的"个头"差异

下面用一个 Stepper 分步演示 char / short / int / double 四种类型在内存中占用的空间，以及 sizeof 运算符如何帮你确认当前平台上每种类型真实的大小。

猜一猜：sizeof(int)、sizeof(double) 和 CHAR_BIT 在你的实现上分别是多少？先记录猜测，再让程序输出真实结果。

代码速查：类型声明与 printf 的写法

下面是在你需要时快速对照的 C 类型声明与输出代码：

#include <stdio.h>
int main(void) {
    // ===== 整型声明 =====
    short s = 32767;            // short 2 字节
    int i = 42;                 // 普通整数；大小查询当前实现
    long l = 123456789L;        // long，后缀 L
    unsigned int u = 4000000000U; // unsigned，后缀 U
 
    // ===== 浮点声明 =====
    float  f = 3.14f;           // float，必须后缀 f！
    double d = 3.14159265358979; // double（默认）
 
    // ===== 字符声明 =====
    char ch   = 'A';            // char
    char code = 65;             // 等价于 'A'
 
    // ===== printf 输出 =====
    printf("int:    %d\n", i);          // 42
    printf("float:  %f\n", f);          // 3.140000
    printf("double: %.15f\n", d);       // 请求小数点后 15 位，不等于都精确
    printf("char:   %c = %d\n", ch, ch);// A = 65
    return 0;
}

无后缀浮点字面量类型是 double，f 后缀产生 float 字面量。赋给 float 时允许转换，但可能发生舍入；需要让表达式按 float 运算时应明确使用 f 后缀。

容易踩的坑

小结

• C 语言要求每个变量在声明时必须指定类型——类型决定了内存大小、取值范围和 printf 的格式占位符
• 基本类型分三类：整型（short/int/long/long long + unsigned 修饰）、浮点型（float/double/long double）、字符型（char）
• 整型修饰符规定范围顺序但不固定字节数；需要协议宽度时使用实现提供的 stdint.h 类型
• printf 格式必须与提升后的实参类型匹配；启用格式警告可捕获很多字面量格式错误
• 用 sizeof、CHAR_BIT、limits.h 与 float.h 查询当前目标，不从平台名称猜类型模型

#include <float.h>
#include <limits.h>
#include <stdio.h>
int main(void) {
    float pi = 3.14159265358979;
    int total = pi;                  // ①
    unsigned int count = -1;         // ②
    printf("pi = %d\n", pi);         // ③
    printf("count = %d\n", count);   // ④
    printf("total = %f\n", total);   // ⑤
    return 0;
}

#include <stdio.h>
int main(void) {
    double pi = 3.14159265358979;        // 用 double 的完整精度
    int total = (int)pi;                 // 显式截断，你知道会丢小数
    int count = -1;                      // 负数不能用 unsigned
    printf("pi = %.10f\n", pi);          // %f 配对 double，%.10 显示 10 位
    printf("count = %d\n", count);       // %d 配对 int
    printf("total = %d\n", total);       // %d 配对 int
    return 0;
}

#include <stdio.h>
int main(void) {
    int a = 5, b = 2;
    float c = a / b;                    // ①
    float d = (float)a / b;             // ②
    int e = 2.9;                        // ③
    printf("c = %f\n", c);              // ④ 输出？
    printf("d = %f\n", d);              // ⑤ 输出？
    printf("e = %d\n", e);              // ⑥ 输出？
 
    unsigned int u = 0;
    u = u - 1;
    printf("u = %u\n", u);              // ⑦ 输出？
    return 0;
}

#include <stdio.h>
int main(void) {
    char   ch   = 'A';
    short  s    = 100;
    int    i    = 1000;
    long long ll = 1000000LL;
    float  f    = 3.14f;
    double d    = 3.14159265358979;
 
    printf("sizeof(char)      = %zu\n", sizeof(ch));
    printf("sizeof(short)     = %zu\n", sizeof(s));
    printf("sizeof(int)       = %zu\n", sizeof(i));
    printf("sizeof(long long) = %zu\n", sizeof(ll));
    printf("sizeof(float)     = %zu\n", sizeof(f));
    printf("sizeof(double)    = %zu\n", sizeof(d));
 
    printf("CHAR_BIT          = %d\n", CHAR_BIT);
    printf("int range         = %d..%d\n", INT_MIN, INT_MAX);
    printf("FLT_DIG / DBL_DIG = %d / %d\n", FLT_DIG, DBL_DIG);
 
    // 同一个 char，两种解读
    printf("\nchar as char: %c\n", ch);   // 输出 A
    printf("char code:    %d\n", ch);    // ASCII 兼容实现通常为 65
 
    return 0;
}