Linux系统编程

作者简介

12.9.4 更多

12.9.3 它是如何工作的

12.9.2 实践步骤

12.9.1 准备工作

12.9 使用Valgrind找到缓冲区溢出

12.8.4 参考

12.8.3 它是如何工作的

12.8.2 实践步骤

12.8.1 准备工作

12.8 使用Valgrind找到一个简单的内存泄漏

12.7.5 参考

12.7.4 更多

12.7.3 它是如何工作的

12.7.2 实践步骤

12.7.1 准备工作

12.7 在多线程中调试程序

12.6.4 更多

12.6.3 它是如何工作的

12.6.2 实践步骤

12.6.1 准备工作

12.6 在新创建的程序中使用GDB

12.5.3 它是如何工作的

12.5.2 实践步骤

12.5.1 准备工作

12.5 在运行期间修改变量

12.4.5 参考

12.4.4 更多

12.4.3 它是如何工作的

12.4.2 实践步骤

12.4.1 准备工作

12.4 使用GDB观察内存

12.3.3 它是如何工作的

12.3.2 实践步骤

12.3.1 准备工作

12.3 使用GDB进入函数内部

12.2.4 更多

12.2.3 它是如何工作的

12.2.2 实践步骤

12.2.1 准备工作

12.2 开始GDB

12.1 技术要求

第12章 调试程序

11.7.4 参考

11.7.3 它是如何工作的

11.7.2 实践步骤

11.7.1 准备工作

11.7 使用条件变量

11.6.3 它是如何工作的

11.6.2 实践步骤

11.6.1 准备工作

11.6 更有效的互斥锁编程

11.5.4 参考

11.5.3 它是如何工作的

11.5.2 实践步骤

11.5.1 准备工作

11.5 使用互斥锁来防止竞态条件

11.4.3 它是如何工作的

11.4.2 实践步骤

11.4.1 准备工作

11.4 触发竞态条件

11.3.3 它是如何工作的

11.3.2 实践步骤

11.3.1 准备工作

11.3 从线程中读取返回值

11.2.5 参考

11.2.4 更多

11.2.3 它是如何工作的

11.2.2 实践步骤

11.2.1 准备工作

11.2 编写第一个线程化程序

11.1 技术要求

第11章 在程序中使用线程

10.12.4 参考

10.12.3 它是如何工作的

10.12.2 实践步骤

10.12.1 准备工作

10.12 UNIX套接字编程——构建接收者

10.11.4 参考

10.11.3 它是如何工作的

10.11.2 实践步骤

10.11.1 准备工作

10.11 UNIX套接字编程——构建发送者

10.10.4 参考

10.10.3 它是如何工作的

10.10.2 实践步骤

10.10.1 准备工作

10.10 在不相关的进程中使用共享内存

10.9.4 参考

10.9.3 它是如何工作的

10.9.2 实践步骤

10.9.1 准备工作

10.9 在父子进程间使用共享内存通信

10.8.4 参考

10.8.3 它是如何工作的

10.8.2 实践步骤

10.8.1 准备工作

10.8 消息队列——构建接收者

10.7.4 参考

10.7.3 它是如何工作的

10.7.2 实践步骤

10.7.1 准备工作

10.7 消息队列——构建发送者

10.6.4 参考

10.6.3 它是如何工作的

10.6.2 实践步骤

10.6.1 准备工作

10.6 FIFO——构建接收者

10.5.4 参考

10.5.3 它是如何工作的

10.5.2 实践步骤

10.5.1 准备工作

10.5 FIFO——构建发送者

10.4.5 参考

10.4.4 更多

10.4.3 它是如何工作的

10.4.2 实践步骤

10.4.1 准备工作

10.4 FIFO——在shell中使用它

10.3.4 参考

10.3.3 它是如何工作的

10.3.2 实践步骤

10.3.1 准备工作

10.3 使用管道通信

10.2.4 参考

10.2.3 它是如何工作的

10.2.2 实践步骤

10.2.1 准备工作

