声明一个变量时,编译器记下的不只是名字,还有“从这块地址开始取几个字节、按什么规则解释”。int 和 float 都可能占 4 字节,但同一串二进制按前者读是整数,按后者读是浮点数。类型就是这套读法。

内置类型清单
字符型:char、signed char、unsigned char。
整型:short、int、long、long long,每一种都能加 signed 或 unsigned,方括号里的 int 可以省略,short int 和 short 是同一个类型。long long 是 C99 引入的。
浮点型:float、double、long double。
布尔型:C89 没有专门的布尔类型,用整数 0 表示假、非 0 表示真。C99 引入 _Bool,它只存 0 和 1,占 1 字节。写 true、false、bool 需要包含 <stdbool.h>,那里面把它们定义成宏;C23 起这三个名字才升为关键字。
课件在那段布尔示例里写了 _Bool flag = true;,却没有包含 <stdbool.h>。_Bool 本身是关键字,不需要头文件,但 true 不是,照抄会得到“未声明的标识符”。
课件那张分类图把数组放在“自定义类型”下面,这个归类不准确。数组由元素类型和元素个数组合而成,属于派生类型(derived type);平时说的自定义类型一般指结构体、联合、枚举和 typedef 出来的别名。
sizeof 量的是类型,表达式不参与求值
sizeof 是运算符,不是函数,结果是操作数类型占的字节数。两种写法都合法:
#include <stdio.h>
int main(void)
{
int a = 10;
printf("%zu\n", sizeof a); /* 变量可以省括号 */
printf("%zu\n", sizeof(int)); /* 类型必须带括号 */
printf("%zu\n", sizeof(3 + 3.5)); /* 结果类型是 double,输出 8 */
return 0;
}结果类型是 size_t,一个无符号整数类型,打印它用 %zu。课件从头到尾写 %zd,在多数实现上也能出数,但 z 配 d 要求的是“与 size_t 同宽的有符号类型”,参数实际是 size_t 时类型对不上,严格说有未定义行为的风险。
sizeof 只看表达式的类型,不求值:
short s = 2;
int b = 10;
printf("%zu\n", sizeof(s = b + 1)); /* 2:赋值表达式的类型是 short */
printf("s = %d\n", s); /* s 仍是 2,那次赋值没有发生 */赋值表达式的类型取左操作数的类型,所以这里是 short。编译器在编译期就把 sizeof 换成了常量,运行期没有“算一下”这一步。
这条规则有一个例外:变长数组(variable-length array,VLA)的长度要到运行时才知道,对它求 sizeof 会在运行期真正计算长度。普通数组和普通变量不受影响。
宽度没有统一答案
同一份 sizeof 程序,在不同平台上可能给出不同的数。

课件这一页的图和正文对不上。正文列出的 VS2022 x64 输出是 1 1 2 4 4 8 4 8 8,也就是 long 4 字节、long long 8 字节、long double 8 字节;示意图把 long double 画成了 16 字节。long 和 long long 两边一致,冲突只在 long double:16 字节是 64 位 Unix 上 80 位扩展精度的存法,Windows 的 long double 和 double 表示相同。
| 类型 | Windows x64(MSVC,LLP64) | Linux x86-64(GCC,LP64) |
|---|---|---|
char / _Bool | 1 / 1 | 1 / 1 |
short | 2 | 2 |
int | 4 | 4 |
long | 4 | 8 |
long long | 8 | 8 |
float / double | 4 / 8 | 4 / 8 |
long double | 8 | 16 |
| 指针 | 8 | 8 |
Windows 采用 LLP64:long 保持 4 字节,只有指针和 long long 是 64 位。Linux 和 macOS 采用 LP64:long 和指针一起变成 64 位。把 Linux 上按 64 位使用的 long 搬到 Windows,会静默截断。要 64 位整数,写 long long 或 int64_t。
long double 在 MSVC 上和 double 的表示完全一致,只是两个不同的类型名;GCC 在 x86-64 上用 80 位扩展精度存储、按 16 字节对齐。这个数不能跨平台假设。
char 默认有没有符号,标准交给实现决定:x86 上的 MSVC 和 GCC 默认有符号,某些 ARM 平台默认无符号。所以 char 不等于 signed char,需要明确符号时就写全。int 不一样,int 等同于 signed int。
取值范围不要手抄,用 <limits.h> 里的宏:SCHAR_MIN、SCHAR_MAX、SHRT_MIN、SHRT_MAX、INT_MIN、INT_MAX、LONG_MIN、LONG_MAX、LLONG_MIN、LLONG_MAX,无符号的上限是 UCHAR_MAX、USHRT_MAX、UINT_MAX、ULONG_MAX、ULLONG_MAX。浮点的范围在 <float.h> 里。
INT_MIN 在头文件里写成 (-2147483647 - 1),不直接写 -2147483648。原因是 2147483648 在词法上先是一个正数,已经超出 int 上限,编译器会先给它找别的类型,整个表达式就不再是 int。拆成减一,才能保证结果待在 int 里。
unsigned 改变的是最大整数,也改变了比较规则
signed 表示带正负号,unsigned 表示只有 0 和正整数。同样长度的内存,无符号能表示的最大值更大:16 位 short 的范围是 -32768 到 32767,unsigned short 是 0 到 65535。
真正容易出事的是混合比较:
#include <stdio.h>
int main(void)
{
int a = -1;
unsigned int b = 1;
printf("%d\n", a < b); /* 0,在 unsigned 的世界里 -1 比 1 大 */
printf("%u\n", (unsigned)a); /* 4294967295,-1 的补码被当成无符号 */
return 0;
}int 和 unsigned int 同宽,通常算术转换规定同宽时转成无符号的那个,于是 -1 的全 1 位模式被当成 4294967295 来比。规则可以概括成:有浮点就都转成浮点;char、short、_Bool 这类窄类型先提升成 int;同宽看符号,有符号的让位;不同宽,窄的转成宽的。
无符号变量倒着循环也是同一个根源:
unsigned int i = 5;
for (i = 5; i >= 0; --i) /* i 减到 0 后再减 1 变成 UINT_MAX,条件永远成立 */
{
printf("%u\n", i);
}工程上的办法是别让有符号和 unsigned 待在同一个表达式里;必须比,就先判负数。
变量是内存块、名字和类型
创建变量的语法是 类型 名字;:
int age; /* 整型变量 */
char ch; /* 字符变量 */
double weight; /* 浮点型变量 */创建时给初值叫初始化,创建之后再给值叫赋值:
int a = 100; /* 初始化 */
a = 200; /* 赋值 */大括号外定义的是全局变量,大括号内定义的是局部变量。同名时局部优先,全局变量被遮住:
#include <stdio.h>
int n = 1000;
int main(void)
{
int n = 10;
printf("%d\n", n); /* 10 */
return 0;
}内存通常按三块理解:

