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

C 的数据类型分成内置类型和自定义类型两组:内置类型包括字符型、整型、浮点型、布尔型,自定义类型列出数组、结构体、枚举、联合体

内置类型清单

字符型: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 程序,在不同平台上可能给出不同的数。

课件这张宽度示意图把 long 画成 4 字节、long long 画成 8 字节,和 Windows 一致,但把 long double 画成了 16 字节;同一页正文给出的 VS2022 x64 输出里,long double 是 8

课件这一页的图和正文对不上。正文列出的 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 / _Bool1 / 11 / 1
short22
int44
long48
long long88
float / double4 / 84 / 8
long double816
指针88

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;
}

内存通常按三块理解:

内存分区:栈区放局部变量和函数参数,堆区用于 malloc、calloc、realloc、free 管理的动态内存,静态区放全局变量和静态变量

局部变量在栈上,函数返回时随之失效;全局变量和 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;
}

键盘输入 100 进入标准输入 stdin,scanf 从缓冲区取走并写入 score,printf 把结果送到标准输出 stdout 显示在屏幕上

一次读多个值,格式串里写几个占位符,后面就跟几个地址:

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。

输入 1 2 后连续按 Ctrl+Z 结束输入,scanf 只成功赋了两个变量,r 输出 2;f 保持初始值 0.000000

判断输入是否成功,看返回值比猜缓冲区里还剩什么可靠。scanf 失败时不会自动清掉读不动的字符,错误处理要自己写。