10.2 使用IPC信号——为守护进程构建客户端

10.1 技术要求

第10章 使用不同类型的IPC

9.8.5 参考

9.8.4 更多

9.8.3 它是如何工作的

9.8.2 实践步骤

9.8.1 准备工作

9.8 读取终端的大小

9.7.4 更多

9.7.3 它是如何工作的

9.7.2 实践步骤

9.7.1 准备工作

9.7 关闭密码提示回显

9.6.4 参考

9.6.3 它是如何工作的

9.6.2 实践步骤

9.6.1 准备工作

9.6 创建一个PTY

9.5.4 参考

9.5.3 它是如何工作的

9.5.2 实践步骤

9.5.1 准备工作

9.5 检查是否是TTY设备

9.4.4 参考

9.4.3 更多

9.4.2 它是如何工作的

9.4.1 实践步骤

9.4 调查TTY和PTY设备，并向它们写入数据

9.3.3 它是如何工作的

9.3.2 实践步骤

9.3.1 准备工作

9.3 使用stty改变终端的设置

9.2.4 参考

9.2.3 它是如何工作的

9.2.2 实践步骤

9.2.1 准备工作

9.2 查看终端信息

9.1 技术要求

第9章 终端I/O及改变终端行为

8.8.3 它是如何工作的

8.8.2 实践步骤

8.8.1 准备工作

8.8 编译静态链接程序

8.7.5 参考

8.7.4 更多

8.7.3 它是如何工作的

8.7.2 实践步骤

8.7.1 准备工作

8.7 在程序中使用动态库

8.6.3 它是如何工作的

8.6.2 实践步骤

8.6.1 准备工作

8.6 在系统上安装动态库

8.5.5 参考

8.5.4 更多

8.5.3 它是如何工作的

8.5.2 实践步骤

8.5.1 准备工作

8.5 创建动态库

8.4.3 它是如何工作的

8.4.2 实践步骤

8.4.1 准备工作

8.4 使用静态库

8.3.4 参考

8.3.3 它是如何工作的

8.3.2 实践步骤

8.3.1 准备工作

8.3 创建静态库

8.2.4 更多

8.2.3 它是如何工作的

8.2.2 实践步骤

8.2.1 准备工作

8.2 库及其重要性

8.1 技术要求

第8章 创建共享库

7.7.4 参考

7.7.3 它是如何工作的

7.7.2 实践步骤

7.7.1 准备工作

7.7 查阅日志

7.6.3 它是如何工作的

7.6.2 实践步骤

7.6.1 准备工作

7.6 使新的守护进程成为systemd服务

7.5.4 参考

7.5.3 它是如何工作的

7.5.2 实践步骤

7.5.1 准备工作

7.5 为systemd创建现代守护进程

7.4.3 它是如何工作的

7.4.2 实践步骤

7.4.1 准备工作

7.4 启用和禁用服务，以及启动和停止服务

7.3.5 参考

7.3.4 更多

7.3.3 它是如何工作的

7.3.2 实践步骤

7.3.1 准备工作

7.3 为守护进程编写单元文件

7.2.5 参考

7.2.4 更多

7.2.3 它是如何工作的

7.2.2 实践步骤

7.2.1 准备工作

7.2 了解systemd

7.1 技术要求

第7章 使用systemd处理守护进程

6.12.4 更多

6.12.3 它是如何工作的

6.12.2 实践步骤

6.12.1 准备工作

6.12 实现信号处理程序

6.11.4 更多

6.11.3 它是如何工作的

6.11.2 实践步骤

6.11.1 准备工作

6.11 创建守护进程

6.10.4 参考

6.10.3 它是如何工作的

6.10.2 实践步骤

6.10.1 准备工作

6.10 了解孤儿进程

6.9.4 更多

6.9.3 它是如何工作的

6.9.2 实践步骤

6.9.1 准备工作

6.9 创建僵尸进程

6.8.3 它是如何工作的

6.8.2 实践步骤

6.8.1 准备工作

