引言
这是一本写给初学者的 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 程序的几个基本要素。
#include <stdio.h>:预处理指令,把标准输入输出头文件包含进来,这样才能使用printf。int main(void):主函数,程序执行的入口。int表示返回整型,void表示不接收参数。printf(...):库函数调用,向标准输出打印字符串。return 0;:向操作系统返回 0,表示程序正常结束。
编译与运行(以 GCC 为例):
gcc hello.c -o hello
./hello
输出结果为:
Hello, World!
C 语言程序的结构特点
- 预处理指令:以
#开头,在编译前由预处理器处理,如#include、#define。 - 函数:C 程序由一个或多个函数组成,有且仅有一个
main函数作为入口。 - 语句:以分号
;结尾,是程序执行的基本单位。 - 注释:
/* ... */为块注释,// ...为行注释(C99 起支持)。 - 大小写敏感:
Main与main是两个不同的标识符。
1.2 数据类型
C 语言是强类型语言,每个变量都必须有明确的类型,类型决定了变量占用的内存大小、取值范围以及可参与的运算。
基本数据类型
| 类型 | 典型字节数 | 典型取值范围 | 说明 |
|---|---|---|---|
char | 1 | -128 ~ 127(有符号) | 字符或小整数 |
short | 2 | -32768 ~ 32767 | 短整型 |
int | 4 | -2147483648 ~ 2147483647 | 最常用的整型 |
long | 4 / 8 | 依平台而定 | 长整型 |
long long | 8 | -2^63 ~ 2^63-1 | C99 引入的 64 位整型 |
float | 4 | 约 ±3.4e38,6~7 位有效数字 | 单精度浮点 |
double | 8 | 约 ±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 | 指针地址 |
%zu | sizeof 的返回值 |
scanf 函数用于格式化输入,原型为 int scanf(const char *format, ...);。注意传入的是变量的地址:
int n;
scanf("%d", &n); /* 必须加 & */
scanf 返回成功读入的项数,可用于判断输入是否合法。
常量
常量是程序运行期间值不可改变的量,常见的有四类:
- 字面常量:直接写出的值,如
10、3.14、'A'、"hello"。 - 宏常量:用
#define定义,如#define PI 3.14159。 - 常变量:用
const修饰,如const int MAX = 100;。 - 枚举常量:用
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 / 无后缀 | 链接后的完整程序 | 链接器 |
四个阶段各做什么
- 预处理:处理
#include、#define、条件编译,展开宏、删除注释,产出.i文件。这一步只做文本替换,不检查语法错误。 - 编译:把预处理后的代码翻译成汇编语言,同时做语法检查、类型检查与优化,产出
.s文件。 - 汇编:把汇编代码翻译成机器指令,产出目标文件
.o,其中还留有未解析的外部符号(如printf)。 - 链接:把多个目标文件与库文件合并,解析符号引用,确定各段最终地址,产出可执行文件。
# 以 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;
}
这段代码里三者的分工一目了然:结构体负责「数据长什么样」,指针负责「怎样高效地传递和修改数据」,文件负责「数据怎样活过程序的生命周期」。后续章节会分别把每一环讲透,这里只需记住这条链路:结构体 → 指针 → 文件。
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 等背景知识。回顾时建议抓住三条线索:类型决定内存布局、控制结构决定执行路径、编译链接决定代码如何变成程序。
思考题
int与unsigned int在内存中占用的字节数相同,为什么取值范围不同?- 为什么说「变量是一块有名字的内存」?
extern int a;与int a;在内存分配上有什么区别? - 前置
++与后置++单独成句时结果相同,为什么参与表达式后可能不同? - 预处理、编译、汇编、链接四个阶段,各自能发现哪一类错误?
改错题
/* 错误 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 */
动手作业
- 编写程序,输入三个整数,输出其中的最大值与最小值(分别用
if-else和三目运算符各实现一次)。 - 把 2.3 节的三角形面积程序改造成函数封装版本,并加入「三边能否构成三角形」的判断。
- 用
sizeof打印本章出现的所有基本类型在本机上的字节数,并与表格中的典型值对照。 - 用 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 三种循环,以及函数初步与多文件结构。回顾时抓住三条线索:分支决定走哪条路、循环决定重复多少次、函数决定逻辑怎么拆。
思考题
if (a = 5)与if (a == 5)有什么区别?为什么前者几乎总是 bug?&&和||的短路求值有什么实际用处?举一个利用短路避免空指针解引用的例子。switch的case为什么不能是变量或浮点数?漏写break会发生什么?- 头文件里为什么只放声明、不放定义?
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");
动手作业
- 编写程序,输入一个百分制成绩,用
if-else输出等级(优秀/良好/及格/不及格),再用switch实现同样的功能并比较两种写法。 - 用
while、do-while、for三种循环分别求 1 到 n 的和,比较它们的写法差异。 - 把本章的综合示例拆成
max_of、average两个函数,分别放进math_utils.c与math_utils.h,在main.c中调用,用 GCC 分步编译链接。 - 用
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)等价。
练习题:
- 编写函数求一维数组的最大值、最小值与平均值。
- 实现数组逆序:原地交换首尾元素,不使用额外数组。
- 编写函数判断一个 3×3 二维数组是否为主对角线对称。
- 用指针遍历二维数组,输出所有元素之和。
- 思考题:为什么
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 *是泛型指针,不能直接解引用,必须先转换类型。- 空指针、野指针、失效指针都必须避免解引用。
练习题:
- 编写函数
void reverse(int *a, int n),用指针原地逆序数组。 - 用二级指针实现一个函数,动态分配并初始化一个长度为 n 的整型数组。
- 用函数指针实现一个简易计算器,支持加减乘除四种运算。
- 分析
int *const p与const int *p的区别,并各写一个示例。 - 思考题:为什么
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。
练习题:
- 不调用库函数,自己实现
strlen、strcpy、strcmp三个函数。 - 用
strtok统计一段文本中单词的个数。 - 用
memmove实现数组元素的循环右移。 - 用
strtol实现一个安全的字符串转整数函数,非法输入返回错误码。 - 思考题:为什么
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修饰局部变量延长生存期,修饰全局变量限制可见性。- 递归必须有出口,且每次规模缩小。
练习题:
- 编写函数
int max3(int a, int b, int c),返回三个数中的最大值。 - 用递归实现斐波那契数列,并分析其时间复杂度。
- 用递归实现汉诺塔,输出每一步移动。
- 用递归实现二分查找,比较与循环版本的差异。
- 思考题:为什么
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调整。 - 共用体成员共享内存,枚举定义具名整型常量。
练习题:
- 设计一个
Book结构体,包含书名、作者、价格,并编写函数按价格排序。 - 设计一个嵌套结构体
Employee,包含姓名和入职日期,输出所有员工信息。 - 用
sizeof验证不同成员顺序下结构体大小的差异,并解释原因。 - 用共用体实现一个「同一块内存按 int 或 float 解释」的小示例。
- 思考题:为什么共用体的大小等于最大成员的大小,而不是所有成员之和?
第八章:动态内存管理
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调整大小。- 常见错误:内存泄漏、重复释放、越界访问、使用已释放内存。
- 柔性数组必须是结构体最后一个成员,可一次分配变长数据。
- 二维数组可用「指针数组」或「一次分配连续内存」两种方式构造。
练习题:
- 实现一个可动态扩容的整型数组,支持
push与自动扩容。 - 用
realloc实现一个动态字符串拼接函数。 - 找出下面代码中的三处内存错误并改正(泄漏、二次释放、越界)。
- 用柔性数组实现一个变长整型缓冲区,并写出释放函数。
- 思考题:为什么
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。
练习题:
- 写一个程序,把用户输入的多行文本写入文件,再逐行读回并打印。
- 用
fwrite/fread把结构体数组写入二进制文件并读回。 - 用
fseek实现读取文件末尾 10 个字节。 - 用
ferror与perror处理打开失败与读取失败。 - 思考题:为什么二进制文件读写比文本文件更高效、精度更高?
第十章:预处理
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控制代码是否参与编译,常用于头文件守卫。
练习题:
- 用
#define实现一个求三个数最大值的宏,并说明括号的必要性。 - 用
#与##实现一个「打印变量名与值」的调试宏。 - 用
do { ... } while (0)改写一个多语句宏,验证在if后使用正确。 - 用条件编译实现一个可开关的调试日志宏。
- 思考题:为什么宏参数带副作用(如
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 定义车位数量、费率、文件名 |
如果想继续挑战,可以尝试这些扩展:
- 动态车位:用
malloc按实际需求分配车位表,支持运行时扩容(第八章)。 - 按时间排序:出场时按入场时间先后排队,用
qsort排序(第七章)。 - 文本格式存储:改用
fprintf/fscanf保存为可读文本,便于人工查看(第九章)。 - 多文件拆分:把车位管理、文件读写、菜单界面拆成多个
.c/.h文件(第二章多文件结构)。 - 统计报表:记录每日收入,用文件追加方式保存流水(第九章)。
写完整项目的关键,不在于代码有多复杂,而在于把每个知识点用在它该出现的地方。当你能独立完成这个停车场系统,再回头看前面的章节,会发现那些曾经零散的语法点,已经连成了一张可以随时调用的网。
本教程面向初学者,系统讲解C语言核心知识体系,涵盖数据类型、控制结构、数组、指针、函数、结构体、动态内存管理、文件操作及预处理等关键主题。强调三大主线:数据在内存中的存储方式、程序编译链接过程、指针对内存与代码的连接机制。内容按概念→示例→图解→练习展开,并以停车场管理系统为综合项目,整合各章知识点实现完整工程实践。
1193

被折叠的 条评论
为什么被折叠?



