首页 > 科技 > 计算机 > 编程语言

嵌入式C语言自我修养——从芯片、编译器到操作系统

作译者：王利涛

出版时间：2021-04 千字数：857 版次：01-01 页数：568

开本：16开装帧： I S B N ：9787121408564

换版：

纸质书定价：￥118.0

库存:有

分享到：

共有图书评论0条【查看评论摘要】

看了又看

{{data.bookName}}

￥{{data.price}}

内容简介

前言

上架建议

作者简介

编辑推荐

音视频专区

第1 章 工欲善其事，必先利其器 ·····································································.1
1.1 代码编辑工具：Vim ·············································································.2
1.1.1 安装Vim ·················································································.2
1.1.2 Vim 常用命令 ············································································.3
1.1.3 Vim 配置文件：vimrc ··································································.6
1.1.4 Vim 的按键映射 ·········································································.8
1.2 程序编译工具：make ···········································································.10
1.2.1 使用IDE 编译C 程序 ·································································.10
1.2.2 使用gcc 编译C 源程序 ·······························································.11
1.2.3 使用make 编译程序 ···································································.14
1.3 代码管理工具：Git ·············································································.16
1.3.1 什么是版本控制系统 ··································································.16
1.3.2 Git 的安装和配置 ······································································.18
1.3.3 Git 常用命令 ············································································.18
第2 章 计算机体系结构与CPU 工作原理 ·························································.21
2.1 一颗芯片是怎样诞生的 ········································································.22
2.1.1 从沙子到单晶硅 ········································································.22
2.1.2 PN 结的工作原理 ······································································.24
2.1.3 从PN 结到芯片电路 ···································································.26
2.1.4 芯片的封装 ··············································································.28
2.2 一颗CPU 是怎么设计出来的 ·································································.29
2.2.1 计算机理论基石：图灵机 ····························································.30
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? XIV ?
2.2.2 CPU 内部结构及工作原理 ····························································.31
2.2.3 CPU 设计流程 ··········································································.33
2.3 计算机体系结构 ·················································································.37
2.3.1 冯·诺依曼架构 ··········································································.38
2.3.2 哈弗架构 ················································································.38
2.3.3 混合架构 ················································································.38
2.4 CPU 性能提升：Cache 机制 ···································································.39
2.4.1 Cache 的工作原理 ······································································.39
2.4.2 一级Cache 和二级Cache ·····························································.41
2.4.3 为什么有些处理器没有Cache ·······················································.42
2.5 CPU 性能提升：流水线 ········································································.42
2.5.1 流水线工作原理 ········································································.43
2.5.2 超流水线技术 ···········································································.44
2.5.3 流水线冒险 ··············································································.47
2.5.4 分支预测 ················································································.49
2.5.5 乱序执行 ················································································.50
2.5.6 SIMD 和NEON ········································································.51
2.5.7 单发射和多发射 ········································································.52
2.6 多核CPU ·························································································.54
2.6.1 单核处理器的瓶颈 ·····································································.54
2.6.2 片上多核互连技术 ·····································································.55
2.6.3 big.LITTLE 结构 ·······································································.58
2.6.4 超线程技术 ··············································································.59
2.6.5 CPU 核数越多越好吗 ··································································.61
2.7 后摩尔时代：异构计算的崛起 ································································.62
2.7.1 什么是异构计算 ········································································.62
2.7.2 GPU ······················································································.63
2.7.3 DSP ·······················································································.64
2.7.4 FPGA ·····················································································.64
2.7.5 TPU ·······················································································.65
2.7.6 NPU ······················································································.67
2.7.7 后摩尔时代的XPU 们 ·································································.70
目 录
? XV ?
2.8 总线与地址 ·······················································································.71
2.8.1 地址的本质 ··············································································.72
2.8.2 总线的概念 ··············································································.73
2.8.3 总线编址方式 ···········································································.74
2.9 指令集与微架构 ·················································································.74
2.9.1 什么是指令集 ···········································································.75
2.9.2 什么是微架构 ···········································································.76
2.9.3 指令助记符：汇编语言 ·······························································.79
第3 章 ARM 体系结构与汇编语言 ··································································.81
3.1 ARM 体系结构 ··················································································.81
3.2 ARM 汇编指令 ··················································································.84
3.2.1 存储访问指令 ···········································································.85
3.2.2 数据传送指令 ···········································································.87
3.2.3 算术逻辑运算指令 ·····································································.87
3.2.4 操作数：operand2 详解 ·······························································.88
3.2.5 比较指令 ················································································.88
3.2.6 条件执行指令 ···········································································.89
3.2.7 跳转指令 ················································································.90
3.3 ARM 寻址方式 ··················································································.91
3.3.1 寄存器寻址 ··············································································.91
3.3.2 立即数寻址 ··············································································.91
3.3.3 寄存器偏移寻址 ········································································.92
3.3.4 寄存器间接寻址 ········································································.92
3.3.5 基址寻址 ················································································.92
3.3.6 多寄存器寻址 ···········································································.92
3.3.7 相对寻址 ················································································.93
3.4 ARM 伪指令 ·····················································································.94
3.4.1 LDR 伪指令 ·············································································.94
3.4.2 ADR 伪指令 ·············································································.96
3.5 ARM 汇编程序设计·············································································.97
3.5.1 ARM 汇编程序格式 ···································································.97
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? XVI ?
3.5.2 符号与标号 ··············································································.98
3.5.3 伪操作 ···················································································.99
3.6 C 语言和汇编语言混合编程 ·································································.101
3.6.1 ATPCS 规则 ···········································································.101
3.6.2 在C 程序中内嵌汇编代码 ··························································.103
3.6.3 在汇编程序中调用C 程序 ··························································.104
3.7 GNU ARM 汇编语言 ·········································································.105
3.7.1 重新认识编译器 ······································································.105
3.7.2 GNU ARM 编译器的伪操作 ························································.107
3.7.3 GNU ARM 汇编语言中的标号 ·····················································.108
3.7.4 .section 伪操作 ········································································.109
3.7.5 基本数据格式 ·········································································.110
3.7.6 数据定义 ··············································································.110
3.7.7 汇编代码分析实战 ···································································.111
第4 章 程序的编译、链接、安装和运行 ·························································.114
4.1 从源程序到二进制文件 ······································································.115
4.2 预处理过程 ·····················································································.120
4.3 程序的编译 ·····················································································.123
4.3.1 从C 文件到汇编文件 ································································.124
4.3.2 汇编过程 ··············································································.127
4.3.3 符号表与重定位表 ···································································.129
4.4 链接过程························································································.132
4.4.1 分段组装 ··············································································.132
4.4.2 符号决议 ··············································································.136
4.4.3 重定位 ·················································································.140
4.5 程序的安装 ·····················································································.142
4.5.1 程序安装的本质 ······································································.142
4.5.2 在Linux 下制作软件安装包 ························································.143
4.5.3 使用apt-get 在线安装软件 ··························································.145
4.5.4 在Windows 下制作软件安装包 ····················································.147
目 录
? XVII ?
4.6 程序的运行 ·····················································································.150
4.6.1 操作系统环境下的程序运行 ·······················································.150
4.6.2 裸机环境下的程序运行 ·····························································.153
4.6.3 程序入口main()函数分析 ···························································.154
4.6.4 BSS 段的小秘密 ······································································.157
4.7 链接静态库 ·····················································································.158
4.8 动态链接························································································.162
4.8.1 与地址无关的代码 ···································································.164
4.8.2 全局偏移表 ············································································.165
4.8.3 延迟绑定 ··············································································.166
4.8.4 共享库 ·················································································.168
4.9 插件的工作原理 ···············································································.169
4.10 Linux 内核模块运行机制 ···································································.171
4.11 Linux 内核编译和启动分析 ································································.174
4.12 U-boot 重定位分析 ··········································································.179
4.13 常用的binutils 工具集 ······································································.185
第5 章 内存堆栈管理 ·················································································.188
5.1 程序运行的“马甲”：进程 ·································································.189
5.2 Linux 环境下的内存管理 ····································································.190
5.3 栈的管理························································································.192
5.3.1 栈的初始化 ············································································.193
5.3.2 函数调用 ··············································································.195
5.3.3 参数传递 ··············································································.199
5.3.4 形参与实参 ············································································.201
5.3.5 栈与作用域 ············································································.206
5.3.6 栈溢出攻击原理 ······································································.208
5.4 堆内存管理 ·····················································································.210
5.4.1 裸机环境下的堆内存管理 ··························································.212
5.4.2 uC/OS 的堆内存管理 ································································.213
5.4.3 Linux 堆内存管理 ····································································.219
5.4.4 堆内存测试程序 ······································································.227
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? XVIII ?
5.4.5 实现自己的堆管理器 ································································.229
5.5 mmap 映射区域探秘 ··········································································.233
5.5.1 将文件映射到内存 ···································································.236
5.5.2 mmap 映射实现机制分析 ···························································.239
5.5.3 把设备映射到内存 ···································································.240
5.5.4 多进程共享动态库 ···································································.243
5.6 内存泄漏与防范 ···············································································.245
5.6.1 一个内存泄漏的例子 ································································.245
5.6.2 预防内存泄漏 ·········································································.246
5.6.3 内存泄漏检测：MTrace ·····························································.248
5.6.4 广义上的内存泄漏 ···································································.250
5.7 常见的内存错误及检测 ······································································.251
5.7.1 总有一个Bug，让你泪流满面 ·····················································.253
5.7.2 使用core dump 调试段错误 ························································.254
5.7.3 什么是内存踩踏 ······································································.256
5.7.4 内存踩踏监测：mprotect ····························································.257
5.7.5 内存检测神器：Valgrind ····························································.259
第6 章 GNU C 编译器扩展语法精讲 ·····························································.263
6.1 C 语言标准和编译器 ·········································································.264
6.1.1 什么是C 语言标准 ··································································.264
6.1.2 C 语言标准的内容 ···································································.265
6.1.3 C 语言标准的发展过程 ·····························································.265
6.1.4 编译器对C 语言标准的支持 ·······················································.268
6.1.5 编译器对C 语言标准的扩展 ·······················································.268
6.2 指定初始化 ·····················································································.269
6.2.1 指定初始化数组元素 ································································.269
6.2.2 指定初始化结构体成员 ·····························································.271
6.2.3 Linux 内核驱动注册 ·································································.271
6.2.4 指定初始化的好处 ···································································.273
6.3 宏构造“利器”：语句表达式 ······························································.273
6.3.1 表达式、语句和代码块 ·····························································.273
目 录
? XIX ?
6.3.2 语句表达式 ············································································.274
6.3.3 在宏定义中使用语句表达式 ·······················································.276
6.3.4 内核中的语句表达式 ································································.280
6.4 typeof 与container_of 宏 ·····································································.280
6.4.1 typeof 关键字 ·········································································.280
6.4.2 typeof 使用示例 ······································································.281
6.4.3 Linux 内核中的container_of 宏 ····················································.281
6.4.4 container_of 宏实现分析 ····························································.283
6.5 零长度数组 ·····················································································.286
6.5.1 什么是零长度数组 ···································································.286
6.5.2 零长度数组使用示例 ································································.288
6.5.3 内核中的零长度数组 ································································.288
6.5.4 思考：指针与零长度数组 ··························································.290
6.6 属性声明：section·············································································.292
6.6.1 GNU C 编译器扩展关键字：__attribute__ ·······································.292
6.6.2 属性声明：section ···································································.294
6.6.3 U-boot 镜像自复制分析 ·····························································.297
6.7 属性声明：aligned ············································································.299
6.7.1 地址对齐：aligned ···································································.299
6.7.2 结构体的对齐 ·········································································.302
6.7.3 思考：编译器一定会按照aligned 指定的方式对齐吗 ·························.304
6.7.4 属性声明：packed ···································································.305
6.7.5 内核中的aligned、packed 声明 ····················································.306
6.8 属性声明：format ·············································································.306
6.8.1 变参函数的格式检查 ································································.306
6.8.2 变参函数的设计与实现 ·····························································.308
6.8.3 实现自己的日志打印函数 ··························································.312
6.9 属性声明：weak ···············································································.314
6.9.1 强符号和弱符号 ······································································.314
6.9.2 函数的强符号与弱符号 ·····························································.316
6.9.3 弱符号的用途 ·········································································.317
6.9.4 属性声明：alias ······································································.319
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? XX ?
6.10 内联函数 ······················································································.320
6.10.1 属性声明：noinline ·································································.320
6.10.2 什么是内联函数 ····································································.320
6.10.3 内联函数与宏 ·······································································.321
6.10.4 编译器对内联函数的处理 ·························································.322
6.10.5 思考：内联函数为什么定义在头文件中 ········································.324
6.11 内建函数 ······················································································.324
6.11.1 什么是内建函数 ····································································.324
6.11.2 常用的内建函数 ····································································.325
6.11.3 C 标准库的内建函数 ·······························································.328
6.11.4 内建函数：__builtin_constant_p(n) ···············································.328
6.11.5 内建函数：__builtin_expect(exp,c) ···············································.329
6.11.6 Linux 内核中的likely 和unlikely ················································.330
6.12 可变参数宏 ···················································································.333
6.12.1 什么是可变参数宏 ··································································.334
6.12.2 继续改进我们的宏 ··································································.335
6.12.3 可变参数宏的另一种写法 ·························································.336
6.12.4 内核中的可变参数宏 ·······························································.336
第7 章 数据存储与指针 ··············································································.339
7.1 数据类型与存储 ···············································································.340
7.1.1 大端模式与小端模式 ································································.340
7.1.2 有符号数和无符号数 ································································.343
7.1.3 数据溢出 ··············································································.345
7.1.4 数据类型转换 ·········································································.348
7.2 数据对齐························································································.352
7.2.1 为什么要数据对齐 ···································································.352
7.2.2 结构体对齐 ············································································.353
7.2.3 联合体对齐 ············································································.356
7.3 数据的可移植性 ···············································································.358
7.4 Linux 内核中的size_t 类型 ··································································.360
7.5 为什么很多人编程时喜欢用typedef ·······················································.361
目 录
? XXI ?
7.5.1 typedef 的基本用法 ··································································.361
7.5.2 使用typedef 的优势 ··································································.364
7.5.3 使用typedef 需要注意的地方 ······················································.366
7.5.4 typedef 的作用域 ·····································································.368
7.5.5 如何避免typedef 被大量滥用 ······················································.368
7.6 枚举类型························································································.369
7.6.1 使用枚举的三种方法 ································································.370
7.6.2 枚举的本质 ············································································.370
7.6.3 Linux 内核中的枚举类型 ···························································.372
7.6.4 使用枚举需要注意的地方 ··························································.372
7.7 常量和变量 ·····················································································.373
7.7.1 变量的本质 ············································································.374
7.7.2 常量存储 ··············································································.376
7.7.3 常量折叠 ··············································································.377
7.8 从变量到指针 ··················································································.378
7.8.1 指针的本质 ············································································.379
7.8.2 一些复杂的指针声明 ································································.381
7.8.3 指针类型与运算 ······································································.383
7.9 指针与数组的“暧昧”关系 ·································································.386
7.9.1 下标运算符[] ··········································································.388
7.9.2 数组名的本质 ·········································································.389
7.9.3 指针数组与数组指针 ································································.392
7.10 指针与结构体 ················································································.395
7.11 二级指针 ······················································································.399
7.11.1 修改指针变量的值 ··································································.400
7.11.2 二维指针和指针数组 ·······························································.402
7.11.3 二级指针和二维数组 ·······························································.403
7.12 函数指针 ······················································································.407
7.13 重新认识void ················································································.408
第8 章 C 语言的面向对象编程思想 ·······························································.411
8.1 代码复用与分层思想 ·········································································.412
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? XXII ?
8.2 面向对象编程基础 ············································································.413
8.2.1 什么是OOP ···········································································.414
8.2.2 类的封装与实例化 ···································································.414
8.2.3 继承与多态 ············································································.416
8.2.4 虚函数与纯虚函数 ···································································.418
8.3 Linux 内核中的OOP 思想：封装 ··························································.419
8.3.1 类的C 语言模拟实现 ································································.420
8.3.2 链表的抽象与封装 ···································································.422
8.3.3 设备管理模型 ·········································································.423
8.3.4 总线设备模型 ·········································································.427
8.4 Linux 内核中的OOP 思想：继承 ··························································.429
8.4.1 继承与私有指针 ······································································.429
8.4.2 继承与抽象类 ·········································································.430
8.4.3 继承与接口 ············································································.431
8.5 Linux 内核中的OOP 思想：多态 ··························································.433
第9 章 C 语言的模块化编程思想 ··································································.436
9.1 模块的编译和链接 ············································································.437
9.2 系统模块划分 ··················································································.439
9.2.1 模块划分方法 ·········································································.439
9.2.2 面向对象编程的思维陷阱 ··························································.441
9.2.3 规划合理的目录结构 ································································.442
9.3 一个模块的封装 ···············································································.443
9.4 头文件深度剖析 ···············································································.444
9.4.1 基本概念 ··············································································.444
9.4.2 隐式声明 ··············································································.446
9.4.3 变量的声明与定义 ···································································.447
9.4.4 如何区分定义和声明 ································································.449
9.4.5 前向引用和前向声明 ································································.450
9.4.6 定义与声明的一致性 ································································.453
9.4.7 头文件路径 ············································································.454
9.4.8 Linux 内核中的头文件 ······························································.456
目 录
? XXIII ?
9.4.9 头文件中的内联函数 ································································.459
9.5 模块设计原则 ··················································································.459
9.6 被误解的关键字：goto ·······································································.461
9.7 模块间通信 ·····················································································.462
9.7.1 全局变量 ··············································································.462
9.7.2 回调函数 ··············································································.466
9.7.3 异步通信 ··············································································.470
9.8 模块设计进阶 ··················································································.471
9.8.1 跨平台设计 ············································································.471
9.8.2 框架 ····················································································.473
9.9 AIoT 时代的模块化编程 ·····································································.476
第10 章 C 语言的多任务编程思想和操作系统入门 ···········································.478
10.1 多任务的裸机实现 ···········································································.479
10.1.1 多任务的模拟实现 ··································································.479
10.1.2 改变任务的执行频率 ·······························································.481
10.1.3 改变任务的执行时间 ·······························································.484
10.2 操作系统基本原理 ···········································································.488
10.2.1 调度器工作原理 ····································································.490
10.2.2 函数栈与进程栈 ····································································.492
10.2.3 可重入函数 ··········································································.493
10.2.4 临界区与临界资源 ··································································.495
10.3 中断 ····························································································.497
10.3.1 中断处理流程 ·······································································.497
10.3.2 进程栈与中断栈 ····································································.500
10.3.3 中断函数的实现 ····································································.504
10.4 系统调用 ······················································································.506
10.4.1 操作系统的API ·····································································.506
10.4.2 操作系统的权限管理 ·······························································.508
10.4.3 CPU 的特权模式 ····································································.508
10.4.4 Linux 系统调用接口 ································································.509
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? XXIV ?
10.5 揭开文件系统的神秘面纱 ··································································.510
10.5.1 什么是文件系统 ····································································.511
10.5.2 文件系统的挂载 ····································································.513
10.5.3 根文件系统 ··········································································.514
10.6 存储器接口与映射 ···········································································.515
10.6.1 存储器与接口 ·······································································.515
10.6.2 存储映射 ·············································································.518
10.6.3 嵌入式启动方式 ····································································.520
10.7 内存与外部设备 ·············································································.521
10.7.1 内存与外存 ··········································································.521
10.7.2 外部设备 ·············································································.522
10.7.3 I/O 端口与I/O 内存 ································································.523
10.8 寄存器操作 ···················································································.524
10.8.1 位运算应用 ··········································································.524
10.8.2 操作寄存器 ··········································································.527
10.8.3 位域 ···················································································.529
10.9 内存管理单元MMU ········································································.531
10.9.1 地址转换 ·············································································.532
10.9.2 权限管理 ·············································································.534
10.10 进程、线程和协程 ·········································································.535
10.10.1 进程 ·················································································.536
10.10.2 线程 ·················································································.538
10.10.3 线程池 ··············································································.539
10.10.4 协程 ·················································································.540
10.10.5 小结 ·················································································.541
参考文献 ···································································································.543