6.8 使用system()启动一个新进程

6.7.3 它是如何工作的

6.7.2 实践步骤

6.7.1 准备工作

6.7 在创建的进程中执行新程序

6.6.4 更多

6.6.3 它是如何工作的

6.6.2 实践步骤

6.6.1 准备工作

6.6 创建新进程

6.5.4 参考

6.5.3 它是如何工作的

6.5.2 实践步骤

6.5.1 准备工作

6.5 在进程中使用execl()替换运行的程序

6.4.4 参考

6.4.3 它是如何工作的

6.4.2 实践步骤

6.4.1 准备工作

6.4 使用信号控制和终止进程

6.3.3 它是如何工作的

6.3.2 实践步骤

6.3.1 准备工作

6.3 在Bash中使用作业控制

6.2.4 更多

6.2.3 它是如何工作的

6.2.2 实践步骤

6.2.1 准备工作

6.2 探索如何创建进程

6.1 技术要求

第6章 创建进程和使用作业控制

5.14.4 更多

5.14.3 它是如何工作的

5.14.2 实践步骤

5.14.1 准备工作

5.14 使用fseek()在文件中移动

5.13.3 它是如何工作的

5.13.2 实践步骤

5.13.1 准备工作

5.13 使用lseek()在文件中移动

5.12.4 更多

5.12.3 它是如何工作的

5.12.2 实践步骤

5.12.1 准备工作

5.12 使用流读写二进制数据

5.11.4 更多

5.11.3 它是如何工作的

5.11.2 实践步骤

5.11.1 准备工作

5.11 使用流读取文件

5.10.4 参考

5.10.3 它是如何工作的

5.10.2 实践步骤

5.10.1 准备工作

5.10 使用流写入文件

5.9.4 更多

5.9.3 它是如何工作的

5.9.2 实践步骤

5.9.1 准备工作

5.9 使用文件描述符读取文件

5.8.4 更多

5.8.3 它是如何工作的

5.8.2 实践步骤

5.8.1 准备工作

5.8 使用文件描述符写入文件

5.7.4 更多

5.7.3 它是如何工作的

5.7.2 实践步骤

5.7.1 准备工作

5.7 设置访问权限和所有权

5.6.3 它是如何工作的

5.6.2 实践步骤

5.6.1 准备工作

5.6 获得访问权限和所有权

5.5.3 它是如何工作的

5.5.2 实践步骤

5.5.1 准备工作

5.5 删除文件

5.4.4 更多

5.4.3 它是如何工作的

5.4.2 实践步骤

5.4.1 准备工作

5.4 创建文件并更新时间戳

5.3.4 更多

5.3.3 它是如何工作的

5.3.2 实践步骤

5.3.1 准备工作

5.3 创建软链接和硬链接

5.2.3 它是如何工作的

5.2.2 实践步骤

5.2.1 准备工作

5.2 读取索引节点信息并学习文件系统

5.1 技术要求

第5章 使用文件I/O和文件系统操作

4.8.4 更多

4.8.3 它是如何工作的

4.8.2 实践步骤

4.8.1 准备工作

4.8 返回错误值

4.7.3 更多

4.7.2 实践步骤

4.7.1 准备工作

4.7 使用errno和perror()

4.6.3 更多

4.6.2 实践步骤

4.6.1 准备工作

4.6 使用errno和strerror()

4.5.4 更多

4.5.3 它是如何工作的

4.5.2 实践步骤

4.5.1 准备工作

4.5 处理更多errno宏

4.4.3 它是如何工作的

4.4.2 实践步骤

4.4.1 准备工作

4.4 错误处理和errno

4.3.3 它是如何工作的

4.3.2 实践步骤

4.3.1 准备工作

4.3 处理常见的错误

4.2.3 它是如何工作的

4.2.2 实践步骤

4.2.1 准备工作

4.2 为什么错误处理在系统编程中很重要

4.1 技术要求

第4章 处理程序中的错误

3.11.3 它是如何工作的

