从了解 C 语法到成为真正的 C 程序员

C 是一门非常容易学习的编程语言。变量、函数、控制流语句、结构体、指针,仅此而已。最重要的是,C 给予你完全的控制权——当你用 C 编写代码时,你就是上帝。

然而,能力越大,责任越大。你可以让一切运行得完美而高效,但也可能因为在程序中引入栈溢出、悬空指针、释放后使用、空指针解引用、重复释放、内存泄漏、越界内存访问等问题而把一切搞砸。

此外,C 是一门赋予你控制权的强大语言。然而,这也意味着,与 C++、Python 等语言相比,C 提供的抽象层要少得多,而且你需要自己实现大量逻辑才能完成工作。因此,从了解 C 语法到成为一名真正的 C 程序员,还有很长的一段路要走。

我在 2024/2025 年学习了 C,但没有通过编写真正可投入生产环境的程序来实践所学知识,便转而学习 C++。随后,我开始使用 C++ 和 Qt 编写应用程序,并且发现这种开发方式让我感到很舒适。然而,最近几天,我在尝试使用 libcanokey 开发一个 CanoKey 配套应用程序时遇到了不少障碍。这个项目最初是为了练习 C++ + Qt + Kirigami 编程,但我发现,从“了解 C”到“知道如何使用 C 开发实用程序”,自己仍然有很多东西需要学习。

本文列举了一些简单的例子,希望能帮助那些刚刚学会 C 语法、却还不知道如何使用 C 编写实用程序的人。

在 C 中实现面向对象编程

C 本身并不原生支持面向对象编程。C 中用于组合多个值的主要内置聚合类型之一称为结构体。它将多个内置 C 类型的成员或其他结构体类型的成员组合成一个类型,成员之间还可能存在填充。然而,自由软件社区中的许多 C 项目和库都采用了手动实现的伪面向对象设计。它们并没有扩展 C 语法,而只是利用结构体来实现自己的目标。

基本思想

定义一个结构体:

typedef struct Counter
{
    int a;
} Counter;

然后定义一些函数:

Counter *counter_create()
{
    Counter *ans = malloc(sizeof *ans);
    if (! ans) return NULL;
    ans->a = 0;
    return ans;
}

void counter_increase(Counter *self)
{
    self->a++;
}

int counter_get_value(Counter *self)
{
    return self->a;
}

恭喜!你已经在 C 中实现了一个类及其方法。

一个实现相同功能的 C++ 类看起来会是这样:

class Counter
{
public:
    Counter()
    : a(0) {}

    void increase()
    {
        this->a++;
    }

    int get_value() const
    {
        return this->a;
    }

private:
    int a;
}

核心思想就是将结构体用作对象,将函数用作方法。

封装

通常,我们会将自己定义的结构体视为对象,并通过一组函数来操作它们。然而,直接修改这些结构体的成员仍然是可行的,这可能会导致意料之外的行为。

C 并没有提供一种机制,既能阻止直接修改结构体,又允许通过指定的一组函数来修改它。不过,有一个技巧可以帮助我们实现这个目标。

将结构体和函数的声明放在头文件 counter.h 中:

#ifndef COUNTER_H
#define COUNTER_H

typedef struct Counter Counter;
Counter *counter_create();
void counter_increase(Counter *self);
int counter_get_value(Counter *self);

#endif

然后将实现放在 counter.c 中:

#include "counter.h"

struct Counter
{
    int a;
};

Counter *counter_create()
{
    Counter *ans = malloc(sizeof *ans);
    if (! ans) return NULL;
    ans->a = 0;
    return ans;
}

void counter_increase(Counter *self)
{
    self->a++;
}

int counter_get_value(Counter *self)
{
    return self->a;
}

在任何需要使用 Counter 的源文件中,只需写入:

#include "counter.h"

现在,你的源文件知道存在一个名为 Counter 的结构体,也知道有一些函数可以操作这个结构体。但是,源文件并不知道该结构体具体包含哪些成员,也不知道这些函数的实现细节。因此,它无法直接修改该结构体,除非强行将指针转换为某个已知类型的指针。