局部变量在栈上,函数返回时随之失效;全局变量和 static 变量在静态区,程序运行期间一直存在,没写初值也会被清零。堆区留给动态内存管理,malloc 系列函数从这里取空间。
栈上的局部变量不写初值,内容是不确定的。VS 的 Debug 配置会把未初始化的栈填成 0xCC,看到 -858993460 只是这个填充值的十进制形式,不是语言保证的初值。
五个算术运算符、赋值和自增
+、-、*、/、% 都是双目运算符,两边各有一个操作数。
加法和减法直接算。乘法用 *:
int num = 5;
printf("%d\n", num * num); /* 25 */除法的规则取决于两边的类型。两边都是整数时做整数除法,商向零截断,小数部分丢掉:
float x = 6 / 4; /* 先算 6/4 得 1,再转成 1.0 */
int y = 6 / 4; /* 1 */想要 1.5,至少一个操作数得是浮点数:6.0 / 4 或 6 / 4.0。这个规则在百分比上很常见:
int score = 5;
score = (score / 20) * 100; /* 5/20 是 0,结果 0 */
score = (score / 20.0) * 100; /* 25.0 转回 int 是 25 */% 求余,只能用于整数,浮点数不能用。余数的符号跟着第一个操作数走:
printf("%d\n", 11 % -5); /* 1 */
printf("%d\n", -11 % -5); /* -1 */
printf("%d\n", -11 % 5); /* -1 */-7 / 2 是 -3,C99 规定商向零截断,不是向下取整。要非负余数,得自己补一句 r < 0 ? r + b : r。
赋值用 =,可以连续赋值,从右往左结合:
int a = 3;
int b = 5;
int c = 0;
c = b = a + 3; /* 先 b = 6,再 c = 6 */拆开写更便于调试。复合赋值把“读出来、算、写回去”合成一步:
a += 3; /* a = a + 3 */
a -= 2;同类写法还有 *= /= %=,以及后面才会用的 >>= <<= &= |= ^=。
自增 ++ 和自减 -- 分前置和后置:
int a = 10;
int b = ++a; /* 先加 1,a 变 11,再把 11 给 b */
int c = a++; /* 先把 10 给 c,再让 a 变 11 */口诀是前置“先改后用”,后置“先用后改”。-- 同理。单目 + 不改变值,写了等于没写;单目 - 取相反数。
同一个变量在同一个表达式里被修改多次,例如 i = i++,属于未定义行为,任何结果都合法,不要写。
强制类型转换写作 (类型)表达式:
int a = 3.14; /* MSVC 会给 C4244“可能丢失数据”的警告 */
int b = (int)3.14; /* 明确转换,取整数部分,得到 3 */转换只改变这一次的读法,不改变变量本身的类型。能不用就不用,非用不可时要清楚截断发生在哪一步。
printf 的格式串和参数必须对得上
printf 的名字里 f 是 format,格式串里的占位符决定后面参数怎样被读出来。占位符按类型分组:
| 类别 | 常用写法 |
|---|---|
| 有符号整数 | %d、%i(十进制) |
| 无符号整数 | %u、%o(八进制)、%x / %X(十六进制) |
| 浮点 | %f、%e / %E(科学计数)、%g / %G、%a / %A(十六进制浮点) |
| 字符与字符串 | %c、%s |
| 指针与特殊 | %p(地址)、%n(写入已输出字符数)、%%(一个百分号)、%zu(size_t) |
长度修饰符放在字母前:h 对应 short,l 对应 long,ll 对应 long long,L 对应 long double。所以有 %hd、%ho、%hx、%hu、%ld、%lo、%lx、%lu、%lld、%llo、%llx、%llu、%Lf、%Le。%i 在 printf 里和 %d 一样;在 scanf 里它会根据前缀识别十进制、八进制或十六进制。%g 默认按 6 个有效数字输出,整数部分超过 6 位时自动转成科学计数法。
格式串还能限定宽度、对齐和小数位:
printf("%5d\n", 123); /* " 123",不足 5 位左补空格 */
printf("%-5d\n", 123); /* "123 ",左对齐 */
printf("%12f\n", 123.45); /* 总宽至少 12,默认小数点后 6 位 */
printf("%+d\n", 12); /* "+12",正数也带符号 */
printf("%.2f\n", 0.5); /* "0.50" */
printf("%6.2f\n", 0.5); /* " 0.50" */
printf("%*.*f\n", 6, 2, 0.5); /* 宽度和精度由参数传入 */
printf("%.5s\n", "hello world"); /* 只输出前 5 个字符 */占位符和参数一一对应。占位符比参数多时,printf 会去读一个不存在的参数,标准层面是未定义行为,不是“随便打印点内存”。
%f 和 %lf 在 printf 里都表示 double。float 作为可变参数传进去会先提升成 double,所以 printf("%f", 0.1f) 正确。scanf 没有这个提升,%f 收 float *,%lf 收 double *,写反了就是往 4 字节的空间里写 8 字节。
scanf 按格式从缓冲区取数
scanf 从标准输入读数据,原型在 <stdio.h>。它要的是地址,不是值,所以普通变量前面必须加 &:
#include <stdio.h>
int main(void)
{
int score = 0;
printf("请输入成绩:");
scanf("%d", &score);
printf("成绩是:%d\n", score);
return 0;
}
一次读多个值,格式串里写几个占位符,后面就跟几个地址:
int i = 0, j = 0;
float x = 0.0f, y = 0.0f;
scanf("%d%d%f%f", &i, &j, &x, &y);数值占位符会自动跳过起首的空格、制表符和换行,所以输入可以分成多行。输入先进入缓冲区,按回车后 scanf 才开始按占位符解读;这次停在哪里,下次就从那里接着读。
int x = 0;
float y = 0.0f;
/* 输入 " -13.45e12# 0" */
scanf("%d", &x); /* 读到 -13,停在 '.' */
scanf("%f", &y); /* 从 '.' 开始读到 .45e12,停在 '#' */scanf 的占位符和 printf 基本一致,区别在浮点:%f 是 float,%lf 是 double,%Lf 是 long double。%c 读一个字符,%s 读字符串,%[] 在方括号里指定可接受的字符集合,例如 %[0-9] 只收数字,遇到集合外的字符就停。
空白处理有一条课件说窄了。课件写“除了 %c 以外,所有占位符都会忽略起首空白”,实际 %[ 也不跳过。准确的说法是 %c、%[、%n 不跳过空白,其余转换说明符会跳过。
%c 想跳过前面的空白,就写成 scanf(" %c", &ch),%c 前面那个空格表示“跳过零个或多个空白”。先读整数再读字符时,上一次留下的回车会被 %c 当字符读走,原因就在这里。
%s 从第一个非空白字符开始读,读到空白为止,所以读不了带空格的字符串,而且不检查数组长度。读进字符数组时要限长:
char name[11];
scanf("%10s", name); /* 最多读 10 个字符,第 11 个位置留给 '\0' */分隔符不固定时用赋值忽略符 *:
int year = 0, month = 0, day = 0;
scanf("%d%*c%d%*c%d", &year, &month, &day); /* 2020-01-01 和 2020/01/01 都能过 */%*c 读走一个字符但不赋值,也不计入返回值。
返回值是成功赋值的个数:
int a = 0, b = 0;
float f = 0.0f;
int r = scanf("%d %d %f", &a, &b, &f);
printf("a=%d b=%d f=%f\n", a, b, f);
printf("r = %d\n", r);三项都读到时 r 是 3;只输入两个整数就结束输入,r 是 2;一个都没读到就遇到输入结束,返回 EOF,也就是 -1。

判断输入是否成功,看返回值比猜缓冲区里还剩什么可靠。scanf 失败时不会自动清掉读不动的字符,错误处理要自己写。
还没有评论 — 第一条由你来留。