3.11.2 实践步骤

3.11.1 准备工作

3.11 编写一个更高级的Makefile

3.10.3 它是如何工作的

3.10.2 实践步骤

3.10.1 准备工作

3.10 编写一个简单的Make file

3.9.4 更多

3.9.3 它是如何工作的

3.9.2 实践步骤

3.9.1 准备工作

3.9 使用GCC选项编写一个通用的Makefile

3.8.3 它是如何工作的

3.8.2 实践步骤

3.8.1 准备工作

3.8 使用Make编译

3.7.3 它是如何工作的

3.7.2 实践步骤

3.7.1 准备工作

3.7 编译过程的4个步骤

3.6.4 更多

3.6.3 它是如何工作的

3.6.2 实践步骤

3.6.1 准备工作

3.6 定义功能测试宏

3.5.4 更多

3.5.3 它是如何工作的

3.5.2 实践步骤

3.5.1 准备工作

3.5 获取Linux和类UNIX头文件信息

3.4.4 更多

3.4.3 它是如何工作的

3.4.2 实践步骤

3.4.1 准备工作

3.4 使用系统调用

3.3.4 更多

3.3.3 它是如何工作的

3.3.2 实践步骤

3.3.1 准备工作

3.3 切换C标准

3.2.4 更多

3.2.3 它是如何工作的

3.2.2 实践步骤

3.2.1 准备工作

3.2 使用GNU编译器套件链接库

3.1 技术要求

第3章 深入探索Linux中的C语言

2.10.4 更多

2.10.3 它是如何工作的

2.10.2 实践步骤

2.10.1 准备工作

2.10 读取环境变量

2.9.4 更多

2.9.3 它是如何工作的

2.9.2 实践步骤

2.9.1 准备工作

2.9 将结果重定向到文件

2.8.4 更多

2.8.3 它是如何工作的

2.8.2 实践步骤

2.8.1 准备工作

2.8 编写一个管道友好的程序

2.7.4 更多

2.7.3 它是如何工作的

2.7.2 实践步骤

2.7.1 准备工作

2.7 从标准输入读取

2.6.3 更多

2.6.2 它是如何工作的

2.6.1 实践步骤

2.6 写入标准输出和标准错误

2.5.5 参考

2.5.4 更多

2.5.3 它是如何工作的

2.5.2 实践步骤

2.5.1 准备工作

2.5 使用管道连接程序

2.4.4 更多

2.4.3 它是如何工作的

2.4.2 实践步骤

2.4.1 准备工作

2.4 重定向标准输入、标准输出和标准错误

2.3.4 更多

2.3.3 它是如何工作的

2.3.2 实践步骤

2.3.1 准备工作

2.3 使用有意义的返回值退出程序

2.2.5 参考

2.2.4 更多

2.2.3 它是如何工作的

2.2.2 实践步骤

2.2.1 准备工作

2.2 返回值以及如何读取它们

2.1 技术要求

第2章 使你的程序易于脚本化

1.7.4 更多

1.7.3 它是如何工作的

1.7.2 实践步骤

1.7.1 准备工作

1.7 搜索手册以获取信息

1.6.4 更多

1.6.3 它是如何工作的

1.6.2 实践步骤

1.6.1 准备工作

1.6 在内置手册页中查找信息

1.5.3 它是如何工作的

1.5.2 实践步骤

1.5.1 准备工作

1.5 编写一个解析命令行选项的程序

1.4.4 更多

1.4.3 它是如何工作的

1.4.2 实践步骤

1.4.1 准备工作

1.4 在Linux中编写一个简单的C程序

1.3.3 它是如何工作的

1.3.2 实践步骤

1.3.1 准备工作

1.3 安装GDB和Valgrind

1.2.3 它是如何工作的

1.2.2 实践步骤

1.2.1 准备工作

1.2 安装GCC和GNU Make

1.1 技术要求

第1章 获取必要的工具并编写第一个Linux程序

关于审校者

关于作者

前言

译者序

内容简介

版权信息