继承

定义另一个结构体:

typedef struct CounterPlusPlus
{
    Counter pref;
    int step;
} CounterPlusPlus;

然后定义一个方法:

void counter_plus_plus_increase(CounterPlusPlus *self)
{
    self->pref.a += self->step;
}

我们当然可以定义一个类似 int counter_plus_plus_get_value(CounterPlusPlus *self) 的函数,用来获取升级版计数器的值。但我们其实不需要这样做!

在一个结构体中,各个成员按照声明顺序排列,不过成员之间可能会插入填充。一个 CounterPlusPlus 由一个 Counter 和其后的一个 int 组成。因此,一个 CounterPlusPlus 实例的地址与其第一个成员 pref 的地址完全相同!

因此,我们可以将 CounterPlusPlus * 转换为 Counter *,将其传递给 int counter_get_value(Counter *self),让该函数将其视为一个 Counter。它会完全按照预期工作!

这是在 C 中实现继承的一种常见方法。GObject 就广泛采用了这种方法,其许多数据类型都以这种方式继承自 GObject。

资源管理与所有权

C 赋予我们分配和释放内存的自由,但如果不谨慎使用这种自由,我们就很容易遇到内存泄漏、重复释放、释放后使用等问题。

所有权是 C 程序员遵循的一种约定,它可以帮助程序员正确管理已分配的内存。更多相关信息可以参阅我之前的文章。

与硬件直接通信

你可能知道,系统编程广泛使用 C,而且 C 可以直接与硬件通信。许多 C 初学者和中级学习者可能会认为,这是依赖于硬件接口引入的某些特殊 C 语法。但在大多数情况下,事实并非如此。

大多数制造商都会为其硬件提供硬件抽象层,以便开发者更轻松地开发固件和驱动程序。硬件抽象层会提供用于操作硬件的函数。然而,在大多数情况下,硬件抽象层本身也是用 C 编写的。那么,硬件抽象层究竟使用哪些 C 语言结构来操作硬件呢?

事实上,某些硬件平台会为特定操作提供专用机器指令,而我们可以通过将汇编语言与 C 结合来使用这些指令。不过,在大多数情况下,使用 C 与硬件通信并不比下面这样的代码更复杂:

*((volatile uint32_t *)0x40000000UL) = 1;

没错,你没有看错,我也没有开玩笑。一个地址、一次类型转换,以及一次普通的整数赋值。就这么简单。

大多数硬件都有用于控制其运行的控制寄存器。通过向这些寄存器写入数值,你就可以让它们执行不同的任务。MMIO 等技术会将这些寄存器映射到一个或多个地址空间中,使你能够像访问普通内存一样访问它们。通过读取外设寄存器并向其写入数据,我们可以配置硬件、控制其运行状态,并触发它所支持的操作。外设的内部逻辑会解释这些寄存器访问,并执行相应的操作。还有其他技术,例如 PMIO,它会在支持该技术的体系结构上使用独立的 I/O 地址空间。

没有任何神奇或不透明的东西。

进一步的建议

上面列出的内容只是冰山一角。

