C 语言从入门到实战:写给初学者的系统教程

本教程面向初学者,系统讲解C语言核心知识体系,涵盖数据类型、控制结构、数组、指针、函数、结构体、动态内存管理、文件操作及预处理等关键主题。强调三大主线:数据在内存中的存储方式、程序编译链接过程、指针对内存与代码的连接机制。内容按概念→示例→图解→练习展开,并以停车场管理系统为综合项目,整合各章知识点实现完整工程实践。

引言

这是一本写给初学者的 C 语言教程。它把 C 语言的学习拆成十个章节,从最基础的语法元素一路走到指针、内存管理、文件操作与预处理。它既适合作为课程讲义,也适合作为自学路线图。

学习 C 语言的关键不在于记住多少语法,而在于理解三件事:数据在内存中如何存放、程序如何被编译链接成可执行文件、指针如何把内存与代码连接起来。抓住这三条主线,后面所有章节都会变得顺理成章。

每一章大致按「概念 → 示例 → 图解 → 练习」的顺序展开:先讲清楚知识点是什么、解决什么问题,再给出可以直接编译运行的代码并逐行解释,然后用内存图、流程图把抽象过程可视化,最后用改错题、思考题和动手作业检验是否真正掌握。

阅读前建议准备好一台能安装编译器的电脑(Windows 可用 MinGW / MSVC,Linux / macOS 自带 GCC 或 Clang)、一个顺手的编辑器或 IDE(VS Code、CLion、Dev-C++ 都可以),以及一个记录问题的笔记本:遇到不懂的地方先记下来,读到后面往往自然就通了。

主线关注的问题对应章节
数据在内存中如何存放类型、变量、数组、结构体、对齐第一、三、七章
程序如何被编译链接预处理、编译、汇编、链接、多文件第一、二、六、十章
指针如何连接内存与代码地址、解引用、指针运算、函数指针第四、五、八章

把这三条主线贯穿起来读,你会发现后面看似零散的知识点,其实都在回答同一个问题:这段代码在内存里到底发生了什么。

第一章:C 语言概述

1.1 什么是 C 语言

C 语言诞生于 1972 年,由贝尔实验室的 Dennis Ritchie 在 B 语言的基础上发展而来,最初用于编写 UNIX 操作系统。它是一门面向过程的通用编程语言,兼具高级语言的抽象能力和汇编语言贴近硬件的效率,因此常被称为“系统级语言”。

C 语言的核心特点可以概括为以下几点:

  • 简洁紧凑:关键字只有 32 个(C89),语法规则少,学习曲线相对平缓。
  • 贴近硬件:支持位运算、指针和直接内存访问,适合编写操作系统、驱动和嵌入式程序。
  • 可移植性强:只要目标平台提供符合标准的编译器,同一份源码就能重新编译运行。
  • 效率高:编译后生成的机器码质量接近汇编,运行开销小。
  • 结构化:以函数为基本单位,支持模块化设计。
第一个 C 语言程序
#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");
    return 0;
}

这段代码包含 C 程序的几个基本要素。

  1. #include <stdio.h>:预处理指令,把标准输入输出头文件包含进来,这样才能使用 printf。
  2. int main(void):主函数,程序执行的入口。int 表示返回整型,void 表示不接收参数。
  3. printf(...):库函数调用,向标准输出打印字符串。
  4. return 0;:向操作系统返回 0,表示程序正常结束。

编译与运行(以 GCC 为例):

gcc hello.c -o hello
./hello

输出结果为:

Hello, World!
C 语言程序的结构特点
  • 预处理指令:以 # 开头,在编译前由预处理器处理,如 #include、#define。
  • 函数:C 程序由一个或多个函数组成,有且仅有一个 main 函数作为入口。
  • 语句:以分号 ; 结尾,是程序执行的基本单位。
  • 注释:/* ... */ 为块注释,// ... 为行注释(C99 起支持)。
  • 大小写敏感:Main 与 main 是两个不同的标识符。

1.2 数据类型

C 语言是强类型语言,每个变量都必须有明确的类型,类型决定了变量占用的内存大小、取值范围以及可参与的运算。

基本数据类型
类型典型字节数典型取值范围说明
char1-128 ~ 127(有符号)字符或小整数
short2-32768 ~ 32767短整型
int4-2147483648 ~ 2147483647最常用的整型
long4 / 8依平台而定长整型
long long8-2^63 ~ 2^63-1C99 引入的 64 位整型
float4约 ±3.4e38,6~7 位有效数字单精度浮点
double8约 ±1.8e308,15~16 位有效数字双精度浮点

注意:上表是常见平台的典型值,标准只规定了最小范围,具体字节数可用 sizeof 查看。

类型与内存占用、取值范围的关系

类型占用的字节数决定了它能表示的范围。例如,1 字节的 char 有 8 位,能表示 2^8 = 256 种状态;若为有符号类型,则一半表示负数,一半表示非负数。

#include <stdio.h>

int main(void)
{
    printf("char   : %zu 字节\n", sizeof(char));
    printf("int    : %zu 字节\n", sizeof(int));
    printf("double : %zu 字节\n", sizeof(double));
    return 0;
}
有符号与无符号类型

在类型前加 unsigned 表示无符号,取值范围从 0 开始,正数上限约翻倍:

unsigned char uc = 255;   /* 0 ~ 255 */
signed char   sc = -1;    /* -128 ~ 127 */

无符号类型在计数、位运算、哈希等场景中很常用,但要注意它与有符号类型混合运算时的隐式转换规则。

1.3 标识符、变量与常量

标识符的命名规则

标识符是用来命名变量、函数、类型等的名称,必须满足:

  • 只能由字母、数字和下划线组成,且不能以数字开头;
  • 区分大小写;
  • 不能使用 C 语言的关键字(如 int、return);
  • 不能与标准库中已定义的名称冲突。

风格约定上,常见有下划线风格 student_age 和驼峰风格 studentAge,团队内保持一致即可。

变量的本质

变量是一块有名字的内存。定义变量时,编译器为它分配一块内存,名字就是访问这块内存的入口。

int a = 10;   /* 分配 4 字节,存入 10 */
声明与定义的区别
  • 定义:为变量分配内存,如 int a = 10;。
  • 声明:告诉编译器“这个名字存在”,不分配内存,如 extern int a;。

一个变量可以声明多次,但只能定义一次。

变量的作用域(可见性)
  • 局部变量:定义在函数或代码块内,只在块内可见。
  • 全局变量:定义在所有函数之外,从定义处到本文件末尾可见。
#include <stdio.h>

int g = 100;          /* 全局变量 */

int main(void)
{
    int a = 10;       /* 局部变量 */
    {
        int b = 20;   /* 块内局部变量 */
        printf("%d %d %d\n", g, a, b);
    }
    /* printf("%d\n", b); 错误:b 已超出作用域 */
    return 0;
}
示例:计算三角形的面积
#include <stdio.h>
#include <math.h>

int main(void)
{
    double a, b, c, p, area;
    printf("请输入三角形三边长:");
    scanf("%lf %lf %lf", &a, &b, &c);

    p = (a + b + c) / 2.0;              /* 半周长 */
    area = sqrt(p * (p - a) * (p - b) * (p - c));  /* 海伦公式 */

    printf("面积 = %.2f\n", area);
    return 0;
}

编译提示:本示例用到 <math.h> 中的 sqrt,用 GCC 编译时需要在命令末尾加 -lm 链接数学库,否则会报 undefined reference to 'sqrt' 错误:

gcc triangle.c -o triangle -lm
./triangle

在 Linux/macOS 上这一步尤其必要;部分 Windows 的 MinGW 环境会自动链接,但显式加上 -lm 更稳妥。

printf 与 scanf 函数详解

printf 函数用于格式化输出,原型为 int printf(const char *format, ...);。常用格式符如下:

格式符含义
%d十进制整数
%f浮点型(默认 6 位小数)
%.2f保留 2 位小数
%c单个字符
%s字符串
%p指针地址
%zusizeof 的返回值

scanf 函数用于格式化输入,原型为 int scanf(const char *format, ...);。注意传入的是变量的地址:

int n;
scanf("%d", &n);   /* 必须加 & */

scanf 返回成功读入的项数,可用于判断输入是否合法。

常量

常量是程序运行期间值不可改变的量,常见的有四类:

  1. 字面常量:直接写出的值,如 10、3.14、'A'、"hello"。
  2. 宏常量:用 #define 定义,如 #define PI 3.14159。
  3. 常变量:用 const 修饰,如 const int MAX = 100;。
  4. 枚举常量:用 enum 定义,如 enum Color { RED, GREEN, BLUE };。
#define PI 3.14159
const int MAX = 100;
enum Color { RED, GREEN, BLUE };
整型常量、字符常量与字符串常量
  • 整型常量:可用十进制 10、八进制 012、十六进制 0xA 表示,后缀 U、L 分别表示无符号和长整型。
  • 字符常量:用单引号括起单个字符,如 'A',本质是一个整型值(ASCII 码)。
  • 字符串常量:用双引号括起,如 "hello",本质是字符数组,以 '\0' 结尾。

1.4 转义字符

转义字符以反斜杠 \ 开头,用来表示一些无法直接输入或具有特殊含义的字符。

转义字符含义ASCII 值
\n换行10
\t水平制表符9
\\反斜杠本身92
\'单引号39
\"双引号34
\0空字符(字符串结束标志)0
\a响铃7
\b退格8
\r回车13
\x41十六进制表示的字符(此处为 ‘A’)65
\101八进制表示的字符(此处为 ‘A’)65
示例 1:换行与制表符
#include <stdio.h>

int main(void)
{
    printf("姓名\t年龄\t成绩\n");
    printf("张三\t18\t95\n");
    printf("李四\t19\t88\n");
    return 0;
}
示例 2:输出引号与反斜杠
#include <stdio.h>

int main(void)
{
    printf("他说:\"C 语言很有趣\"\n");
    printf("路径:C:\\Users\\test\n");
    return 0;
}
示例 3:空字符与字符串结束
#include <stdio.h>

int main(void)
{
    char s[] = "abc";
    printf("字符串长度:%zu\n", sizeof(s));  /* 4,包含结尾的 '\0' */
    return 0;
}
示例 4:十六进制与八进制转义
#include <stdio.h>

int main(void)
{
    printf("%c %c\n", '\x41', '\101');  /* 都输出 A */
    return 0;
}
示例 5:回车与退格的视觉效果
#include <stdio.h>

int main(void)
{
    printf("12345\rABC\n");   /* \r 回到行首,ABC 覆盖 123 */
    printf("abc\bX\n");       /* \b 退一格,X 覆盖 c */
    return 0;
}

1.5 顺序语句、选择语句与循环语句

C 语言有三种基本控制结构:顺序、选择、循环。任何复杂程序都可以由这三种结构组合而成。

顺序结构

程序默认从上到下逐条执行语句,这就是顺序结构。

int a = 3, b = 4;
int sum = a + b;   /* 先算 a+b,再赋值给 sum */
选择语句

if 语句根据条件决定是否执行某段代码:

if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

switch 语句适合多分支等值判断:

switch (grade) {
case 'A': printf("优秀\n"); break;
case 'B': printf("良好\n"); break;
default:  printf("其他\n"); break;
}
循环语句

C 语言提供三种循环:

  • while:先判断条件,再执行循环体。
  • do-while:先执行一次循环体,再判断条件。
  • for:适合已知循环次数的场景。
示例:求 1 到 100 的和
#include <stdio.h>

int main(void)
{
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    printf("1 + 2 + ... + 100 = %d\n", sum);
    return 0;
}
示例:使用 while 循环语句
#include <stdio.h>

int main(void)
{
    int i = 1, sum = 0;
    while (i <= 100) {
        sum += i;
        i++;
    }
    printf("sum = %d\n", sum);
    return 0;
}
示例:统计从键盘输入的一行字符的个数
#include <stdio.h>

int main(void)
{
    int count = 0;
    char ch;

    printf("请输入一行字符:");
    while ((ch = getchar()) != '\n') {
        count++;
    }
    printf("字符个数:%d\n", count);
    return 0;
}
无限循环的常见写法与风险
while (1) { /* ... */ }        /* 常见写法 */
for (;;)  { /* ... */ }        /* 等价写法 */

无限循环本身不是错误,但必须保证循环体内有 break 或 return 等退出机制,否则程序会卡死。

1.6 数组与函数

本节把两个最基础也最重要的概念放在一起讲:数组用来把一批同类型的数据连续地存放在内存里,函数用来把重复的逻辑封装成可复用的代码块。我们会先看清数组在内存中的连续布局,再动手把前面「计算三角形面积」的代码改造成函数封装,体会「一次编写、多次调用」带来的好处,为后面第三章的数组和第六章的函数打下基础。