封面

封面

版权信息

内容简介

译者序

前言

关于作者

关于审校者

第1章 获取必要的工具并编写第一个Linux程序

1.1 技术要求

1.2 安装GCC和GNU Make

1.2.1 准备工作

1.2.2 实践步骤

1.2.3 它是如何工作的

1.3 安装GDB和Valgrind

1.3.1 准备工作

1.3.2 实践步骤

1.3.3 它是如何工作的

1.4 在Linux中编写一个简单的C程序

1.4.1 准备工作

1.4.2 实践步骤

1.4.3 它是如何工作的

1.4.4 更多

1.5 编写一个解析命令行选项的程序

1.5.1 准备工作

1.5.2 实践步骤

1.5.3 它是如何工作的

1.6 在内置手册页中查找信息

1.6.1 准备工作

1.6.2 实践步骤

1.6.3 它是如何工作的

1.6.4 更多

1.7 搜索手册以获取信息

1.7.1 准备工作

1.7.2 实践步骤

1.7.3 它是如何工作的

1.7.4 更多

第2章 使你的程序易于脚本化

2.1 技术要求

2.2 返回值以及如何读取它们

2.2.1 准备工作

2.2.2 实践步骤

2.2.3 它是如何工作的

2.2.4 更多

2.2.5 参考

2.3 使用有意义的返回值退出程序

2.3.1 准备工作

2.3.2 实践步骤

2.3.3 它是如何工作的

2.3.4 更多

2.4 重定向标准输入、标准输出和标准错误

2.4.1 准备工作

2.4.2 实践步骤

2.4.3 它是如何工作的

2.4.4 更多

2.5 使用管道连接程序

2.5.1 准备工作

2.5.2 实践步骤

2.5.3 它是如何工作的

2.5.4 更多

2.5.5 参考

2.6 写入标准输出和标准错误

2.6.1 实践步骤

2.6.2 它是如何工作的

2.6.3 更多

2.7 从标准输入读取

2.7.1 准备工作

2.7.2 实践步骤

2.7.3 它是如何工作的

2.7.4 更多

2.8 编写一个管道友好的程序

2.8.1 准备工作

2.8.2 实践步骤

2.8.3 它是如何工作的

2.8.4 更多

2.9 将结果重定向到文件

2.9.1 准备工作

2.9.2 实践步骤

2.9.3 它是如何工作的

2.9.4 更多

2.10 读取环境变量

2.10.1 准备工作

2.10.2 实践步骤

2.10.3 它是如何工作的

2.10.4 更多

第3章 深入探索Linux中的C语言

3.1 技术要求

3.2 使用GNU编译器套件链接库

3.2.1 准备工作

3.2.2 实践步骤

3.2.3 它是如何工作的

3.2.4 更多

3.3 切换C标准

3.3.1 准备工作

3.3.2 实践步骤

3.3.3 它是如何工作的

3.3.4 更多

3.4 使用系统调用

3.4.1 准备工作

3.4.2 实践步骤

3.4.3 它是如何工作的

3.4.4 更多

3.5 获取Linux和类UNIX头文件信息

3.5.1 准备工作

3.5.2 实践步骤

3.5.3 它是如何工作的

3.5.4 更多

3.6 定义功能测试宏

3.6.1 准备工作

3.6.2 实践步骤

3.6.3 它是如何工作的

3.6.4 更多

3.7 编译过程的4个步骤

3.7.1 准备工作

3.7.2 实践步骤

3.7.3 它是如何工作的

3.8 使用Make编译

3.8.1 准备工作

3.8.2 实践步骤

3.8.3 它是如何工作的

3.9 使用GCC选项编写一个通用的Makefile

3.9.1 准备工作

3.9.2 实践步骤

3.9.3 它是如何工作的

3.9.4 更多

3.10 编写一个简单的Make file

3.10.1 准备工作

3.10.2 实践步骤

3.10.3 它是如何工作的

3.11 编写一个更高级的Makefile

3.11.1 准备工作