前 言
C 语言是很多人学习编程的第一门语言。很多初学者在学习过程中，往往会产生各种各样
的疑惑：C 语言黑屏白字，窗口界面看起来甚至还有点丑陋，现在学这个还有用吗？能编写一
个好玩的App 吗？能写爬虫吗？能搭建一个电商网站吗？光靠C 语言能找到一份月薪过万的工
作吗？现在互联网和人工智能这么火，大家都在学习Java、Python、Ruby……都2021 年了，C
语言是不是已经过时了？
C 语言已经过时了吗
C 语言并没有过时。自C 语言问世几十年来，其实一直都是使用最广泛的编程语言之一，
多年来一直低调地霸占着编程语言的“琅琊榜”，目前还没有看到衰退和被替代的迹象。只不
过在Android、移动互联网火了之后，Java 暂时抢了风头而已，把C 语言从编程语言排行榜上
挤到了第二的位置。沧海桑田，时过境迁，很多编程语言如过江之鲫，风云变幻，但C 语言依
然宝刀未老，在编程语言排行榜上从未跌出过前三，这也从侧面说明了C 语言一直都是被广泛
使用的编程语言。既然C 语言被广泛使用，那么主要应用在哪些领域呢？可以这么说，基本上
在每个领域都可以看到C 语言的身影。
? 应用软件：Linux/UNIX 环境下的工具、应用程序。
? 系统软件：操作系统、编译器、数据库、图形处理、虚拟机、多媒体库等。
? 嵌入式开发：各种RTOS、BSP、固件、驱动、API 库。
? 嵌入式、工业控制、物联网、消费电子、科研领域、数值计算。
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? IV ?
? 实现其他编程/脚本语言：Lua、Python、Shell。
? 网站服务器底层、游戏、各种应用框架。
C 语言是一门高级语言。C 语言有高级语言的各种语法和特性，我们使用C 语言可以构建
大型的软件工程。有人说，C 语言小打小闹，上不了大台面，编写不了大型的项目，这个说法
其实也是站不住脚的：很多大型的GNU 开源项目，其实都是使用C 语言开发的，如Lua 脚本
语言、SQLite、Nginx、UNIX 等。现在市面上几乎所有的操作系统都是使用C 语言开发的，如
Linux 内核、uC/OS、VxWorks、FreeRTOS。目前最新的Linux-5.x 内核代码已多达2000 万行，
3 万多个源文件，这个项目应该不算小了吧！
C 语言也是一门低级语言。通过指针和位运算，我们可以修改内存和寄存器，从而直接控
制CPU 和硬件电路的运行。正是由于这种低级特性，很多操作系统内核、驱动都选择使用C
语言进行开发。尤其在嵌入式开发领域，C 语言被广泛使用，C 语言是嵌入式工程师必须熟练
掌握，甚至需要精通的一门编程语言。
C 语言到底要学到什么程度
学习C 语言到底要学到什么程度，才能达到面试的要求，才能胜任一份嵌入式开发的工作
呢？这是很多嵌入式初学者很关心的问题。
一般来讲，不同的行业领域、不同的C 语言开发岗位、不同的学习目的，对C 语言的要求
也不一样。如图0-1 所示，如果你是在校学生，学习C 语言仅仅是为了应付期末考试、过计算
机二级考试、考证，那么你只要把C 语言的基本语法掌握好，基本上就可以轻松过关，稍微用
心点，说不定还能拿个优秀。如果你想做C 语言桌面软件、网站服务器开发，那么你不仅要学
习C 语言的基本语法，还要对特定行业领域的专业知识、软件工程、项目管理等有所涉猎。这
可不像过计算机二级考试那么简单。计算机二级考试其实压根就不是为程序员准备的，它是非
计算机专业学生的终极目标，而对于一个立志从事软件开发的工程师来说，它仅仅是一个起点。
如果你想以后从事嵌入式开发、Linux 内核驱动开发等工作，那么对C 语言的要求就更高了：
你不仅要掌握C 语言的基本语法、项目管理、软件工程，还要对硬件电路、CPU、操作系统、
编译原理等底层机制有完整的了解，需要对C 语言进行进一步的强化学习和编程训练。
前 言
? V ?
图0-1 C 语言各种开发岗位和学习需求
使用C 语言编程就像写小说一样：为什么你掌握了3000 个常用的英文单词、八大时态、
各种从句语法，还是写不出《哈姆雷特》《冰与火之歌》呢？道理其实很简单，单词和语法只是
基础中的基础，只是工具而已。要想写出优秀的小说，还需要对一门语言背后的社会背景、历
史文化、思维逻辑、风土人情等有深入的理解和把握才行。
测一测你的C 语言水平
为了达到更好的学习效果，下面特意列出了一些问题，用来测评你真实的C 语言水平。
C 语言测试（1）：基本概念考查
? 什么是标识符、关键字和预定义标识符？三者有何区别？
? 在C 程序编译过程中，什么是语法检查、语义检查？两者有何区别？
? 什么是表达式？什么是语句？什么是代码块？
? 什么是左值、右值、对象、副作用、未定义行为？
? 什么是结合性、左结合、右结合？
C 语言测试（2）：一个sizeof (int)引发的思考
? sizeof 是函数，是关键字，还是预定义标识符？
? 在32 位和64 位的Windows 7 环境下运行，结果分别是多少？
? 在32 位和64 位的X86 CPU 平台下运行，结果分别是多少？
? 在8 位、16 位、32 位的单片机环境下运行，结果分别是多少？
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? VI ?
? 在32 位ARM 和64 位ARM 下运行，结果分别是多少？
? 分别在VC++ 6.0、Turbo C、Keil、32 位/64 位GCC 编译器下编译、运行，结果一样吗？
? 使用32 位GCC 编译器编译生成32 位可执行文件，运行在64 位环境下，结果如何？
? 使用64 位GCC 编译器编译生成64 位可执行文件，运行在32 位环境下，结果如何？
C 语言测试（3）：自增运算符
使用不同的编译器编译、运行下面的程序代码，结果分别是多少？结果是否一定相同？为
什么？
#include ＜stdio.h＞
int main(void)
{
int i = 1;
int j = 2;
printf("%dn", i++*i++);
printf("%dn", i+++j);
return 0;
}
C 语言测试（4）：程序代码分析
#include ＜stdio.h＞
int main(void)
{
int i;
int a[0];
printf("hello world!n");
int j;
for(int k=0; k＜10; k++);
return 0;
}
阅读上面的程序代码，然后进行如下操作，观察运行结果并分析。
? 分别使用C-Free、GCC、VC++ 6.0、Visual Studio 编译、运行代码，运行结果一定相
同吗？会出现什么问题？为什么？
? 在VC++ 6.0 环境下，新建console 工程，将上面的程序代码分别保存为.cpp 和.c 文件
并编译、运行，运行结果会如何？为什么？
前 言
? VII ?
C 语言测试（5）：程序运行内存分析
在32 位Linux 下，编写一个数据复制函数，在实际运行中会出现什么问题？
int *data_copy(int *p)
{
int buffer[8192*1024];
memcpy(buffer, p, 8192*1024);
return buffer;
}
C 语言测试（6）：程序改错题
在嵌入式ARM 裸机平台上，实现一个MP3 播放器，要求实现如下功能：当不同的控制按
键被按下时，播放器可以播放、暂停、播放上一首歌曲、播放下一首歌曲。为了实现这些功能，
我们设计了一个按键中断处理函数：当有按键被按下时，会产生一个中断，我们在按键中断处
理函数中读取按键的值，并根据按键的值执行不同的操作。下面设计的按键中断处理函数中有
很多不合理之处，请找出6 处以上。
int keyboard_isr(int irq_num)
{
char *buf =(char *)malloc(512);
int key_value = 0,
key_value = keyboard_scan();
if(key_value == 1)
{
mp3_decode(buf,"xx.mp3");
sleep(10);
mp3_play(buf); //播放
}
else if(key_value == 2)
mp3_pause(buf); //暂停
else if(key_value == 3)
mp3_next(buf); //播放下一首歌曲
else if(key_value == 4)
mp3_prev(buf); //播放上一首歌曲
else
{
printf("UND key !");
return -1;
}
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? VIII ?
return 0;
}
C 语言测试（7）：Linux 内核代码分析
在Linux 内核源码中存在着各种各样、稀奇古怪的C 语言语法，试分析下面代码中宏定义、
零长度数组、位运算、结构体变量初始化的作用。
#define stamp(fmt, args...) pr_debug("%s:%i: " fmt "n", __func__, __LINE__, ## args)
#define pr_debug(fmt, ...) __pr(__pr_debug, fmt, ##__VA_ARGS__)
#define container_of(ptr, type, member) ({ const typeof(((type *)0)-＞member) * __mptr = (ptr); (type *)((char *)__mptr - offsetof(type, member)); })
#define likely(x) __builtin_expect(!!(x),1)
#define unlikely(x) __builtin_expect(!!(x),0)
struct urb
{
struct kref kref;
struct usb_iso_packet_descriptor iso_frame_desc[0];
}
flags ＆= ~(URB_DIR_MASK | URB_DMA_MAP_SINGLE | URB_DMA_MAP_PAGE );
static struct usb_driver i2400mu_driver = {
.name = KBUILD_MODNAME,
.suspend = i2400mu_suspend,
.resume = i2400mu_resume,
.supports_autosuspend = 1,
};
C 语言测试（8）：Linux 内核代码赏析
在Linux 内核源码中，我们经常可以看到下面的代码风格，试分析它们的意义。
extern void usage(const char *err) NORETURN;
extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
static inline __attribute__((noinline)) int func();
static inline __attribute__((always_inline)) int func();
前 言
? IX ?
#define ftrace_vprintk(fmt, vargs) do { if (__builtin_constant_p(fmt)) { static const char *trace_printk_fmt __used __attribute__((section("__trace_printk_fmt"))) = __builtin_constant_p(fmt) ? fmt : NULL; __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs); } else __ftrace_vprintk(_THIS_IP_, fmt, vargs); } while (0)
你要学习的，不仅仅是C 语言……
对于上面的几个C 语言测试，如果你已经知道了答案，并且知道其要考查的是什么知识点，
恭喜你，你对C 语言及计算机体系结构的知识已经很熟悉了。如果回答得不是很好，偷偷用百
度也没有搜到理想的答案，也不用气馁，因为这次测试要考查的内容其实已经不仅仅是C 语言
的知识了，而是和嵌入式C 语言开发相关的一些理论知识，如处理器架构、操作系统、编译原
理、编译器特性、内存堆栈管理、Linux 内核中的GNU C 扩展语法等。
当然，上面的测试也不是为了故意扎你心或者卖关子，让你赶紧掏腰包买下这本书，而是
想要传递一个信息：要想从事嵌入式开发工作，尤其是嵌入式Linux 内核驱动开发工作，你要
精通的不仅仅是C 语言，最好还要掌握和C 语言相关的一系列基础理论和调试技能。笔者也是
过来人，从最初学习嵌入式到从事嵌入式开发工作，这一路走来坎坷崎岖，什么都不说了，说
多了都是泪。从一开始连指针都不会用、不敢用，看内核驱动代码一头雾水，越看越没底、越
看越没自信，到现在不再犯怵，有自信和能力看懂内核中的代码细节和系统框架，这种进步不
是天上掉下来的，也不是一不小心跌入山洞，捡到武功秘籍练出来的，而是不断地学习和实践、
反复迭代、不断完善自己的知识体系和技能树，才慢慢达到的。学习没有捷径可走，要想真正
学好嵌入式、精通嵌入式，个人觉得除了精通C 语言，最好还要具备以下完整的知识体系和编
程技能。
? 半导体基础、CPU 工作原理、硬件电路、计算机系统结构。
? ARM 体系结构与汇编指令、汇编程序设计、ARM 反汇编分析。
? 程序的编译、链接、安装、运行和重定位分析。
? 熟悉C 语言标准、ARM、GNU 编译器的特性和扩展语法。
? C 语言的模块化编程思想，学会使用模块化思想去分析复杂的系统。
? C 语言的面向对象编程（简称OOP）思想，学会使用OOP 思想去分析Linux 内核驱动。
嵌入式C 语言自我修养——从芯片、编译器到操作系统
? X ?
? 对指针的深刻理解，对复杂指针的声明和灵活应用。
? 对内存堆栈管理、内存泄漏、栈溢出、段错误的深刻理解。
? 多任务并发编程思想，CPU 和操作系统基础理论。
本书内容及写作初衷
本书从C 语言的角度出发，分10 章，在默认读者已经掌握C 语言基本语法的基础上，和
大家一起探讨、学习C 语言背后的CPU 工作原理、计算机体系结构、ARM 平台下程序的编译/
链接、程序运行时的内存堆栈管理等底层知识。同时，针对嵌入式开发领域，用3 章分别探讨
了C 语言的面向对象编程思想、模块化编程思想和多任务编程思想，这些底层知识和编程思想
构成了嵌入式开发所需要的通用理论基础和核心技能。尤其是对于很多从不同专业转行到嵌入
式开发的朋友，由于专业背景的差异，导致每个人的知识储备和编程技能树参差不齐，在学习
嵌入式开发的过程中会经常遇到各种各样的问题，陷入学习的困境。
本书的写作初衷就是为不同专业背景的读者搭建嵌入式开发所需要的完整知识体系和认知
框架。掌握了这些基础理论和编程技能，也就补齐了短板，可为后续的嵌入式开发进阶学习打
下坚实的基础。
本书特色
? 大白话写作风格，通俗易懂，不怕学不会，就怕你不学。
? 大量的配图、原理图，图文并茂，更加有利于学习和理解。
? 在ARM 平台下讲解程序的编译、链接和运行原理（独创）。
? 现场“手撕”ARM 汇编代码，从反汇编角度剖析C 函数调用、传参过程。
? 多角度剖析C 语言：CPU、计算机体系结构、编译器、操作系统、软件工程。
? GNU C 编译器扩展语法精讲（在GNU 开源软件、Linux 内核中大量使用）。
? 内存堆栈管理机制的底层剖析，从根源上理解内存错误。
? 从零开始一步一步搭建和迭代嵌入式软件框架。
? 教你用OOP 思想分析Linux 内核中复杂的驱动和子系统。
? C 语言的多任务并发编程思想，CPU 和操作系统零基础入门。
读者定位
本书针对的是嵌入式开发，尤其是嵌入式Linux 开发背景下的C 语言进阶学习，比较适合
在校学生、嵌入式学员、工作1~3 年的职场新兵阅读和学习。为了达到更好的学习效果，在阅
前 言
? XI ?
读本书之前，首先要确保你已经掌握了C 语言的基本语法，并且至少使用过一款C 语言集成开
发环境（VC++ 6.0、Visual Studio、C-Free、GCC 都可以），开发过一个完整的C 语言项目（课
程设计也算）。有了这些基础和编程经验之后，学习效果会更好。
致谢及意见反馈
本书在写作过程中参考了很多经典图书、论文期刊、开源代码，包括互联网上的很多电子
资料，由于时间和精力的关系，无法对这些资料的最初出处一一溯本求源，对各种资料的创建
者和分享者不能一一列举。这里对他们的贡献表示真诚的感谢。
感谢电子工业出版社的董英和李秀梅编辑，本书从选题的论证到书稿的格式审核、文字编
辑，她们都付出了辛苦的劳动并提出了很多专业意见。鉴于作者水平、时间和精力有限，书中
难免出现一些错误。如果你在阅读过程中发现了错误或者需要改进的地方，欢迎和我联系
（E-mail：3284757626@qq.com），或者在我的个人博客（www.zhaixue.cc）上留言，或者扫码
关注微信公众号“宅学部落”。

查看更多 > 图书评论

暂无评论

发表图书评论

评论标题：
评论内容：
验证码：: 看不清楚
点击刷新
: 您还没有登录，请登录后再评论。
点击“登录”

购买过本书的顾客还买过

{{data.bookName}}

￥{{data.price}}