数组:同类型元素的连续存储

数组是一组类型相同、地址连续的变量集合,通过下标访问。例如 int a[5]; 就在内存中连续分配了 5 个 int,共 20 字节,a[0] 到 a[4] 依次排列,下标从 0 开始。

#include <stdio.h>

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};   /* 定义并初始化 5 个元素 */
    for (int i = 0; i < 5; i++) {
        printf("a[%d] = %d\n", i, a[i]);  /* 通过下标逐个访问 */
    }
    return 0;
}
函数:把重复逻辑封装起来

函数把一段逻辑打包,给它起个名字,需要时调用即可。函数由返回类型、函数名、参数列表、函数体四部分组成:

返回类型 函数名(参数列表)
{
    函数体;
    return 返回值;   /* 若返回类型为 void 可省略 */
}
示例:把求面积的代码改为函数封装

前面 1.3 节里,求三角形面积的逻辑直接写在 main 函数中。如果程序里要多次求面积,重复代码会很难维护。下面把它抽成一个独立函数 triangle_area,由 main 函数负责输入输出,职责更清晰:

#include <stdio.h>
#include <math.h>

/* 计算三角形面积:传入三边长,返回面积;边长非法时返回 -1 */
double triangle_area(double a, double b, double c)
{
    double p = (a + b + c) / 2.0;                 /* 先求半周长 p */
    if (a + b <= c || a + c <= b || b + c <= a) { /* 任意两边之和须大于第三边 */
        return -1.0;                              /* 不构成三角形,返回 -1 表示错误 */
    }
    return sqrt(p * (p - a) * (p - b) * (p - c)); /* 海伦公式求面积并返回 */
}

int main(void)
{
    double a, b, c, area;

    printf("请输入三角形三边长:");
    if (scanf("%lf %lf %lf", &a, &b, &c) != 3) {  /* 检查是否成功读入 3 个数 */
        printf("输入格式错误\n");
        return 1;                                 /* 非 0 表示异常退出 */
    }

    area = triangle_area(a, b, c);                /* 调用函数,逻辑与输入输出分离 */
    if (area < 0) {
        printf("这三条边不能构成三角形\n");
    } else {
        printf("面积 = %.2f\n", area);            /* 保留两位小数输出 */
    }
    return 0;                                     /* 正常结束 */
}

这段代码体现了函数封装的两个好处:一是逻辑复用,任何地方都能再调用 triangle_area;二是职责分离,main 函数只管输入输出,计算交给函数,代码更易读、易改、易测。

1.7 编译与链接

本节回答一个常被忽略却极其关键的问题:你写的 .c 文件,是怎样一步步变成能直接运行的可执行程序的? 我们会认识源文件、头文件、目标文件和可执行文件这几种「文件形态」,走一遍「预处理 → 编译 → 汇编 → 链接」的完整流程,并顺带说清「可见性(作用域)」和「生存期」这两个贯穿全书的底层概念,为后面第六章的函数调用机制做铺垫。

四种「文件形态」
文件扩展名内容由谁产生
源文件.c你写的 C 代码手写
头文件.h函数原型、宏、类型声明手写
目标文件.o / .obj汇编后的机器码+符号表编译器
可执行文件.exe / 无后缀链接后的完整程序链接器
四个阶段各做什么
  1. 预处理:处理 #include、#define、条件编译,展开宏、删除注释,产出 .i 文件。这一步只做文本替换,不检查语法错误。
  2. 编译:把预处理后的代码翻译成汇编语言,同时做语法检查、类型检查与优化,产出 .s 文件。
  3. 汇编:把汇编代码翻译成机器指令,产出目标文件 .o,其中还留有未解析的外部符号(如 printf)。
  4. 链接:把多个目标文件与库文件合并,解析符号引用,确定各段最终地址,产出可执行文件。
# 以 GCC 为例,分步观察每个阶段的产物
gcc -E hello.c -o hello.i    # 预处理
gcc -S hello.i -o hello.s    # 编译
gcc -c hello.s -o hello.o    # 汇编
gcc hello.o -o hello         # 链接
常见链接错误
  • undefined reference to 'xxx':函数只声明未定义,或定义所在的目标文件没参与链接。
  • multiple definition of 'xxx':同一个符号在多个文件中被定义(全局变量最容易踩坑)。
  • 头文件里只放声明,定义放到 .c 文件,是避免重复定义的基本纪律。
可见性与生存期
  • 可见性(作用域):名字在源码的哪些位置能被使用,是编译期概念。
  • 生存期:变量在运行时实际存在多久,是运行期概念。

两者并不总是一致:static 局部变量作用域仍在块内,但生存期延长到整个程序运行期间。理解这一区别,后面讲栈帧、static、extern 时就不会混淆。

1.8 运算符

本节系统梳理 C 语言的运算符。先讲清「操作数、优先级、结合性」这几个术语,让你能读懂表达式是怎么被求值的;再用一组小而精的示例,分别演示 % 取模、*= 复合赋值、三目运算符,以及最容易踩坑的前置 ++ 与后置 ++ 的区别。掌握这些细节,才能写出既正确又不易出错的表达式。

三个基本术语
  • 操作数:运算符作用的对象,如 a + b 中的 a、b。
  • 优先级:不同运算符混用时谁先算,如 a + b * c 先算 *。
  • 结合性:同优先级运算符的运算方向,如 a - b - c 从左到右,a = b = c 从右到左。