3.11.2 实践步骤

3.11.3 它是如何工作的

第4章 处理程序中的错误

4.1 技术要求

4.2 为什么错误处理在系统编程中很重要

4.2.1 准备工作

4.2.2 实践步骤

4.2.3 它是如何工作的

4.3 处理常见的错误

4.3.1 准备工作

4.3.2 实践步骤

4.3.3 它是如何工作的

4.4 错误处理和errno

4.4.1 准备工作

4.4.2 实践步骤

4.4.3 它是如何工作的

4.5 处理更多errno宏

4.5.1 准备工作

4.5.2 实践步骤

4.5.3 它是如何工作的

4.5.4 更多

4.6 使用errno和strerror()

4.6.1 准备工作

4.6.2 实践步骤

4.6.3 更多

4.7 使用errno和perror()

4.7.1 准备工作

4.7.2 实践步骤

4.7.3 更多

4.8 返回错误值

4.8.1 准备工作

4.8.2 实践步骤

4.8.3 它是如何工作的

4.8.4 更多

第5章 使用文件I/O和文件系统操作

5.1 技术要求

5.2 读取索引节点信息并学习文件系统

5.2.1 准备工作

5.2.2 实践步骤

5.2.3 它是如何工作的

5.3 创建软链接和硬链接

5.3.1 准备工作

5.3.2 实践步骤

5.3.3 它是如何工作的

5.3.4 更多

5.4 创建文件并更新时间戳

5.4.1 准备工作

5.4.2 实践步骤

5.4.3 它是如何工作的

5.4.4 更多

5.5 删除文件

5.5.1 准备工作

5.5.2 实践步骤

5.5.3 它是如何工作的

5.6 获得访问权限和所有权

5.6.1 准备工作

5.6.2 实践步骤

5.6.3 它是如何工作的

5.7 设置访问权限和所有权

5.7.1 准备工作

5.7.2 实践步骤

5.7.3 它是如何工作的

5.7.4 更多

5.8 使用文件描述符写入文件

5.8.1 准备工作

5.8.2 实践步骤

5.8.3 它是如何工作的

5.8.4 更多

5.9 使用文件描述符读取文件

5.9.1 准备工作

5.9.2 实践步骤

5.9.3 它是如何工作的

5.9.4 更多

5.10 使用流写入文件

5.10.1 准备工作

5.10.2 实践步骤

5.10.3 它是如何工作的

5.10.4 参考

5.11 使用流读取文件

5.11.1 准备工作

5.11.2 实践步骤

5.11.3 它是如何工作的

5.11.4 更多

5.12 使用流读写二进制数据

5.12.1 准备工作

5.12.2 实践步骤

5.12.3 它是如何工作的

5.12.4 更多

5.13 使用lseek()在文件中移动

5.13.1 准备工作

5.13.2 实践步骤

5.13.3 它是如何工作的

5.14 使用fseek()在文件中移动

5.14.1 准备工作

5.14.2 实践步骤

5.14.3 它是如何工作的

5.14.4 更多

第6章 创建进程和使用作业控制

6.1 技术要求

6.2 探索如何创建进程

6.2.1 准备工作

6.2.2 实践步骤

6.2.3 它是如何工作的

6.2.4 更多

6.3 在Bash中使用作业控制

6.3.1 准备工作

6.3.2 实践步骤

6.3.3 它是如何工作的

6.4 使用信号控制和终止进程

6.4.1 准备工作

6.4.2 实践步骤

6.4.3 它是如何工作的

6.4.4 参考

6.5 在进程中使用execl()替换运行的程序

6.5.1 准备工作

6.5.2 实践步骤

6.5.3 它是如何工作的

6.5.4 参考

6.6 创建新进程

6.6.1 准备工作

6.6.2 实践步骤

6.6.3 它是如何工作的

6.6.4 更多

6.7 在创建的进程中执行新程序

6.7.1 准备工作

6.7.2 实践步骤

6.7.3 它是如何工作的