目前,我正在使用某个大语言模型服务提供商提供的学习模式,深入学习这些内容。它生成了一份学习路线图,下面列出了一些重要的知识点。希望这些内容能对你有所帮助。

  1. 内存管理与所有权
    • 栈分配与堆分配。
    • 对象生命周期与存储期。
    • 所有权、借用与所有权转移。
    • 浅拷贝与深拷贝。
    • 引用计数。
    • 资源获取与释放。
    • 部分初始化与失败清理。
    • 避免内存泄漏、重复释放与释放后使用。
    • 灵活数组成员。
    • 对齐与填充。
    • 分配大小溢出。
  2. API 设计与封装
    • 不透明结构体。
    • 公共头文件与私有头文件。
    • 构造函数与析构函数。
    • 初始化函数与终结函数。
    • 取值函数与设置函数。
    • 引用计数 API。
    • 复制与克隆。
    • 函数契约。
    • 前置条件与后置条件。
    • 错误报告。
    • API 文档。
    • 命名空间约定。
    • 回调 API。
  3. 完整的编译过程
    • 预处理。
    • 编译。
    • 汇编。
    • 链接。
    • 翻译单元。
    • 目标文件。
    • 符号表。
    • 未定义符号。
    • 符号可见性。
    • 静态库。
    • 共享库。
    • 位置无关代码。
    • 运行时库加载。
    • 动态链接。
    • ABI 兼容性。
  4. 高级指针技术
    • 指针运算。
    • 数组与指针:它们的相似之处与区别。
    • 二级指针(T **)。
    • 指向数组的指针。
    • 函数指针。
    • 指向结构体的指针。
    • const 正确性。
    • restrict。
    • void * 与泛型编程。
    • 空指针与无效指针。
    • 指针生命周期与别名规则。
  5. 结构体与面向数据的设计
    • 结构体组合。
    • 不透明结构体。
    • 公共结构体与私有结构体。
    • 带标签的联合体。
    • 枚举类型。
    • 位域及其可移植性限制。
    • 结构体填充与对齐。
    • 灵活数组成员。
    • 侵入式与非侵入式数据结构。
    • 结构体初始化。
    • 复合字面量。
  6. C 字符串与二进制数据
    • 以空字符结尾的字符串。
    • 字符数组。
    • 缓冲区大小与容量。
    • strlen()、strcmp()、memcpy() 和 memmove()。
    • 安全的字符串构造。
    • 动态字符串缓冲区。
    • UTF-8。
    • 字符编码与字节表示之间的区别。
    • 整数格式化与 printf() 格式说明符。
    • 格式字符串漏洞。
    • 二进制数据处理。
  7. 整数类型与未定义行为
    • 整数提升。
    • 有符号与无符号算术。
    • 整数溢出。
    • 整数转换。
    • 固定宽度整数类型(uint32_t、int64_t 等)。
    • size_t、ptrdiff_t 和 uintptr_t。
    • 字节序。
    • 对齐。
    • 未定义行为。
    • 未指定行为。
    • 实现定义行为。
    • 严格别名规则。
  8. 错误处理
    • 基于返回值的错误处理。
    • 错误代码。
    • 错误输出参数。
    • 使用 goto 的清理模式。
  9. C 中的数据结构与算法
    • 动态数组。
    • 链表。
    • 双向链表。
    • 哈希表。
    • 树。
    • 二叉搜索树。
    • 平衡树。
    • 队列。
    • 栈。
    • 堆。
    • 环形缓冲区。
    • 字符串构造器。
    • 迭代器。
  10. 函数指针、回调与多态
    • 回调注册。
    • 函数指针。
    • 结构体中的函数指针。
    • 虚函数表模式。
    • 接口实现。
    • 事件处理程序。
    • 用户数据指针。
    • 插件接口。
    • 动态分派。
  11. 操作系统接口
    • C 标准库与操作系统 API。
    • POSIX。
    • 文件描述符。
    • 文件流(FILE *)。
    • 文件操作。
    • 目录与路径。
    • 进程。
    • 环境变量。
    • 管道。
    • 信号。
    • 套接字。
    • 内存映射(mmap())。
    • 系统调用。
  12. 并发与多线程
    • 进程与线程。
    • POSIX 线程。
    • 互斥锁。
    • 条件变量。
    • 信号量。
    • 原子操作。
    • 数据竞争。
    • 死锁。
    • 线程安全。
    • 线程局部存储。
    • 内存顺序。
    • 事件循环。
    • 异步编程。
  13. 事件驱动编程
    • 事件循环。
    • 事件队列。
    • 事件分发。
    • 回调。
    • 定时器。
    • 输入事件。
    • 窗口事件。
    • 异步操作。
    • 应用程序生命周期。
  14. 构建系统
    • GNU Make
    • Autoconf 和 Automake
    • Meson
    • CMake
  15. 库安装与依赖管理
    • 头文件包含目录。
    • 库目录。
    • pkg-config。
    • .pc 文件。
    • PKG_CONFIG_PATH。
    • 静态链接与共享链接。
    • 运行时库路径。
    • 安装前缀。
    • 头文件安装。
    • 库版本管理。
    • 依赖发现。
    • 传递依赖。
  16. 调试
    • GDB。
    • 断点。
    • 回溯。
    • 栈帧。
    • 变量检查。
    • 核心转储。
    • 监视点。
    • 调试符号。
    • 优化后程序的调试。
    • 段错误调试。
  17. 内存错误与未定义行为检测
    • AddressSanitizer,用于检测越界访问、释放后使用及其他内存错误。
    • UndefinedBehaviorSanitizer,用于检测各种形式的未定义行为。
    • Valgrind Memcheck,用于检测无效内存访问、未初始化的值和内存泄漏。
    • MemorySanitizer,用于检测对未初始化内存的使用。
    • 静态分析,用于在不执行程序的情况下检测潜在缺陷。
  18. 软件测试
    • 单元测试。
    • 集成测试。
    • 回归测试。
    • 测试夹具。
    • 测试断言。
    • 边界测试。
    • 错误路径测试。
    • 内存泄漏测试。
    • 模糊测试。
    • 持续集成。
  19. 性能分析
    • 算法复杂度。
    • 缓存局部性。
    • 内存分配开销。
    • 性能剖析。
    • CPU 性能剖析。
    • 内存性能剖析。
    • 基准测试。
    • 面向数据的优化。
  20. 编码规范与可读性
    • 命名约定。
    • 缩进。
    • 函数组织。
    • 头文件组织。
    • 注释。
    • 文档注释。
    • 公有与私有符号的命名。
    • 文件组织。
    • 避免不必要的宏。
    • 避免不必要的全局变量。
    • 保持函数易于理解。
    • 保持一致性。
  21. 文档
    • 公有函数。
    • 函数参数。
    • 返回值。
    • 错误条件。
    • 所有权转移。
    • 对象生命周期。
    • 线程安全保证。
    • API 稳定性。
    • 使用示例。
  22. API 与 ABI 稳定性
    • 什么是 API?
    • 什么是 ABI?
    • 什么情况构成不兼容的变更?
    • 为什么公开结构体成员可能造成问题。
    • 符号可见性。
    • 共享库版本管理。
    • 弃用。
    • 向后兼容性。
    • 并行安装不同版本的库。
  23. 国际化与本地化
    • UTF-8。
    • 字符编码。
    • 区域设置。
    • gettext。
    • 翻译目录。
    • 复数形式。
    • 日期与数字格式化。
    • 错误消息翻译。
    • 避免硬编码面向用户的字符串。
  24. Git 与协作开发
    • 仓库。
    • 提交。
    • 分支。
    • 合并。
    • 变基。
    • 差异检查。
    • 冲突解决。
    • 补丁创建。
    • 代码审查。
    • 问题报告。
    • 发布分支。

或者使用简化版本:

  1. 阶段 1 — 惯用 C 编程
    • 内存所有权与生命周期。
    • 高级指针与结构体。
    • 字符串与缓冲区处理。
    • 错误处理。
    • 数据结构。
    • 函数指针与回调。
  2. 阶段 2 — 库工程
    • 不透明类型与 API 设计。
    • 头文件与源文件组织。
    • 静态库与共享库。
    • 编译与链接。
    • pkg-config。
    • ABI 与 API 稳定性。
  3. 阶段 3 — 专业 C 开发
    • POSIX 与系统编程。
    • 构建系统。
    • 调试与性能剖析。
    • 单元测试与集成测试。
    • 运行时检测工具与静态分析。
    • 文档与编码规范。
  4. 阶段 4 — 生态系统开发
    • GLib 与 GObject。
    • GNU 开发实践。
    • SDL 开发实践。
    • Git 与协作开发。
    • API 兼容性。
    • 向成熟项目贡献补丁。
使用 Hugo 构建
主题 Stack 由 Jimmy 设计