运算符分类速览
类别运算符结合性
算术+ - * / %左结合
关系> < >= <= == !=左结合
逻辑&&、`
位运算&、`、^`、`~`、`<<`、`>>`
赋值= += -= *= /= %=右结合
自增自减++ --前缀右结合、后缀左结合
三目? :右结合
取模 %

% 只能用于整型,结果是余数,符号与被除数一致:

printf("%d\n", 7 % 3);    /* 1 */
printf("%d\n", -7 % 3);   /* -1,不是 2 */

关于负数取模与数学「求余」的差异,详见 1.11 附录 · 取模与求余的区别。

复合赋值 *=

a *= b 等价于 a = a * (b),且左操作数只求值一次,比 a = a * b 更高效也更安全:

int a = 5;
a *= 2 + 3;   /* 等价于 a = a * (2 + 3),结果 25 */
三目运算符

条件 ? 值1 : 值2,条件为真取值 1,否则取值 2。适合简单的二选一赋值,嵌套过多会降低可读性。

int max = (a > b) ? a : b;
前置 ++ 与后置 ++
  • ++i:先自增,再返回自增后的值。
  • i++:先返回原值,再自增。
int i = 1;
int a = ++i;   /* i 变 2,a 得 2 */
int b = i++;   /* b 得 2,i 变 3 */

单独成句时 ++i 与 i++ 效果相同;一旦参与表达式,结果可能不同。更要注意 i++ + i++ 这类同一表达式内多次修改同一变量,属于未定义行为,不同编译器结果可能不一致,务必避免。

1.9 指针、结构体与文件

本节是第一章的「预告片」,把 C 语言里三个分量最重的主题先亮个相:指针揭示变量在内存中的地址与存储结构,结构体把相关数据打包成一个整体,文件则让程序的数据能持久保存到磁盘。这里只讲它们「是什么、解决什么问题」,具体细节会在第四、七、九章分别深入展开,先建立整体印象即可。

  • 指针:存放地址的变量。它让函数能修改外部数据、让数组能高效遍历,也是动态内存管理的入口。第四章专门讲。
  • 结构体:把不同类型的数据打包成一个整体,如学生包含姓名、年龄、成绩。它是自定义类型的基础,第七章专门讲。
  • 文件:让数据在程序结束后依然存在。C 语言用 FILE * 把文件抽象成流,第九章专门讲。

三者常常配合出现:结构体里放指针成员实现变长数据,指针指向动态分配的结构体数组,再把整个结构体写入文件做持久化。先记住这个组合,后面读到相关章节时会更顺畅。

三者如何配合:一个最小示例

下面的例子把三个主题串在一起:用结构体描述一条学生记录,用指针在函数中修改它,再把记录写入文件并读回。代码刻意保持精简,只演示「配合方式」,不展开细节。

#include <stdio.h>
#include <string.h>

/* 1. 结构体:把一条学生记录打包成一个整体 */
struct Student {
    char name[20];
    int  age;
    double score;
};

/* 2. 指针:通过指针修改调用方的结构体,避免整体拷贝 */
void birthday(struct Student *p)
{
    p->age += 1;              /* 用 -> 通过指针访问成员 */
}

int main(void)
{
    struct Student s = {"张三", 18, 95.5};

    birthday(&s);             /* 传入地址,函数内修改生效 */
    printf("修改后:%s %d %.1f\n", s.name, s.age, s.score);

    /* 3. 文件:把结构体按字节原样写入磁盘,再读回 */
    FILE *fp = fopen("student.bin", "wb");
    if (fp == NULL) {
        return 1;
    }
    fwrite(&s, sizeof(s), 1, fp);   /* 一次写入整个结构体 */
    fclose(fp);

    struct Student t;
    fp = fopen("student.bin", "rb");
    if (fp == NULL) {
        return 1;
    }
    fread(&t, sizeof(t), 1, fp);    /* 一次读回整个结构体 */
    fclose(fp);

    printf("读回:%s %d %.1f\n", t.name, t.age, t.score);
    return 0;
}

这段代码里三者的分工一目了然:结构体负责「数据长什么样」,指针负责「怎样高效地传递和修改数据」,文件负责「数据怎样活过程序的生命周期」。后续章节会分别把每一环讲透,这里只需记住这条链路:结构体 → 指针 → 文件。

结构体 Student
打包数据

指针 struct Student *
高效传递与修改

文件 FILE *
持久化到磁盘

读回内存
还原为结构体

1.10 关键字总览

C 语言的关键字是编译器「预留」的单词,它们有固定含义,不能拿来当变量名或函数名。C89 一共 32 个关键字,C99 又新增了 5 个。把它们按用途分类记忆,比死记硬背有效得多。

数据类型关键字

char、int、short、long、float、double、signed、unsigned、void、_Bool(C99)、_Complex、_Imaginary。它们负责声明变量和函数的类型,决定了内存占用与取值范围。

流程控制关键字

if、else、switch、case、default、for、while、do、break、continue、goto、return。它们控制程序的执行路径,是第二章的重点。

存储类与限定符关键字

auto、static、extern、register、const、volatile、typedef、sizeof。它们描述变量的存储位置、生命周期和只读属性。

#include <stdio.h>

typedef unsigned int uint;   /* typedef 给类型起别名 */

static int counter = 0;      /* static 修饰的全局变量只在本文档可见 */

int main(void)
{
    const int MAX = 10;      /* const 修饰的变量不可修改 */
    register int i;          /* register 建议编译器把变量放进寄存器 */

    for (i = 0; i < MAX; i++) {
        counter += i;
    }
    printf("counter = %d, sizeof(uint) = %zu\n", counter, sizeof(uint));
    return 0;
}
const 与 #define 的区别
对比项const 常变量#define 宏常量
处理阶段编译期,参与类型检查预处理期,纯文本替换
是否有类型有,受类型规则约束无,只是字符序列
能否取地址可以不可以
调试信息有无

因此,能用 const 的地方优先用 const,宏常量更适合表示与类型无关的配置值。

1.11 附录

附录集中收录第一章反复用到、但展开讲会打断主线的背景知识,建议遇到相关问题时回来查阅。

计算机硬件基本组成与模拟程序运行

一台计算机的核心部件包括 CPU(运算器与控制器)、内存、硬盘 和 输入输出设备。程序运行时,代码和数据先从硬盘加载到内存,CPU 再从内存中逐条取指令、译码、执行。理解这条「硬盘 → 内存 → CPU」的路径,就能明白为什么变量有地址、为什么指针有意义。

软件与文件的概念

软件分为系统软件(操作系统、编译器)和应用软件。文件是存储在磁盘上的数据集合,C 语言通过标准 I/O 库把文件抽象成「流」,第九章会详细展开。

进制及进制转换

计算机内部使用二进制,而书写时常用八进制和十六进制简化表示。二进制转十进制按权展开求和,十进制转二进制用「除 2 取余、逆序排列」:

十进制 13 → 13/2=6 余 1
            6/2=3  余 0
            3/2=1  余 1
            1/2=0  余 1
逆序读取:1101(二进制)
ASCII 编码表

ASCII 用 7 位二进制表示 128 个字符。需要记住几个关键区间:'0'~'9' 是 4857,`‘A’`'Z' 是 6590,`‘a’`'z' 是 97~122。大小写字母相差 32,这个规律常用于字符大小写转换。

取模与求余的区别

在 C 语言中,% 对负数取模的结果符号与被除数一致:-7 % 3 得 -1,而数学上的「求余」通常得正数 2。写涉及负数的取模逻辑时要特别小心。

三角形面积公式

已知三边 a、b、c,半周长 p = (a + b + c) / 2,面积由海伦公式给出:

area = sqrt(p * (p - a) * (p - b) * (p - c))

使用前必须保证任意两边之和大于第三边,否则根号内会出现负数。

1.12 本章小结与练习

本章从「C 语言是什么」出发,依次走过了数据类型、标识符与变量、常量、转义字符、三种基本控制结构、数组与函数、编译链接、运算符、关键字,最后用附录补齐了硬件、进制、ASCII 等背景知识。回顾时建议抓住三条线索:类型决定内存布局、控制结构决定执行路径、编译链接决定代码如何变成程序。

思考题

  1. int 与 unsigned int 在内存中占用的字节数相同,为什么取值范围不同?
  2. 为什么说「变量是一块有名字的内存」?extern int a; 与 int a; 在内存分配上有什么区别?
  3. 前置 ++ 与后置 ++ 单独成句时结果相同,为什么参与表达式后可能不同?
  4. 预处理、编译、汇编、链接四个阶段,各自能发现哪一类错误?

改错题

/* 错误 1:scanf 漏写取地址符 */
int n;
scanf("%d", n);          /* 应改为 scanf("%d", &n); */

/* 错误 2:宏参数未加括号 */
#define SQUARE(x) x * x
int r = SQUARE(2 + 3);   /* 展开为 2 + 3 * 2 + 3,结果 11 而非 25 */

/* 错误 3:数组下标越界 */
int a[5];
a[5] = 1;                /* 合法下标是 0 ~ 4 */

动手作业

  1. 编写程序,输入三个整数,输出其中的最大值与最小值(分别用 if-else 和三目运算符各实现一次)。
  2. 把 2.3 节的三角形面积程序改造成函数封装版本,并加入「三边能否构成三角形」的判断。
  3. 用 sizeof 打印本章出现的所有基本类型在本机上的字节数,并与表格中的典型值对照。
  4. 用 GCC 的 -E、-S、-c 分步编译一个 hello.c,观察每个阶段生成的中间文件。

补充说明:本章 2.3 的三角形面积示例用到 <math.h>,GCC 下需加 -lm;2.8 的取模细节、2.11 的进制转换与 ASCII 表,遇到疑问时可回查对应小节与附录。

第二章:分支语句、循环语句与函数初步

本章把「让程序会做判断、会重复劳动、会拆分模块」这三件事讲清楚:先用 bool 类型和关系、逻辑表达式打好判断的基础,再依次介绍 if、switch 两种分支语句,接着讲 while、do-while、for 三种循环,最后落到函数初步与多文件结构。学完本章,你写的程序就不再是「一条直线跑到底」,而是能根据输入走不同路径、能重复处理一批数据、能把逻辑拆成可复用的模块。

2.1 bool 类型与关系、逻辑表达式

bool 类型与 <stdbool.h>:C89 没有布尔类型,判断真假一律用整数——0 为假,非 0 为真。C99 在 <stdbool.h> 中引入了 bool、true、false,本质仍是整数 _Bool,只是让语义更清晰:

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    bool ok = true;          /* true 等价于 1,false 等价于 0 */
    printf("%d %zu\n", ok, sizeof(bool));   /* 输出 1 1 */
    return 0;
}

关系运算符:>、<、>=、<=、==、!= 用于比较两个值,结果是 0 或 1。最常见的坑是把赋值 = 误写成相等 ==:

int a = 3;
if (a = 5) {          /* 错误:这是赋值,表达式值为 5,恒为真 */
    printf("永远会执行\n");
}
if (a == 5) {         /* 正确:比较是否相等 */
    printf("a 等于 5\n");
}

逻辑运算符:&&(与)、||(或)、!(非)。它们有两个重要特性:

  • 短路求值:a && b 中若 a 为假,b 不再求值;a || b 中若 a 为真,b 不再求值。因此 if (p != NULL && p->x > 0) 是安全的写法。
  • 结果归一化:逻辑运算的结果只会是 0 或 1,不会保留操作数的原值。
int x = 5;
if (x > 0 && x < 10) {       /* 区间判断必须写成两个比较再用 && 连接 */
    printf("x 在 0 到 10 之间\n");
}

注意:0 < x < 10 这种写法在 C 里是错的,它先算 0 < x 得到 0 或 1,再拿这个结果和 10 比较,几乎恒为真。

运算符优先级:关系运算符高于 && 和 ||,! 最高。拿不准时一律加括号,可读性也更好。

2.2 分支语句

if 语句的三种形式:

/* 形式一:单分支 */
if (score >= 60) {
    printf("及格\n");
}

/* 形式二:双分支 */
if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

/* 形式三:多分支 */
if (score >= 90) {
    printf("优秀\n");
} else if (score >= 75) {
    printf("良好\n");
} else if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

else 的就近匹配(悬挂 else):else 总是与它前面最近的、尚未配对的 if 结合。缩进好看不代表逻辑正确:

if (a > 0)
    if (b > 0)
        printf("都为正\n");
else                     /* 这个 else 属于内层 if,而不是外层 */
    printf("b 不为正\n");

要让它属于外层 if,必须给内层 if 加上花括号。

条件表达式的真假判断:if (x) 等价于 if (x != 0);if (!p) 等价于 if (p == NULL)。指针判空、返回值判错时这种写法很常用。

嵌套与代码风格:分支嵌套过深会让代码难以阅读,通常建议:

  • 能提前 return 的尽早 return,减少一层缩进;
  • 把「异常/边界情况」放在前面处理,正常流程留在后面;
  • 每个分支体都用花括号包起来,即使只有一条语句。
/* 提前返回,避免深层嵌套 */
int check(int x)
{
    if (x < 0) {
        return -1;       /* 先处理异常 */
    }
    if (x == 0) {
        return 0;
    }
    return 1;            /* 正常流程 */
}

2.3 switch 语句

基本形式:switch 根据一个整型表达式的值,跳到匹配的 case 标号处执行。

switch (grade) {
case 'A':
    printf("优秀\n");
    break;
case 'B':
    printf("良好\n");
    break;
case 'C':
    printf("及格\n");
    break;
default:
    printf("其他\n");
    break;
}

break 与「贯穿(fall through)」:case 只是跳转标号,不会自动结束。若省略 break,会继续执行下一个 case 的语句,这叫贯穿。它有时是刻意利用的特性:

switch (ch) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
    printf("元音\n");
    break;               /* 多个 case 共用一段逻辑 */
default:
    printf("辅音\n");
    break;
}

但多数情况下漏写 break 是 bug,编译器(如 GCC 的 -Wimplicit-fallthrough)可以帮忙提示。

default 的位置:default 可以放在任意位置,但习惯上放在最后;即使放在中间,也建议保留 break。

switch 的适用与限制:case 后必须是整型常量表达式(如 1、'A'、枚举值),不能是变量或浮点数,也不能判断区间。判断区间、浮点比较、字符串比较都应改用 if-else。

与 if-else 的选择:等值多分支用 switch 更清晰、跳转效率也更高;范围判断、复合条件用 if-else。

2.4 函数初步

为什么需要函数:把重复的逻辑封装起来,一次编写、多处调用,既减少代码量,也便于修改和测试。

函数的定义与调用:

#include <stdio.h>

/* 定义:返回类型 函数名(参数列表) { 函数体 } */
int add(int a, int b)
{
    return a + b;
}

int main(void)
{
    int s = add(3, 4);       /* 调用:实参 3、4 传给形参 a、b */
    printf("%d\n", s);       /* 输出 7 */
    return 0;
}

函数声明(原型):声明告诉编译器「这个函数存在、参数和返回值是什么样」,定义给出函数体。声明可以多次,定义只能一次。若函数定义在使用之前,可以省略声明;否则必须先声明:

int add(int a, int b);       /* 声明,通常放在文件开头或头文件里 */

int main(void)
{
    printf("%d\n", add(3, 4));
    return 0;
}

int add(int a, int b)        /* 定义 */
{
    return a + b;
}

参数传递:值传递:C 语言只有值传递,实参的值被拷贝给形参,函数内修改形参不影响实参。要修改外部变量必须传地址(指针),这一点在第四章会详细展开。

void try_modify(int x)
{
    x = 100;                 /* 只改了拷贝,外部不变 */
}

返回值:return 把结果带回调用处;返回类型为 void 时可省略 return,或写 return; 提前结束。返回类型必须与声明一致,否则可能被截断或产生未定义行为。

main 函数与返回值:main 的返回值传给操作系统,0 表示正常结束,非 0 表示异常。main 也可以带参数 int main(int argc, char *argv[]) 接收命令行参数。

2.5 多文件结构

为什么要拆成多个文件:当程序变大,把所有代码塞进一个 .c 文件会难以维护。按职责拆成多个源文件,配合头文件共享声明,是工程化的基本做法。

头文件放什么、源文件放什么:

文件放什么不放什么
.h 头文件函数声明、宏、类型定义、extern 变量声明函数定义、变量定义
.c 源文件函数定义、变量定义——

一个最小示例:

/* math_utils.h —— 只放声明 */
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int sub(int a, int b);

#endif
/* math_utils.c —— 放定义 */
#include "math_utils.h"

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
/* main.c —— 使用 */
#include <stdio.h>
#include "math_utils.h"

int main(void)
{
    printf("%d %d\n", add(3, 4), sub(3, 4));
    return 0;
}

头文件包含守卫:#ifndef / #define / #endif 防止同一个头文件被重复包含导致重复定义。也可以用 #pragma once(多数编译器支持,但不是标准)。

编译与链接多个文件:

gcc -c math_utils.c -o math_utils.o
gcc -c main.c -o main.o
gcc main.o math_utils.o -o app

也可以一步完成:gcc main.c math_utils.c -o app。若出现 undefined reference,通常是某个 .c 文件没参与链接;若出现 multiple definition,通常是变量或函数在头文件里被定义了。

static 与 extern 在多文件中的作用:static 修饰全局变量或函数,把它限制为仅本文件可见,避免命名冲突;extern 声明某个符号在别的文件中定义。

2.6 循环语句

C 语言提供三种循环,各有适用场景。

while 语句:先判断条件,条件为真才执行循环体,可能一次都不执行。

int i = 1;
while (i <= 5) {
    printf("%d ", i);
    i++;
}

do { } while (表达式):先执行一次循环体,再判断条件,至少执行一次。

int i = 1;
do {
    printf("%d ", i);
    i++;
} while (i <= 5);

for 语句及其惯用法:把「初始化、条件、更新」集中在一行,最适合已知循环次数的场景。

for (int i = 1; i <= 5; i++) {
    printf("%d ", i);
}

在 for 语句中省略表达式:三个表达式都可以省略,但分号必须保留。for (;;) 就是无限循环。

for (;;) {
    /* 无限循环,需在内部 break 退出 */
}

无限循环的惯用法:while (1) 与 for (;;) 等价,常用于事件循环、服务器主循环,必须保证有退出机制。

2.7 逗号运算符与空语句

逗号运算符的求值顺序:逗号表达式 a, b 从左到右依次求值,整个表达式的值是最后一个子表达式的值。

int a = (1, 2, 3);   /* a 的值为 3 */

逗号运算符优先级最低,常用于 for 中同时更新多个变量:

for (i = 0, j = 10; i < j; i++, j--) {
    /* ... */
}

空语句及其带来的问题:单独一个分号 ; 就是空语句。它本身合法,但误写在 if、while、for 后面会造成逻辑错误。

if (x > 0);          /* 分号让 if 变成空语句,后面的块无条件执行 */
{
    printf("正数\n");
}

while (i < 10);      /* 死循环:循环体是空语句,i 永远不变 */

2.8 跳转语句

break:立即跳出当前所在的 switch 或最内层循环。

continue:跳过本次循环剩余语句,直接进入下一次循环判断。

goto:无条件跳转到同一函数内的标号处。滥用会破坏程序结构,但在「多层循环一次性跳出」和「统一错误处理」场景下仍有用武之地。

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        if (a[i][j] == target) {
            goto found;      /* 一次跳出两层循环 */
        }
    }
}
found:
    printf("找到了\n");

return:结束当前函数并返回调用点,可带返回值。

return 与 exit 函数的区别:return 只结束当前函数,控制权回到调用者;exit 结束整个进程,会刷新并关闭所有打开的文件流,return 从 main 返回等价于 exit。

#include <stdlib.h>

void fatal(void)
{
    fprintf(stderr, "致命错误\n");
    exit(1);      /* 直接终止整个程序 */
}

2.9 综合示例与附录

综合示例:完整小程序拆解。下面是一个把输入、计算、输出拆成独立函数的小程序,体会模块化设计:

#include <stdio.h>

/* 求最大值 */
int max_of(int a, int b)
{
    return a > b ? a : b;
}

/* 求平均值 */
double average(int a, int b)
{
    return (a + b) / 2.0;
}

int main(void)
{
    int x, y;
    printf("请输入两个整数:");
    if (scanf("%d %d", &x, &y) != 2) {
        printf("输入错误\n");
        return 1;
    }
    printf("最大值 = %d,平均值 = %.2f\n", max_of(x, y), average(x, y));
    return 0;
}

函数头注释规范:每个函数上方用注释说明功能、参数含义、返回值,便于他人阅读:

/**
 * @brief  计算两个整数的最大值
 * @param  a 第一个整数
 * @param  b 第二个整数
 * @return 较大的那个数
 */
int max_of(int a, int b);

如何编程:从问题到代码的思考路径:先明确输入输出 → 拆解成若干步骤 → 每个步骤对应一个函数 → 再逐个实现、逐个测试。

利用函数实现模块化程序设计:把「读数据」「处理数据」「输出结果」分成不同函数,主函数只负责调度,逻辑清晰、便于复用。

示例:黑洞陷阱的解题思路与代码。所谓「黑洞数」,是指一个数经过固定规则变换后最终收敛到的固定值。以三位数黑洞数 495 为例:任取一个三位数,把各位数字重排成最大数和最小数相减,反复迭代最终必得 495。

#include <stdio.h>

/* 把三位数各位数字重排成最大数与最小数,返回两者之差 */
int kaprekar_step(int n)
{
    int d[3], tmp, max = 0, min = 0;
    d[0] = n / 100;
    d[1] = (n / 10) % 10;
    d[2] = n % 10;

    /* 冒泡排序,升序 */
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 2 - i; j++)
            if (d[j] > d[j + 1]) {
                tmp = d[j]; d[j] = d[j + 1]; d[j + 1] = tmp;
            }

    min = d[0] * 100 + d[1] * 10 + d[2];
    max = d[2] * 100 + d[1] * 10 + d[0];
    return max - min;
}

int main(void)
{
    int n;
    printf("请输入一个三位数:");
    scanf("%d", &n);
    while (n != 495) {
        printf("%d -> ", n);
        n = kaprekar_step(n);
    }
    printf("495\n");
    return 0;
}

函数设计的基本原则:可复用性(同一函数能被多处调用)、可维护性(修改只影响一处)、可读性(命名与注释清晰)、健壮性(对非法输入有防护)、高内聚(一个函数只做一件事)、低耦合(函数之间依赖尽量少)。

C 语言的函数接口设计:接口即函数原型,应保持稳定;参数不宜过多,必要时用结构体打包;错误通过返回值或输出参数传递,避免用全局变量隐式通信。

2.10 本章小结与练习

本章从 bool 类型与关系、逻辑表达式出发,依次讲了 if、switch 两种分支语句,while、do-while、for 三种循环,以及函数初步与多文件结构。回顾时抓住三条线索:分支决定走哪条路、循环决定重复多少次、函数决定逻辑怎么拆。

思考题

  1. if (a = 5) 与 if (a == 5) 有什么区别?为什么前者几乎总是 bug?
  2. && 和 || 的短路求值有什么实际用处?举一个利用短路避免空指针解引用的例子。
  3. switch 的 case 为什么不能是变量或浮点数?漏写 break 会发生什么?
  4. 头文件里为什么只放声明、不放定义?static 修饰全局变量能解决什么问题?

改错题

/* 错误 1:赋值误写成相等 */
if (x = 0) { }           /* 应改为 if (x == 0) */

/* 错误 2:区间判断写法错误 */
if (0 < x < 10) { }      /* 应改为 if (x > 0 && x < 10) */

/* 错误 3:switch 漏写 break */
switch (n) {
case 1: printf("一\n");   /* 缺少 break,会继续执行 case 2 */
case 2: printf("二\n"); break;
}

/* 错误 4:if 后误加空语句 */
if (x > 0);              /* 分号让 if 变成空语句 */
    printf("正数\n");

动手作业

  1. 编写程序,输入一个百分制成绩,用 if-else 输出等级(优秀/良好/及格/不及格),再用 switch 实现同样的功能并比较两种写法。
  2. 用 while、do-while、for 三种循环分别求 1 到 n 的和,比较它们的写法差异。
  3. 把本章的综合示例拆成 max_of、average 两个函数,分别放进 math_utils.c 与 math_utils.h,在 main.c 中调用,用 GCC 分步编译链接。
  4. 用 goto 实现「在二维数组中查找目标值,找到后一次性跳出两层循环」,再思考能否用函数加 return 达到同样效果。

第三章:数组

本章把「一批同类型数据」放进连续的内存里,讲清数组的定义、初始化、遍历、二维布局,以及数组与函数、数组与指针之间的关系。学完本章,你应该能画出任意一维、二维数组的内存图,并解释「数组名为什么能当指针用」。

3.1 数组概述

数组是一组类型相同、地址连续的变量集合,通过下标访问,下标从 0 开始。定义形式为 类型 数组名[元素个数];,元素个数必须是编译期可确定的常量表达式。

int a[5];        /* 5 个 int,共 20 字节,a[0] ~ a[4] */
double d[10];    /* 10 个 double */

数组的三个关键性质:

  • 连续存储:元素在内存中依次排列,a[i] 的地址等于首地址加 i * sizeof(元素类型)。
  • 下标从 0 开始:合法下标范围是 0 ~ n-1,越界访问不会报错,但属于未定义行为。
  • 数组名不是变量:数组名代表首元素地址,不能被赋值,也不能自增自减。

3.2 一维数组

定义与初始化

一维数组的初始化有三种常见写法:

int a[5] = {1, 2, 3, 4, 5};   /* 全部初始化 */
int b[5] = {1, 2};            /* 部分初始化,其余自动补 0 */
int c[]  = {1, 2, 3};         /* 省略长度,由初始化列表决定,长度为 3 */

注意:int d[5]; 只定义不初始化时,元素的值是不确定的(局部数组),使用前必须先赋值。

遍历与内存布局
#include <stdio.h>

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("a[%d] = %d, 地址 = %p\n", i, a[i], (void *)&a[i]);
    }
    printf("数组总大小 = %zu 字节\n", sizeof(a));
    return 0;
}

运行后可以看到,相邻元素的地址正好相差 sizeof(int)(通常 4 字节),这就是「连续存储」的直接证据。

低地址 ┌────┬────┬────┬────┬────┐ 高地址
       │ 1  │ 2  │ 3  │ 4  │ 5  │
       └────┴────┴────┴────┴────┘
        a[0] a[1] a[2] a[3] a[4]
常见操作示例

求最大值、求和、逆序输出是最基础的三类操作:

#include <stdio.h>

int main(void)
{
    int a[5] = {3, 1, 4, 2, 5};
    int max = a[0], sum = 0;

    for (int i = 0; i < 5; i++) {
        if (a[i] > max) {
            max = a[i];       /* 更新最大值 */
        }
        sum += a[i];          /* 累加求和 */
    }
    printf("max = %d, sum = %d\n", max, sum);

    for (int i = 4; i >= 0; i--) {
        printf("%d ", a[i]);  /* 逆序输出 */
    }
    printf("\n");
    return 0;
}

3.3 二维数组

二维数组可以理解为「数组的数组」:int a[3][4] 表示 3 行 4 列,共 12 个 int,在内存中依然是连续的,按行优先(先行后列)排列。

int a[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

内存布局如下,a[i][j] 的地址等于首地址加 (i * 列数 + j) * sizeof(int):

行优先连续排列:
a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] ... a[2][3]
  1       2       3       4       5     ...   12

遍历二维数组需要两层循环:

#include <stdio.h>

int main(void)
{
    int a[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%3d", a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

提示:二维数组作为函数参数时,列数不能省略,因为编译器需要它来计算行偏移,如 void f(int a[][4], int rows)。

3.4 数组与函数

数组作为函数参数时会退化为指针,函数内部拿不到数组长度,必须额外传入长度参数。

#include <stdio.h>

/* 求数组元素之和:传入首地址与元素个数 */
int sum_array(int *a, int n)
{
    int s = 0;
    for (int i = 0; i < n; i++) {
        s += a[i];
    }
    return s;
}

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};
    printf("sum = %d\n", sum_array(a, 5));   /* 数组名即首地址 */
    return 0;
}

两个容易踩的坑:

  • 在函数内写 sizeof(a) 得到的是指针大小(通常 8 字节),不是数组总大小。
  • 函数内修改 a[i] 会直接改动调用方的数组,因为传的是地址而非副本。

3.5 指针与数组

数组名在大多数表达式中会转换为首元素地址,因此可以用指针遍历数组:

#include <stdio.h>

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};
    int *p = a;              /* 等价于 &a[0] */

    for (int i = 0; i < 5; i++) {
        printf("%d ", *(p + i));   /* 指针偏移后解引用 */
    }
    printf("\n");
    return 0;
}

需要区分两个容易混淆的写法:

写法含义类型
a首元素地址int *
&a整个数组的地址int (*)[5]
a + 1第二个元素地址(偏移 4 字节)int *
&a + 1跳过整个数组(偏移 20 字节)int (*)[5]
printf("%td\n", (int *)&a - a);   /* 0,两者数值相同 */
printf("%td\n", (char *)(&a + 1) - (char *)&a);   /* 20,整个数组的大小 */

a[i]、*(a + i)、*(p + i)、p[i] 四种写法完全等价,理解这一点,后面第四章讲指针时就不会觉得抽象。

3.6 本章小结与练习

本章要点回顾:

  • 数组是同类型、连续存储的元素集合,下标从 0 开始,越界属于未定义行为。
  • 一维数组初始化时未写出的元素自动补 0;省略长度时由初始化列表决定。
  • 二维数组按行优先连续排列,a[i][j] 的地址由 i * 列数 + j 计算。
  • 数组作函数参数时退化为指针,长度信息丢失,需额外传参。
  • 数组名是首元素地址,a[i] 与 *(a + i) 等价。

练习题:

  1. 编写函数求一维数组的最大值、最小值与平均值。
  2. 实现数组逆序:原地交换首尾元素,不使用额外数组。
  3. 编写函数判断一个 3×3 二维数组是否为主对角线对称。
  4. 用指针遍历二维数组,输出所有元素之和。
  5. 思考题:为什么 void f(int a[5]) 与 void f(int *a) 完全等价?函数内如何正确获取元素个数?

第四章:指针

指针是 C 语言的灵魂,也是初学者最容易卡住的地方。本章从「地址」这个最朴素的概念出发,先讲清指针是什么、怎么画内存图,再讲指针的运算、应用、const 修饰、void *,最后把数组、指针与函数串成一条完整的链路。

4.1 什么是指针

指针就是存放地址的变量。每个变量在内存中都有地址,把地址存进另一个变量,这个变量就是指针。

#include <stdio.h>

int main(void)
{
    int a = 10;
    int *p = &a;          /* p 存放 a 的地址 */

    printf("a 的值   = %d\n", a);
    printf("a 的地址 = %p\n", (void *)&a);
    printf("p 的值   = %p\n", (void *)p);
    printf("*p 的值  = %d\n", *p);   /* 解引用,取到 a 的值 */
    return 0;
}

两个核心运算符:

  • &:取地址,&a 得到 a 的地址。
  • *:解引用,*p 取出 p 所指向地址上的值。

4.2 图解指针

变量 a:  ┌──────┐
          │  10  │   地址 0x7ffc1234
          └──────┘
              ▲
              │
变量 p:  ┌──────┐
          │0x7ffc1234│  地址 0x7ffc1238
          └──────┘

p 里存的是 a 的地址,所以 *p 就是 a。指针的类型决定了「一次解引用读几个字节、按什么格式解释」。

int a = 10;
int *pi = &a;        /* 解引用读 4 字节,按 int 解释 */
char *pc = (char *)&a;   /* 解引用读 1 字节,按 char 解释 */

4.3 指针的运算

指针支持有限的几种运算,核心是加减整数与同类型指针相减:

#include <stdio.h>

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};
    int *p = a;

    p++;                 /* 前进一个元素,地址增加 sizeof(int) */
    printf("%d\n", *p);  /* 输出 2 */

    printf("%td\n", &a[4] - &a[0]);   /* 输出 4,相差 4 个元素 */
    return 0;
}

要点:

  • p + n 的地址偏移是 n * sizeof(*p),不是 n 个字节。
  • 两个同类型指针相减得到元素个数,不是字节数。
  • 指针不能相加、不能相乘,也不能与浮点数运算。

4.4 指针的应用

指针最常见的三个用途:在函数内修改外部变量、遍历数组、动态内存管理。

#include <stdio.h>

/* 通过指针交换两个变量的值 */
void swap(int *x, int *y)
{
    int t = *x;
    *x = *y;
    *y = t;
}

int main(void)
{
    int a = 1, b = 2;
    swap(&a, &b);        /* 传地址,函数内修改才生效 */
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

如果写成 void swap(int x, int y),函数内交换的只是副本,调用方的 a、b 不会改变——这正是「值传递」与「传地址」的区别。

4.5 关于 * 和 & 的谜题

* 与 & 互为逆运算,但优先级和结合方向容易让人迷惑:

int a = 10;
int *p = &a;

printf("%d\n", *&a);      /* 等价于 a,输出 10 */
printf("%d\n", &*p);      /* 等价于 &a,输出 a 的地址 */
printf("%d\n", **&p);     /* 等价于 *p,输出 10 */

记忆方法:& 和 * 都是从右往左结合,*&a 先取地址再解引用,等于原地不动;&*p 先解引用再取地址,也等于原地不动。

4.6 数组与指针

数组名在表达式中退化为首元素地址,因此数组和指针在遍历上几乎可以互换:

#include <stdio.h>

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};
    int *p = a;

    for (int i = 0; i < 5; i++) {
        printf("%d %d %d\n", a[i], *(a + i), *(p + i));   /* 三者等价 */
    }
    return 0;
}

但两者并不完全相同:

对比项数组名 a指针 p
能否赋值不能可以
sizeof整个数组大小指针大小
存储位置不占额外空间占一块指针空间

4.7 指针变量与 const

const 与指针结合时有三种写法,含义完全不同:

int a = 1, b = 2;
int *const p1 = &a;        /* 指针自身只读:p1 不能改指向,但能改 *p1 */
const int *p2 = &a;        /* 指向的内容只读:不能通过 p2 改 a,但 p2 可改指向 */
const int *const p3 = &a;  /* 两者都只读 */

记忆口诀:const 在 * 左边修饰内容,在 * 右边修饰指针自身。

const 也常用于函数形参,向调用方承诺「我不会改你的数据」:

void print_array(const int *a, int n);   /* 良好的接口约定 */

4.8 无类型指针 void*

void * 是泛型指针,可以存放任意类型对象的地址,常用于通用接口(如 malloc 返回值、qsort 回调)。但它不能直接解引用,必须先转换成具体类型:

#include <stdio.h>

int main(void)
{
    int a = 10;
    void *p = &a;
    printf("%d\n", *(int *)p);   /* 必须先转成 int* 才能解引用 */
    return 0;
}

void * 与其它指针之间可以隐式转换,这也是 malloc 返回值可以不写强制转换的原因。

4.9 数组、指针与函数综合

数组作函数参数退化为指针

void f(int a[5]) 与 void f(int *a) 完全等价,长度信息丢失,必须额外传参。

二级指针

指向指针的指针,常用于在函数内修改外部指针,或构造动态二维数组:

#include <stdio.h>
#include <stdlib.h>

void alloc(int **p, int n)
{
    *p = (int *)malloc(n * sizeof(int));   /* 通过二级指针带回分配结果 */
}

int main(void)
{
    int *arr = NULL;
    alloc(&arr, 5);
    arr[0] = 1;
    printf("%d\n", arr[0]);
    free(arr);
    return 0;
}
函数指针

存放函数地址的指针,可用于回调、策略选择:

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main(void)
{
    int (*op)(int, int) = add;   /* 函数指针 */
    printf("%d\n", op(3, 4));    /* 输出 7 */
    op = sub;
    printf("%d\n", op(3, 4));    /* 输出 -1 */
    return 0;
}
数组指针

int (*p)[3] 指向整个数组,常用于二维数组按行遍历:

int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int (*p)[3] = a;          /* p 指向一行 */
printf("%d\n", p[1][2]);  /* 输出 6 */
空指针、野指针、失效指针
int *p = NULL;          /* 空指针:安全但不可解引用 */
int *q;                 /* 野指针:未初始化,值不确定 */
int *r = (int *)malloc(sizeof(int));
free(r);
/* 此时 r 是失效指针,不可再解引用 */

三者都必须避免解引用,使用前先判空、初始化、释放后置 NULL。

4.10 本章小结与练习

本章要点回顾:

  • 指针是存放地址的变量,& 取地址、* 解引用,二者互为逆运算。
  • 指针加减整数按元素大小偏移,同类型指针相减得到元素个数。
  • 数组名退化为首元素地址,a[i] 与 *(a + i) 等价,但数组名不可赋值。
  • const 在 * 左边修饰内容,在 * 右边修饰指针自身。
  • void * 是泛型指针,不能直接解引用,必须先转换类型。
  • 空指针、野指针、失效指针都必须避免解引用。

练习题:

  1. 编写函数 void reverse(int *a, int n),用指针原地逆序数组。
  2. 用二级指针实现一个函数,动态分配并初始化一个长度为 n 的整型数组。
  3. 用函数指针实现一个简易计算器,支持加减乘除四种运算。
  4. 分析 int *const p 与 const int *p 的区别,并各写一个示例。
  5. 思考题:为什么 free(p) 之后要把 p 置为 NULL?

第五章:字符串处理函数详解

C 语言没有专门的字符串类型,字符串本质是以 '\0' 结尾的字符数组。本章系统梳理 <string.h> 中的常用函数,按「检验、操作、内存、转换」四类展开,每个函数都给出可直接运行的示例,并指出常见的坑。

5.1 复习:字符与字符串

  • 字符:用单引号 'A',本质是一个整型值(ASCII 码)。
  • 字符串:用双引号 "A",本质是字符数组,以 '\0' 结尾。
char c = 'A';        /* 1 字节,值为 65 */
char s[] = "A";      /* 2 字节:'A' 和 '\0' */

内存分布:"abc" 占 4 字节,依次是 'a' 'b' 'c' '\0'。字符数组与字符串的区别在于是否自动补 '\0':

char a[3] = {'a', 'b', 'c'};   /* 字符数组,没有 '\0' */
char b[]  = "abc";             /* 字符串,自动补 '\0',长度 4 */

5.2 字符串检验函数

strlen:求长度

返回字符串长度(不含 '\0')。三种常见实现思路:下标遍历、指针遍历、递归。

#include <stdio.h>
#include <string.h>

int main(void)
{
    const char *s = "hello";
    printf("%zu\n", strlen(s));   /* 输出 5 */
    return 0;
}

指针实现版本:

size_t my_strlen(const char *s)
{
    const char *p = s;
    while (*p) {
        p++;                      /* 走到 '\0' 停下 */
    }
    return (size_t)(p - s);       /* 指针相减得到元素个数 */
}
strcmp、strncmp、strcoll:比较

strcmp 按字典序比较,返回负、0、正;strncmp 只比较前 n 个字符;strcoll 按本地化规则比较。

printf("%d\n", strcmp("abc", "abd"));   /* 负数,abc < abd */
printf("%d\n", strncmp("abc", "abd", 2));   /* 0,前两个字符相同 */
strchr、strrchr:查找字符

strchr 找字符首次出现位置,strrchr 找最后一次出现位置,找不到返回 NULL。

const char *s = "hello world";
printf("%s\n", strchr(s, 'o'));    /* 输出 "o world" */
printf("%s\n", strrchr(s, 'o'));   /* 输出 "orld" */
strspn、strcspn、strpbrk:字符集匹配
  • strspn:返回开头连续属于指定字符集的长度。
  • strcspn:返回开头连续不属于指定字符集的长度。
  • strpbrk:返回第一个属于指定字符集的位置。
printf("%zu\n", strspn("abc123", "abc"));    /* 3 */
printf("%zu\n", strcspn("abc123", "123"));   /* 3 */
strtok:切分字符串

按分隔符切分,会修改原串(把分隔符替换成 '\0'),因此不能用于字符串字面量。

#include <stdio.h>
#include <string.h>

int main(void)
{
    char s[] = "a,b,c";
    char *tok = strtok(s, ",");
    while (tok != NULL) {
        printf("%s\n", tok);
        tok = strtok(NULL, ",");   /* 后续调用传 NULL */
    }
    return 0;
}
strstr:查找子串

在主串中查找子串,返回首次出现位置。GCC 实现采用朴素匹配加优化;KMP 通过前缀表把复杂度降到 O(n+m)。

const char *s = "hello world";
const char *pos = strstr(s, "world");
if (pos != NULL) {
    printf("找到,位置偏移 %td\n", pos - s);
}

5.3 字符串操作函数

strcpy、strncpy:复制

strcpy 把源串复制到目标,需保证目标足够大;strncpy 只复制前 n 个字符,更安全但可能不补 '\0'。

char dst[10];
strcpy(dst, "abc");
strncpy(dst, "abcdef", 3);   /* 只复制前 3 个,dst 为 "abc" */
strcat、strncat:拼接

strcat 把源串追加到目标末尾;strncat 限制追加长度。

char s[20] = "hello";
strcat(s, " world");   /* s 变成 "hello world" */
strxfrm:本地化转换

按本地化规则转换字符串,便于比较,日常使用较少。

5.4 内存操作函数

memchr、memset、memcpy、memcmp、memmove 按字节操作内存,不关心内容是否为字符串,可处理任意二进制数据。

#include <stdio.h>
#include <string.h>

int main(void)
{
    int a[5];
    memset(a, 0, sizeof(a));          /* 全部清零 */
    int b[5];
    memcpy(b, a, sizeof(a));          /* 复制 */
    printf("%d\n", memcmp(a, b, sizeof(a)));   /* 0 表示相同 */
    return 0;
}

与字符串函数的关键区别:

对比项字符串函数内存函数
结束标志以 '\0' 为界按字节数操作
适用数据文本任意二进制
重叠处理不涉及memmove 可处理重叠,memcpy 不保证

5.5 转换成数值格式

atoi、atol、atoll 把字符串转成 int、long、long long:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    printf("%d\n", atoi("123"));       /* 输出 123 */
    printf("%ld\n", atol("456789"));   /* 输出 456789 */
    return 0;
}

注意 atoi 不报错,非法输入返回 0;需要严格校验时用 strtol 并检查 errno。

5.6 本章小结与练习

本章要点回顾:

  • 字符串是以 '\0' 结尾的字符数组,字符用单引号、字符串用双引号。
  • 检验类:strlen、strcmp、strchr、strstr、strtok 等。
  • 操作类:strcpy、strcat 及其 n 版本,注意目标缓冲区大小。
  • 内存类:memset、memcpy、memmove 按字节操作,可处理二进制数据。
  • 转换类:atoi 系列不报错,严格校验用 strtol。

练习题:

  1. 不调用库函数,自己实现 strlen、strcpy、strcmp 三个函数。
  2. 用 strtok 统计一段文本中单词的个数。
  3. 用 memmove 实现数组元素的循环右移。
  4. 用 strtol 实现一个安全的字符串转整数函数,非法输入返回错误码。
  5. 思考题:为什么 strtok 不能用于字符串字面量?

第六章:函数

函数是 C 程序的基本组成单位。本章从自定义函数讲起,深入函数调用背后的栈帧机制,讨论返回值、作用域与生存期,最后用递归把「分治」思想落地。

6.1 自定义函数

函数由返回类型、函数名、参数列表、函数体四部分组成。声明只给出原型,定义给出函数体;声明可多次,定义只能一次。

int add(int a, int b);          /* 声明 */

int add(int a, int b)           /* 定义 */
{
    return a + b;
}

参数传递规则:C 语言只有值传递,需要修改外部变量时传指针;返回值通过寄存器带回,类型需与声明一致。

#include <stdio.h>

void inc(int *p) { *p += 1; }   /* 传地址才能修改外部变量 */

int main(void)
{
    int a = 10;
    inc(&a);
    printf("%d\n", a);          /* 输出 11 */
    return 0;
}

6.2 编译链接和内存布局

编译链接过程回顾:预处理 → 编译 → 汇编 → 链接,最终生成可执行文件。

函数调用时,调用方压入实参、保存返回地址,跳转到函数入口;函数在栈帧中执行,返回时恢复现场。每次调用分配一块栈帧,存放形参、局部变量、返回地址:

高地址
  ┌──────────────┐
  │  调用方栈帧   │
  ├──────────────┤
  │  返回地址     │
  │  形参         │
  │  局部变量     │
  └──────────────┘
低地址

递归调用会层层压栈,深度过大导致栈溢出,这也是递归需要谨慎使用的原因。

6.3 函数返回值问题

小类型(int、指针)通过寄存器返回,大结构体可能通过隐藏指针返回。

返回局部变量指针是典型错误:局部变量在函数返回后栈帧被回收,返回它的地址会得到失效指针。

int *bad(void)
{
    int x = 10;
    return &x;      /* 错误:x 已失效 */
}

正确做法有三种:返回 static 变量、返回全局变量,或由调用方传入缓冲区。

int *good(int *buf)
{
    buf[0] = 10;
    return buf;     /* 由调用方提供内存,安全 */
}

6.4 作用域与生存期

  • 局部域:局部变量只在块内可见。
  • 文件作用域:文件作用域的变量在整个文件内可见。

生存期与作用域并不总是一致:

程序启动 ──► 全局变量创建
   │
   ├─ 函数调用 ──► 局部变量创建
   │
   ├─ 函数返回 ──► 局部变量销毁
   │
程序结束 ──► 全局变量销毁

static 修饰局部变量时,生存期延长到整个程序,但作用域不变:

#include <stdio.h>

void counter(void)
{
    static int n = 0;   /* 只初始化一次,跨调用保持 */
    n++;
    printf("%d\n", n);
}

int main(void)
{
    counter();   /* 1 */
    counter();   /* 2 */
    counter();   /* 3 */
    return 0;
}

static 修饰全局变量或函数时,限制为仅本文件可见。extern 则声明变量或函数在其他文件中定义:

/* a.c */
int g = 100;

/* b.c */
extern int g;   /* 声明 g 在别处定义 */

6.5 递归函数

递归的核心是分治:把大问题拆成规模更小的同类子问题,直到规模足够小可直接求解。分治三步:分解 → 解决 → 合并。

以求阶乘为例,fact(4) 依赖 fact(3),层层下探再逐层返回:

fact(4) = 4 * fact(3)
              fact(3) = 3 * fact(2)
                            fact(2) = 2 * fact(1)
                                          fact(1) = 1
#include <stdio.h>

int fact(int n)
{
    if (n <= 1) {
        return 1;          /* 递归出口,必须有 */
    }
    return n * fact(n - 1);
}

int main(void)
{
    printf("%d\n", fact(5));   /* 输出 120 */
    return 0;
}

写递归必须满足两个条件:有递归出口、每次递归规模缩小,否则会无限递归导致栈溢出。

6.6 本章小结与练习

本章要点回顾:

  • 函数由返回类型、函数名、参数列表、函数体组成,声明可多次、定义只能一次。
  • C 语言只有值传递,修改外部变量需传指针。
  • 每次函数调用分配栈帧,递归过深会栈溢出。
  • 不能返回局部变量的地址,可返回 static 变量或由调用方提供缓冲区。
  • static 修饰局部变量延长生存期,修饰全局变量限制可见性。
  • 递归必须有出口,且每次规模缩小。

练习题:

  1. 编写函数 int max3(int a, int b, int c),返回三个数中的最大值。
  2. 用递归实现斐波那契数列,并分析其时间复杂度。
  3. 用递归实现汉诺塔,输出每一步移动。
  4. 用递归实现二分查找,比较与循环版本的差异。
  5. 思考题:为什么 static 局部变量的初始化只执行一次?

第七章:类型设计

内置类型只能表示单个值,而现实中的实体(学生、商品、日期)往往有多个属性。本章讲如何用结构体把相关数据打包成一个整体,再讲共用体、枚举,以及结构体大小与内存对齐。

7.1 结构体类型的设计

结构体用 struct 定义,把多个不同类型的成员打包成一个整体:

struct Student {
    char name[20];
    int age;
    double score;
};

设计要点:成员按用途分组、名字清晰、数组长度预留足够空间。结构体只是类型声明,不占内存,定义变量时才分配空间。

7.2 结构体变量的定义和初始化

结构体变量在内存中按成员声明顺序依次存放,可能因对齐插入填充字节。

struct Student s = {"张三", 18, 95.5};   /* 按顺序初始化 */
struct Student t = {.name = "李四", .age = 19};   /* 指定成员初始化(C99) */

结构体可以嵌套:

struct Date {
    int year, month, day;
};

struct Person {
    char name[20];
    struct Date birthday;   /* 嵌套结构体 */
};

用 typedef 起别名可简化书写:

typedef struct Student {
    char name[20];
    int age;
} Student;

Student s = {"李四", 19};   /* 不用再写 struct */

7.3 结构体成员访问

用 . 访问结构体变量的成员,用 -> 通过指针访问成员:

#include <stdio.h>

struct Student {
    char name[20];
    int age;
    double score;
};

int main(void)
{
    struct Student s = {"张三", 18, 95.5};
    struct Student *p = &s;

    printf("%s %d\n", s.name, s.age);      /* 变量用 . */
    printf("%s %.1f\n", p->name, p->score); /* 指针用 -> */
    return 0;
}

结构体可作参数和返回值,大结构体建议传指针避免拷贝开销:

void print_student(const struct Student *p)
{
    printf("%s %d %.1f\n", p->name, p->age, p->score);
}

7.4 结构体与数组

结构体数组是最常用的组合,用来表示一组同类实体:

#include <stdio.h>

struct Student {
    char name[20];
    int age;
};

int main(void)
{
    struct Student cls[3] = {
        {"张三", 18},
        {"李四", 19},
        {"王五", 20}
    };
    for (int i = 0; i < 3; i++) {
        printf("%s %d\n", cls[i].name, cls[i].age);
    }
    return 0;
}

配合 qsort 可按任意成员排序:

int cmp_by_age(const void *a, const void *b)
{
    const struct Student *x = a, *y = b;
    return x->age - y->age;
}

7.5 结构体类型大小

结构体大小 = 成员大小之和 + 对齐填充。编译器让成员起始地址是其大小的整数倍,以提高访问效率。

struct A {
    char c;     /* 1 字节 */
    int i;      /* 需 4 字节对齐,c 后填充 3 字节 */
};              /* 总大小 8 字节,不是 5 字节 */

嵌套结构体先按自身对齐规则确定大小,再作为外层成员参与对齐。可用 #pragma pack(n) 改变默认对齐:

#pragma pack(1)
struct B {
    char c;
    int i;
};              /* 紧凑排列,总大小 5 字节 */
#pragma pack()

提示:用 sizeof 查看实际大小,不要凭成员大小相加去猜。

7.6 共用体与枚举

共用体(联合体):所有成员共享同一块内存,大小等于最大成员的大小,同一时刻只能有效使用一个成员。

union U {
    int i;
    char c;
    double d;
};              /* 大小等于 double 的 8 字节 */

枚举:定义一组具名整型常量,默认从 0 开始递增。

enum Color { RED, GREEN, BLUE };   /* RED=0, GREEN=1, BLUE=2 */
enum Color c = GREEN;
printf("%d\n", c);   /* 输出 1 */

7.7 本章小结与练习

本章要点回顾:

  • 结构体把多个不同类型的成员打包成一个整体,是自定义类型的基础。
  • 变量用 . 访问成员,指针用 -> 访问成员。
  • 结构体数组配合 qsort 可实现按任意成员排序。
  • 结构体大小受内存对齐影响,可用 #pragma pack 调整。
  • 共用体成员共享内存,枚举定义具名整型常量。

练习题:

  1. 设计一个 Book 结构体,包含书名、作者、价格,并编写函数按价格排序。
  2. 设计一个嵌套结构体 Employee,包含姓名和入职日期,输出所有员工信息。
  3. 用 sizeof 验证不同成员顺序下结构体大小的差异,并解释原因。
  4. 用共用体实现一个「同一块内存按 int 或 float 解释」的小示例。
  5. 思考题:为什么共用体的大小等于最大成员的大小,而不是所有成员之和?

第八章:动态内存管理

8.1 什么是动态内存

编译链接过程再分析:程序的内存布局在链接时确定,但有些数据的大小要到运行时才知道,需要动态分配。

栈区、堆区、静态区的划分:

高地址
  ┌──────────────┐
  │    栈区       │  局部变量、函数调用
  ├──────────────┤
  │    堆区       │  malloc / free
  ├──────────────┤
  │   静态区      │  全局变量、static 变量
  ├──────────────┤
  │   代码区      │  程序指令
  └──────────────┘
低地址

8.2 动态内存分配函数

malloc 与 free:malloc 在堆上分配指定字节数,返回 void*;free 释放。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *p = (int *)malloc(5 * sizeof(int));
    if (p == NULL) {
        return 1;          /* 分配失败 */
    }
    p[0] = 1;
    printf("%d\n", p[0]);
    free(p);               /* 释放后不可再访问 */
    return 0;
}

calloc:分配并清零。

int *p = (int *)calloc(5, sizeof(int));   /* 5 个元素全部为 0 */

realloc 及其调整内存大小的三种情况:扩大(原位置后有空闲则原地扩展,否则搬到新位置)、缩小、失败返回 NULL 且原内存仍有效。

int *q = (int *)realloc(p, 10 * sizeof(int));
if (q != NULL) {
    p = q;      /* 用新指针,旧指针可能已失效 */
}

aligned_alloc:分配指定对齐要求的内存,C11 引入。

8.3 常见错误与练习

找错误:内存泄漏、重复释放、越界访问:

/* 内存泄漏:分配后未 free */
int *p = (int *)malloc(sizeof(int));
p = NULL;   /* 原地址丢失,无法释放 */

/* 重复释放 */
int *q = (int *)malloc(sizeof(int));
free(q);
free(q);    /* 错误:二次释放 */

/* 越界访问 */
int *r = (int *)malloc(5 * sizeof(int));
r[5] = 1;   /* 错误:合法下标 0~4 */

动态管理函数与字符串:用 malloc 分配字符串缓冲区,注意预留 '\0' 的位置。

堆区与栈区的区别:栈由系统自动管理、速度快、空间小;堆由程序员手动管理、空间大、需自行释放。

课堂练习:实现一个可动态扩容的整型数组。

8.4 动态内存与结构体

动态内存管理与结构体:结构体中的指针成员可指向动态分配的内存。

柔性数组的设计与示例:结构体最后一个成员为不指定长度的数组,分配时一次性多分配空间。

#include <stdio.h>
#include <stdlib.h>

struct Buffer {
    int len;
    int data[];      /* 柔性数组,必须是最后一个成员 */
};

int main(void)
{
    struct Buffer *b = (struct Buffer *)malloc(sizeof(struct Buffer) + 5 * sizeof(int));
    b->len = 5;
    for (int i = 0; i < 5; i++) {
        b->data[i] = i;
    }
    printf("%d\n", b->data[4]);
    free(b);
    return 0;
}

定长包、指针数据包、变长数据缓冲区:定长包大小固定;指针数据包在结构体中存指针,数据另分配;变长缓冲区用柔性数组一次分配。

思考题:为什么柔性数组必须是结构体的最后一个成员?

8.5 动态内存与二维数组

用动态内存构造二维数组的多种方式:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int rows = 3, cols = 4;

    /* 方式一:指针数组 + 每行单独分配 */
    int **a = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        a[i] = (int *)malloc(cols * sizeof(int));
    }
    a[1][2] = 7;
    printf("%d\n", a[1][2]);

    for (int i = 0; i < rows; i++) {
        free(a[i]);
    }
    free(a);

    /* 方式二:一次分配连续内存,按行偏移访问 */
    int *b = (int *)malloc(rows * cols * sizeof(int));
    b[1 * cols + 2] = 8;
    printf("%d\n", b[1 * cols + 2]);
    free(b);

    return 0;
}

方式一灵活但分配次数多、内存不连续;方式二一次分配、内存连续、缓存友好,推荐优先使用。

8.6 本章小结与练习

本章要点回顾:

  • 程序内存分为栈区、堆区、静态区和代码区,动态内存来自堆区。
  • malloc 分配、free 释放,calloc 分配并清零,realloc 调整大小。
  • 常见错误:内存泄漏、重复释放、越界访问、使用已释放内存。
  • 柔性数组必须是结构体最后一个成员,可一次分配变长数据。
  • 二维数组可用「指针数组」或「一次分配连续内存」两种方式构造。

练习题:

  1. 实现一个可动态扩容的整型数组,支持 push 与自动扩容。
  2. 用 realloc 实现一个动态字符串拼接函数。
  3. 找出下面代码中的三处内存错误并改正(泄漏、二次释放、越界)。
  4. 用柔性数组实现一个变长整型缓冲区,并写出释放函数。
  5. 思考题:为什么 realloc 失败时不能直接用原指针接收返回值?

第九章:文件操作

9.1 C 语言中的文件

文件是什么:存储在磁盘上的数据集合,可以是文本,也可以是二进制。

文件三要素:文件名、文件路径、文件内容。

C 语言文件系统中的类型:FILE 结构体指针代表一个打开的文件流。

预定义标准流与宏常量:stdin、stdout、stderr 是三个预定义流;EOF 表示文件结束,NULL 表示打开失败。

9.2 流的概念及分类

流的概念:流是数据在程序与外部设备之间传输的抽象,C 语言把所有 I/O 统一成流处理。

文本文件与二进制文件:文本文件以字符形式存储,便于人阅读;二进制文件按字节原样存储,效率高、精度无损。

9.3 文件读写函数

fopen、fclose:

#include <stdio.h>

int main(void)
{
    FILE *fp = fopen("data.txt", "w");
    if (fp == NULL) {
        return 1;
    }
    fprintf(fp, "hello\n");
    fclose(fp);
    return 0;
}

打开模式:"r" 读、"w" 写(清空)、"a" 追加、"rb"/"wb" 二进制。

sprintf、fprintf、fscanf:sprintf 格式化到字符串,fprintf 格式化到文件,fscanf 从文件格式化读取。

fwrite、fread:按字节块读写二进制数据。

int a[3] = {1, 2, 3};
FILE *fp = fopen("arr.bin", "wb");
fwrite(a, sizeof(int), 3, fp);
fclose(fp);

9.4 缓冲与非缓冲文件系统

fflush、setbuf、setvbuf:标准 I/O 默认带缓冲,fflush 强制把缓冲区内容写入文件;setbuf/setvbuf 可设置或取消缓冲。

fflush(stdout);   /* 立即输出,常用于调试 */

9.5 文件位置

ftell、fgetpos、fseek、fsetpos、rewind:ftell 返回当前位置偏移;fseek 移动读写位置;rewind 回到文件开头。

fseek(fp, 0, SEEK_SET);   /* 回到开头 */
long pos = ftell(fp);     /* 当前偏移 */

9.6 错误处理

clearerr、feof、ferror、perror:feof 判断是否读到文件末尾;ferror 判断是否发生错误;perror 打印错误信息;clearerr 清除错误标志。

if (ferror(fp)) {
    perror("读取失败");
}

9.7 对文件的操作

remove、rename:删除文件、重命名文件。

remove("old.txt");
rename("a.txt", "b.txt");

9.8 字符和字符串的输入输出

fgetc、getc、fgets:fgetc 读一个字符;fgets 读一行。

char line[100];
fgets(line, sizeof(line), fp);

fputc、putc、fputs:写一个字符或一行。

getchar、gets、gets_s:getchar 从标准输入读一个字符;gets 因不安全已被废弃,改用 fgets 或 C11 的 gets_s。

putchar、puts、ungetc:putchar 输出一个字符;puts 输出一行并自动换行;ungetc 把字符退回输入流。

putchar('A');
puts("hello");

9.9 本章小结与练习

本章要点回顾:

  • 文件是磁盘上的数据集合,C 语言用 FILE * 把文件抽象成流。
  • fopen 打开、fclose 关闭,打开模式决定读写方式。
  • 文本文件用 fprintf/fscanf,二进制文件用 fwrite/fread。
  • fseek/ftell 控制读写位置,feof/ferror 判断状态。
  • gets 不安全,应改用 fgets。

练习题:

  1. 写一个程序,把用户输入的多行文本写入文件,再逐行读回并打印。
  2. 用 fwrite/fread 把结构体数组写入二进制文件并读回。
  3. 用 fseek 实现读取文件末尾 10 个字节。
  4. 用 ferror 与 perror 处理打开失败与读取失败。
  5. 思考题:为什么二进制文件读写比文本文件更高效、精度更高?

第十章:预处理

10.1 #define

宏常量与命令行定义:#define PI 3.14159 在预处理阶段做文本替换;也可在编译命令行用 -D 定义宏。

字符序列替换:宏就是纯粹的文本替换,不参与类型检查。

定义类似函数的宏:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

预处理运算符:#、##、#@:# 把参数转成字符串,## 连接两个记号,#@ 把参数转成字符(部分编译器支持)。

#define STR(x) #x
#define CAT(a, b) a##b

printf("%s\n", STR(hello));   /* 输出 "hello" */
int CAT(my, var) = 1;         /* 展开为 int myvar = 1; */

10.2 #undef

取消宏定义:#undef PI 之后 PI 不再是宏。

#define PI 3.14
#undef PI

10.3 综合示例

宏体展开过程:预处理器把宏体原样替换到使用处,再参与编译。

递归问题:宏不能递归展开,#define F(x) F(x) 不会无限展开。

#define 与 typedef 的区别:#define 是文本替换,typedef 是类型别名,后者受类型系统约束。

宏与函数的区别:宏在预处理期展开,无调用开销但可能重复求值;函数在运行期调用,有开销但类型安全。

括号问题与变元的副作用:宏参数必须整体加括号,否则优先级出错;参数若带副作用(如 i++)会被求值多次。

#define SQUARE(x) ((x) * (x))   /* 必须加括号 */
int r = SQUARE(i++);            /* i 被自增两次,错误 */

变元可以是类型:宏参数可以传类型名,实现泛型效果。

#define MALLOC(type, n) ((type *)malloc((n) * sizeof(type)))
int *p = MALLOC(int, 5);

10.4 泛型编程

示例与加大括号问题:用宏实现「对任意类型求最大值」时,宏体若含多条语句,必须用 do { } while (0) 包裹,否则在 if 后展开会出错。

#define SWAP(a, b) do { \
    typeof(a) _t = (a); \
    (a) = (b);          \
    (b) = _t;           \
} while (0)

最终的解决方法:do { ... } while (0) 保证宏在语法上等价于一条语句,可安全地放在 if、for 之后。

10.5 可变参数的宏

__VA_ARGS__ 的使用:用 ... 接收可变参数,用 __VA_ARGS__ 引用。

#define LOG(fmt, ...) printf(fmt, __VA_ARGS__)
LOG("%d %d\n", 1, 2);

10.6 宏展开的步骤与预定义宏

宏展开的完整步骤:扫描源码 → 识别宏名 → 替换宏体 → 对替换结果再次扫描(但不递归展开自身)。

常用预定义宏:__FILE__(当前文件名)、__LINE__(当前行号)、__DATE__、__TIME__、__func__(C99)。

printf("%s:%d\n", __FILE__, __LINE__);

10.7 条件编译指令

#if、#else、#elif、#endif:按常量表达式决定是否编译某段代码。

#if VERSION >= 2
    printf("新版本\n");
#else
    printf("旧版本\n");
#endif

#ifdef、#ifndef:判断宏是否已定义,常用于头文件包含守卫。

使用 defined:defined(NAME) 判断宏是否存在,可与 #if 组合。

#if defined(DEBUG) && DEBUG > 0
    printf("调试模式\n");
#endif

10.8 其他预处理指令

#line、#error、#include、#pragma:#line 修改行号与文件名;#error 在编译期产生错误信息;#include 包含文件;#pragma 提供编译器相关指令。

#error "此平台不支持"
#pragma once

10.9 附录

数据类型详解:数据在内存中的存储、补码、char 的范围、短整型、切片与截取:整数以补码存储,正数补码等于原码,负数补码为「反码加 1」。char 有符号时范围 -128~127,无符号时 0~255。

类型转换:隐式类型转换规则、类型转换的本质:低精度向高精度自动转换,本质是改变对同一段内存的解释方式或重新编码。

浮点数的存储表示与详细解读:按 IEEE 754 标准,float 由符号位、8 位阶码、23 位尾数组成;double 为 1 + 11 + 52。

变长参数表:va_list、va_start、va_arg、va_end:

#include <stdio.h>
#include <stdarg.h>

int sum(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    int s = 0;
    for (int i = 0; i < n; i++) {
        s += va_arg(ap, int);
    }
    va_end(ap);
    return s;
}

int main(void)
{
    printf("%d\n", sum(3, 1, 2, 3));   /* 输出 6 */
    return 0;
}

局部变量的内存对齐示例:编译器会按变量大小对齐其地址,结构体成员之间可能插入填充字节,理解对齐有助于计算结构体大小、优化内存布局。

10.10 本章小结与练习

本章要点回顾:

  • 预处理在编译前完成,只做文本替换,不参与类型检查。
  • #define 定义宏常量与函数式宏,参数必须整体加括号。
  • # 转字符串、## 连接记号,__VA_ARGS__ 支持可变参数宏。
  • 多语句宏用 do { ... } while (0) 包裹,避免展开出错。
  • 条件编译 #if/#ifdef 控制代码是否参与编译,常用于头文件守卫。

练习题:

  1. 用 #define 实现一个求三个数最大值的宏,并说明括号的必要性。
  2. 用 # 与 ## 实现一个「打印变量名与值」的调试宏。
  3. 用 do { ... } while (0) 改写一个多语句宏,验证在 if 后使用正确。
  4. 用条件编译实现一个可开关的调试日志宏。
  5. 思考题:为什么宏参数带副作用(如 i++)会导致错误?

第十一章:综合项目实战——停车场管理系统

学到这里,C 语言的主要知识点已经串成了一条完整的线:数据类型、数组、指针、结构体、动态内存、文件操作、预处理。但「学过」和「会用」之间还差一段距离。本章用一个贴近生活的小项目——停车场管理系统——把前面各章的知识点真正拼装起来,让你体会一个完整程序从需求到落地的全过程。

11.1 项目需求分析

停车场管理系统要解决的核心问题是:记录车位状态、管理车辆进出、计算停车费用。在动手写代码之前,先把「要做什么」讲清楚,比直接堆代码重要得多。我们把需求拆成下面几个功能板块:

功能板块输入处理输出
车辆入场车牌号检查是否已入场、找空闲车位、记录入场时间分配的车位号
车辆出场车牌号找到车辆、计算停车时长与费用、释放车位停车时长与费用
查询车位无统计已占用/空闲数量、列出在场车辆车位状态列表
数据持久化车位表程序退出时写入文件,启动时读回磁盘文件

除了功能,还要明确几条约束条件,它们直接决定了后面代码怎么写:

  • 车位数量固定:本项目采用固定 20 个车位,用结构体数组表示车位表。这样既覆盖结构体、数组、字符串、文件等核心知识,又不会因为动态内存的复杂度而喧宾夺主。想改成动态车位,可以留到扩展练习里用 malloc 实现。
  • 车牌号唯一:同一辆车不能同时占用两个车位,入场前必须查重。
  • 时间以秒为单位:用 <time.h> 的 time() 取当前时间戳,存成 long,出场时相减得到停车秒数。
  • 计费规则:每小时 5 元,不足一小时按一小时计(向上取整)。
  • 数据不丢失:程序退出后车位与车辆信息要能恢复,因此需要文件持久化。

把需求写成表格和约束清单,好处是后面每写一个函数,都能对应回某个板块,不会写着写着跑偏。这也是真实项目里「需求分析」这一步的价值:先想清楚边界,再动手实现。

11.2 数据结构设计

整个系统的核心是一张「车位表」。每个车位要么空闲,要么停着一辆车。设计数据结构时,先问自己三个问题:一个车位需要记录哪些信息?整个停车场需要记录哪些信息?这些信息用什么类型表示最合适?

一个车位需要知道:是否被占用、停的是哪辆车(车牌号)、什么时候进来的(入场时间)。于是得到单个车位的结构体:

#define MAX_SLOTS 20        /* 车位总数 */
#define PLATE_LEN 16        /* 车牌号最大长度(含 '\0') */

/* 单个车位 */
typedef struct {
    int  occupied;              /* 0 表示空闲,1 表示已占用 */
    char plate[PLATE_LEN];      /* 车牌号,如 "京A12345" */
    long in_time;               /* 入场时间,用 time_t 的秒数表示 */
} Slot;

再往上,整个停车场就是「一张车位表 + 一个已占用计数」:

/* 停车场:车位表 + 已占用数量 */
typedef struct {
    Slot slots[MAX_SLOTS];
    int  used;                  /* 已占用车位数,便于快速查询 */
} ParkingLot;

这里每个字段的选择都有讲究:

  • occupied 用 int 而不是 bool,是为了配合 memset 一次性清零时语义直观(0 即空闲);用 bool 也可以,但要注意包含 <stdbool.h>。
  • plate 用定长字符数组而不是 char *,是因为车位表是静态分配的,车牌号长度有限且固定,定长数组最省心,也避免了动态内存管理。
  • in_time 用 long 存秒级时间戳,配合 <time.h> 的 time() 使用,出场时两个时间戳相减就是停车秒数。
  • used 是一个冗余字段:它本可以遍历 slots 数出来,但单独存一份能让「停车场是否已满」「空闲数量」这类查询变成 O(1),这是典型的「用一点空间换查询效率」的设计。

这里用到的前面章节知识点:typedef struct 给结构体起别名(第七章)、字符数组存车牌号(第五章)、long 存时间戳(第九章文件持久化时会用到)。数据结构定好了,后面的函数就都是围绕这张表做增删查改。

11.3 核心功能实现

初始化与查找空闲车位

程序启动时,如果数据文件存在就读取,否则把所有车位初始化为空闲。这一板块包含三个基础函数:初始化、查找空闲车位、按车牌查找车辆。它们是后面入场、出场、查询功能的公共底座。

#include <stdio.h>
#include <string.h>

/* 初始化停车场:全部车位置为空闲 */
void lot_init(ParkingLot *lot)
{
    memset(lot, 0, sizeof(ParkingLot));   /* 一次性清零,occupied 全为 0 */
    lot->used = 0;
}

/* 查找第一个空闲车位,返回下标;没有则返回 -1 */
int find_free_slot(const ParkingLot *lot)
{
    for (int i = 0; i < MAX_SLOTS; i++) {
        if (!lot->slots[i].occupied) {
            return i;
        }
    }
    return -1;
}

/* 按车牌号查找车辆所在车位,返回下标;找不到返回 -1 */
int find_by_plate(const ParkingLot *lot, const char *plate)
{
    for (int i = 0; i < MAX_SLOTS; i++) {
        if (lot->slots[i].occupied &&
            strcmp(lot->slots[i].plate, plate) == 0) {
            return i;
        }
    }
    return -1;
}

逐行说明:

  • memset(lot, 0, sizeof(ParkingLot)) 把整块结构体按字节清零,occupied 全变 0(空闲)、plate 全变空串、in_time 全变 0,一步到位。这里依赖「0 字节表示空闲」的约定,所以 occupied 用 int 而非枚举更稳妥。
  • find_free_slot 从头扫描,返回第一个空闲车位下标。用「返回下标、找不到返回 -1」的约定,而不是返回指针,是因为下标更便于打印车位号、也便于调用方判断失败。
  • find_by_plate 先判断 occupied 再比较车牌,避免拿空车位的空串去 strcmp 造成误匹配。strcmp 相等返回 0,所以用 == 0 判断。

两个查找函数都接收 const ParkingLot *,const 修饰表示函数只读不写,既是一种自我约束,也让调用方放心传入。这里用到了第五章的 memset、strcmp,以及第四章的指针与 const。

验证方式:初始化后调用 find_free_slot 应返回 0;连续入场几辆车后,find_by_plate 应能定位到对应车位,查不存在的车牌应返回 -1。

车辆入场

入场逻辑可以拆成四步:判满 → 查重 → 找空位 → 写记录。任何一步失败都要给出明确提示并返回错误,不能默默失败。

#include <time.h>

/* 车辆入场:成功返回车位号,失败返回 -1 */
int car_in(ParkingLot *lot, const char *plate)
{
    /* 第一步:判断停车场是否已满 */
    if (lot->used >= MAX_SLOTS) {
        printf("停车场已满,无法入场\n");
        return -1;
    }
    /* 第二步:查重,同一车牌不能重复入场 */
    if (find_by_plate(lot, plate) != -1) {
        printf("车牌 %s 已在场内\n", plate);
        return -1;
    }
    /* 第三步:找一个空闲车位 */
    int idx = find_free_slot(lot);
    if (idx < 0) {
        return -1;
    }
    /* 第四步:写入车牌与入场时间 */
    Slot *s = &lot->slots[idx];
    s->occupied = 1;
    strncpy(s->plate, plate, PLATE_LEN - 1);   /* 限制长度,防止溢出 */
    s->plate[PLATE_LEN - 1] = '\0';            /* 确保以 '\0' 结尾 */
    s->in_time = (long)time(NULL);             /* 记录当前时间戳 */
    lot->used++;

    printf("入场成功,车位号:%d\n", idx + 1);
    return idx;
}

几个容易踩坑的细节:

  • strncpy 不保证补 '\0':当源串长度等于或超过 PLATE_LEN - 1 时,strncpy 只拷贝前 PLATE_LEN - 1 个字符,不会自动补结束符。所以必须手动写 s->plate[PLATE_LEN - 1] = '\0',否则后续 strcmp 会读到越界内存。
  • 车位号对用户展示用 idx + 1:数组下标从 0 开始,但给用户看的车位号从 1 开始更符合直觉。函数内部仍返回下标,由调用方决定怎么展示。
  • time(NULL) 返回 time_t:显式转成 long 存储,避免不同平台 time_t 类型宽度不一致带来的隐式转换警告。
  • 先判满再查重:顺序无所谓,但先判满能省一次全表扫描;如果停车场已满,查重也没意义。

验证方式:空场入场第一辆车应返回车位号 1;同一车牌再次入场应提示「已在场内」;连续入场 20 辆后第 21 辆应提示「停车场已满」。

车辆出场与计费

出场是计费的核心板块,逻辑分四步:找到车辆 → 计算时长 → 计算费用 → 释放车位。计费规则是每小时 5 元、不足一小时按一小时计。

#define FEE_PER_HOUR 5      /* 每小时费用(元) */

/* 车辆出场:成功返回费用(元),失败返回 -1 */
int car_out(ParkingLot *lot, const char *plate)
{
    /* 第一步:按车牌找到车辆 */
    int idx = find_by_plate(lot, plate);
    if (idx < 0) {
        printf("未找到车牌 %s 的车辆\n", plate);
        return -1;
    }

    Slot *s = &lot->slots[idx];
    long now = (long)time(NULL);
    long seconds = now - s->in_time;
    if (seconds < 0) {
        seconds = 0;                            /* 防止系统时间被回拨导致负数 */
    }

    /* 第二步:不足一小时按一小时计,向上取整 */
    long hours = (seconds + 3599) / 3600;
    if (hours == 0) {
        hours = 1;
    }
    /* 第三步:计算费用 */
    int fee = (int)(hours * FEE_PER_HOUR);

    printf("车牌:%s,停车 %ld 小时,费用 %d 元\n", s->plate, hours, fee);

    /* 第四步:释放车位 */
    s->occupied = 0;
    s->plate[0] = '\0';
    s->in_time = 0;
    lot->used--;
    return fee;
}

关键点逐个解释:

  • 向上取整技巧:(seconds + 3599) / 3600 是整数除法下的向上取整。例如 1 秒 → (1+3599)/3600 = 1,3600 秒 → (3600+3599)/3600 = 1,3601 秒 → (3601+3599)/3600 = 2。这样避免了引入 <math.h> 的 ceil,也避免了浮点误差。
  • hours == 0 的兜底:理论上 seconds >= 0 时 hours 至少为 0,只有 seconds == 0(刚入场立刻出场)时 hours 为 0,此时按规则应算 1 小时,所以补一个判断。
  • seconds < 0 的边界:如果系统时间被回拨(比如手动改时间、NTP 校时),now - in_time 可能为负,直接算会得到负费用。这里把负数归零,体现健壮性考虑。
  • 释放车位要清干净:occupied 置 0、plate 清空、in_time 归零,三者缺一不可,否则下次 find_by_plate 可能误匹配到残留车牌。
  • lot->used--:维护冗余计数,保证查询板块的统计准确。

验证方式:入场后立刻出场,费用应为 5 元(1 小时);停车 1 小时 1 秒,费用应为 10 元(2 小时);出场后再次查询该车位应显示空闲。

查询车位状态
/* 打印当前所有已占用车位 */
void lot_show(const ParkingLot *lot)
{
    printf("===== 停车场状态 =====\n");
    printf("总车位:%d,已占用:%d,空闲:%d\n",
           MAX_SLOTS, lot->used, MAX_SLOTS - lot->used);

    for (int i = 0; i < MAX_SLOTS; i++) {
        if (lot->slots[i].occupied) {
            printf("车位 %2d:%s\n", i + 1, lot->slots[i].plate);
        }
    }
}

11.4 数据持久化

程序退出后数据不能丢,所以要把车位表写入文件。这里用二进制文件保存整个 ParkingLot 结构体,读写都只需一次 fwrite/fread(第九章):

#define DATA_FILE "parking.dat"

/* 保存停车场数据到文件,成功返回 0 */
int lot_save(const ParkingLot *lot)
{
    FILE *fp = fopen(DATA_FILE, "wb");
    if (fp == NULL) {
        perror("保存失败");
        return -1;
    }
    fwrite(lot, sizeof(ParkingLot), 1, fp);
    fclose(fp);
    return 0;
}

/* 从文件加载停车场数据,成功返回 0;文件不存在则初始化 */
int lot_load(ParkingLot *lot)
{
    FILE *fp = fopen(DATA_FILE, "rb");
    if (fp == NULL) {
        lot_init(lot);                          /* 首次运行,初始化 */
        return 0;
    }
    size_t n = fread(lot, sizeof(ParkingLot), 1, fp);
    fclose(fp);
    if (n != 1) {
        lot_init(lot);                          /* 文件损坏,重新初始化 */
        return -1;
    }
    return 0;
}

用二进制方式保存结构体,好处是读写简单、精度无损;缺点是文件格式与结构体布局强绑定,换平台或改结构体后旧文件可能读不出来。这也是第九章强调「二进制文件高效但可移植性差」的一个真实例子。

11.5 主函数与菜单

最后用一个简单的文本菜单把所有功能串起来:

#include <stdio.h>
#include <string.h>

int main(void)
{
    ParkingLot lot;
    lot_load(&lot);

    int choice;
    char plate[PLATE_LEN];

    while (1) {
        printf("\n===== 停车场管理系统 =====\n");
        printf("1. 车辆入场\n");
        printf("2. 车辆出场\n");
        printf("3. 查看车位\n");
        printf("0. 退出\n");
        printf("请选择:");

        if (scanf("%d", &choice) != 1) {
            break;
        }

        switch (choice) {
        case 1:
            printf("请输入车牌号:");
            scanf("%15s", plate);               /* 限制宽度,防止溢出 */
            car_in(&lot, plate);
            break;
        case 2:
            printf("请输入车牌号:");
            scanf("%15s", plate);
            car_out(&lot, plate);
            break;
        case 3:
            lot_show(&lot);
            break;
        case 0:
            lot_save(&lot);
            printf("数据已保存,再见\n");
            return 0;
        default:
            printf("无效选项\n");
            break;
        }
    }

    lot_save(&lot);
    return 0;
}

scanf("%15s", plate) 中的 15 是宽度限制,保证最多读 15 个字符,配合 PLATE_LEN = 16 正好留出 '\0' 的位置,避免缓冲区溢出——这是第五章反复强调的安全习惯。

11.6 项目小结与扩展方向

这个项目虽然不大,却把前面各章的知识点几乎都用了一遍:

知识点在本项目中的体现
结构体Slot、ParkingLot 描述车位与停车场
数组slots[MAX_SLOTS] 车位表
指针函数传 ParkingLot * 避免整体拷贝
字符串车牌号存储与 strcmp、strncpy
文件操作fwrite/fread 持久化数据
预处理#define 定义车位数量、费率、文件名

如果想继续挑战,可以尝试这些扩展:

  1. 动态车位:用 malloc 按实际需求分配车位表,支持运行时扩容(第八章)。
  2. 按时间排序:出场时按入场时间先后排队,用 qsort 排序(第七章)。
  3. 文本格式存储:改用 fprintf/fscanf 保存为可读文本,便于人工查看(第九章)。
  4. 多文件拆分:把车位管理、文件读写、菜单界面拆成多个 .c/.h 文件(第二章多文件结构)。
  5. 统计报表:记录每日收入,用文件追加方式保存流水(第九章)。

写完整项目的关键,不在于代码有多复杂,而在于把每个知识点用在它该出现的地方。当你能独立完成这个停车场系统,再回头看前面的章节,会发现那些曾经零散的语法点,已经连成了一张可以随时调用的网。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址