6.8 使用system()启动一个新进程

6.8.1 准备工作

6.8.2 实践步骤

6.8.3 它是如何工作的

6.9 创建僵尸进程

6.9.1 准备工作

6.9.2 实践步骤

6.9.3 它是如何工作的

6.9.4 更多

6.10 了解孤儿进程

6.10.1 准备工作

6.10.2 实践步骤

6.10.3 它是如何工作的

6.10.4 参考

6.11 创建守护进程

6.11.1 准备工作

6.11.2 实践步骤

6.11.3 它是如何工作的

6.11.4 更多

6.12 实现信号处理程序

6.12.1 准备工作

6.12.2 实践步骤

6.12.3 它是如何工作的

6.12.4 更多

第7章 使用systemd处理守护进程

7.1 技术要求

7.2 了解systemd

7.2.1 准备工作

7.2.2 实践步骤

7.2.3 它是如何工作的

7.2.4 更多

7.2.5 参考

7.3 为守护进程编写单元文件

7.3.1 准备工作

7.3.2 实践步骤

7.3.3 它是如何工作的

7.3.4 更多

7.3.5 参考

7.4 启用和禁用服务，以及启动和停止服务

7.4.1 准备工作

7.4.2 实践步骤

7.4.3 它是如何工作的

7.5 为systemd创建现代守护进程

7.5.1 准备工作

7.5.2 实践步骤

7.5.3 它是如何工作的

7.5.4 参考

7.6 使新的守护进程成为systemd服务

7.6.1 准备工作

7.6.2 实践步骤

7.6.3 它是如何工作的

7.7 查阅日志

7.7.1 准备工作

7.7.2 实践步骤

7.7.3 它是如何工作的

7.7.4 参考

第8章 创建共享库

8.1 技术要求

8.2 库及其重要性

8.2.1 准备工作

8.2.2 实践步骤

8.2.3 它是如何工作的

8.2.4 更多

8.3 创建静态库

8.3.1 准备工作

8.3.2 实践步骤

8.3.3 它是如何工作的

8.3.4 参考

8.4 使用静态库

8.4.1 准备工作

8.4.2 实践步骤

8.4.3 它是如何工作的

8.5 创建动态库

8.5.1 准备工作

8.5.2 实践步骤

8.5.3 它是如何工作的

8.5.4 更多

8.5.5 参考

8.6 在系统上安装动态库

8.6.1 准备工作

8.6.2 实践步骤

8.6.3 它是如何工作的

8.7 在程序中使用动态库

8.7.1 准备工作

8.7.2 实践步骤

8.7.3 它是如何工作的

8.7.4 更多

8.7.5 参考

8.8 编译静态链接程序

8.8.1 准备工作

8.8.2 实践步骤

8.8.3 它是如何工作的

第9章 终端I/O及改变终端行为

9.1 技术要求

9.2 查看终端信息

9.2.1 准备工作

9.2.2 实践步骤

9.2.3 它是如何工作的

9.2.4 参考

9.3 使用stty改变终端的设置

9.3.1 准备工作

9.3.2 实践步骤

9.3.3 它是如何工作的

9.4 调查TTY和PTY设备，并向它们写入数据

9.4.1 实践步骤

9.4.2 它是如何工作的

9.4.3 更多

9.4.4 参考

9.5 检查是否是TTY设备

9.5.1 准备工作

9.5.2 实践步骤

9.5.3 它是如何工作的

9.5.4 参考

9.6 创建一个PTY

9.6.1 准备工作

9.6.2 实践步骤

9.6.3 它是如何工作的

9.6.4 参考

9.7 关闭密码提示回显

9.7.1 准备工作

9.7.2 实践步骤

9.7.3 它是如何工作的

9.7.4 更多

9.8 读取终端的大小

9.8.1 准备工作

9.8.2 实践步骤

9.8.3 它是如何工作的

9.8.4 更多

9.8.5 参考

第10章 使用不同类型的IPC

10.1 技术要求

10.2 使用IPC信号——为守护进程构建客户端

10.2.1 准备工作

10.2.2 实践步骤

10.2.3 它是如何工作的

10.2.4 参考

10.3 使用管道通信

10.3.1 准备工作

10.3.2 实践步骤

10.3.3 它是如何工作的

10.3.4 参考

10.4 FIFO——在shell中使用它

10.4.1 准备工作

10.4.2 实践步骤

10.4.3 它是如何工作的

10.4.4 更多

10.4.5 参考

10.5 FIFO——构建发送者

10.5.1 准备工作

10.5.2 实践步骤

10.5.3 它是如何工作的

10.5.4 参考

10.6 FIFO——构建接收者

10.6.1 准备工作

10.6.2 实践步骤

10.6.3 它是如何工作的

10.6.4 参考

10.7 消息队列——构建发送者

10.7.1 准备工作

10.7.2 实践步骤

10.7.3 它是如何工作的

10.7.4 参考

10.8 消息队列——构建接收者

10.8.1 准备工作

10.8.2 实践步骤

10.8.3 它是如何工作的

10.8.4 参考

10.9 在父子进程间使用共享内存通信

10.9.1 准备工作

10.9.2 实践步骤

10.9.3 它是如何工作的

10.9.4 参考

10.10 在不相关的进程中使用共享内存

10.10.1 准备工作

10.10.2 实践步骤

10.10.3 它是如何工作的

10.10.4 参考

10.11 UNIX套接字编程——构建发送者

10.11.1 准备工作

10.11.2 实践步骤

10.11.3 它是如何工作的

10.11.4 参考

10.12 UNIX套接字编程——构建接收者

10.12.1 准备工作

10.12.2 实践步骤

10.12.3 它是如何工作的

10.12.4 参考

第11章 在程序中使用线程

11.1 技术要求

11.2 编写第一个线程化程序

11.2.1 准备工作

11.2.2 实践步骤

11.2.3 它是如何工作的

11.2.4 更多

11.2.5 参考

11.3 从线程中读取返回值

11.3.1 准备工作

11.3.2 实践步骤

11.3.3 它是如何工作的

11.4 触发竞态条件

11.4.1 准备工作

11.4.2 实践步骤

11.4.3 它是如何工作的

11.5 使用互斥锁来防止竞态条件

11.5.1 准备工作

11.5.2 实践步骤

11.5.3 它是如何工作的

11.5.4 参考

11.6 更有效的互斥锁编程

11.6.1 准备工作

11.6.2 实践步骤

11.6.3 它是如何工作的

11.7 使用条件变量

11.7.1 准备工作

11.7.2 实践步骤

11.7.3 它是如何工作的

11.7.4 参考

第12章 调试程序

12.1 技术要求

12.2 开始GDB

12.2.1 准备工作

12.2.2 实践步骤

12.2.3 它是如何工作的

12.2.4 更多

12.3 使用GDB进入函数内部

12.3.1 准备工作

12.3.2 实践步骤

12.3.3 它是如何工作的

12.4 使用GDB观察内存

12.4.1 准备工作

12.4.2 实践步骤

12.4.3 它是如何工作的

12.4.4 更多

12.4.5 参考

12.5 在运行期间修改变量

12.5.1 准备工作

12.5.2 实践步骤

12.5.3 它是如何工作的

12.6 在新创建的程序中使用GDB

12.6.1 准备工作

12.6.2 实践步骤

12.6.3 它是如何工作的

12.6.4 更多

12.7 在多线程中调试程序

12.7.1 准备工作

12.7.2 实践步骤

12.7.3 它是如何工作的

12.7.4 更多

12.7.5 参考

12.8 使用Valgrind找到一个简单的内存泄漏

12.8.1 准备工作

12.8.2 实践步骤

12.8.3 它是如何工作的

12.8.4 参考

12.9 使用Valgrind找到缓冲区溢出

12.9.1 准备工作

12.9.2 实践步骤

12.9.3 它是如何工作的

12.9.4 更多

作者简介