现代 C++ 教程

Appearance

正常
本文贡献者2 人
查看署名

预处理器与多文件工程 ​

如果你到目前为止所有的 C 程序都写在一个 .c 文件里，那迟早有一天你会撑不住的。实际工程中，我们把代码拆分到多个 .c 和 .h 文件中，每个模块各司其职，然后通过编译和链接把它们组装成完整的程序。

但多文件工程带来的不仅仅是组织上的挑战，它还牵出了 C 语言中一个经常被误解的角色——预处理器（preprocessor）。理解预处理器的本质，是避免那些莫名其妙的编译错误、奇怪的宏展开行为和头文件循环包含的第一步。

第一步——理解预处理器做什么 ​

C 程序从源代码变成可执行文件要经过四个阶段：预处理、编译、汇编和链接。预处理器是第一个工位，它对源文件进行纯文本变换——所有以 # 开头的行都是预处理指令。

预处理器不懂 C 语言。它不知道什么是类型、什么是作用域，只会机械地执行替换、删除和条件选择。你可以用 gcc -E -P demo.c 查看预处理后的输出，感受预处理器有多"暴力"。

#include：最暴力的文本粘贴 ​

#include 的行为非常直接——把指定文件的全部内容原封不动地插入到当前位置。这就是为什么我们说它是文本粘贴，不是模块导入。

尖括号 <> 在系统头文件目录中搜索，双引号 "" 先搜索当前目录再搜索系统目录。嵌套 include 会导致严重的代码膨胀。

第二步——掌握宏的编写技巧和陷阱 ​

对象宏：常量定义 ​

c
#define kMaxBufferSize 1024
#define kVersionString "1.0.0"

char buffer[kMaxBufferSize];

宏定义末尾不要加分号。#define kMaxBufferSize 1024; 会把分号也作为替换文本的一部分。

函数宏：带参数的文本替换 ​

括号是血泪教训的总结：

c
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

不加括号的后果：

c
#define BAD_SQUARE(x) x * x
int r = BAD_SQUARE(2 + 3);   // 展开为 2 + 3 * 2 + 3 = 11，而不是 25

但括号解决不了重复求值问题：

c
int x = 5;
int r = MAX(x++, 10);
// 展开为 ((x++) > (10) ? (x++) : (10))
// x++ 被求值了两次！x 最终变成了 7 而不是 6

多行宏与 do-while(0) 惯用法 ​

c
#define SAFE_FREE(ptr)         \
    do {                        \
        if ((ptr) != NULL) {     \
            free((ptr));         \
            (ptr) = NULL;        \
        }                       \
    } while (0)

do { ... } while(0) 作为一个整体构成一条语句，不会在 if-else 的分支中出现悬挂问题。这个技巧在 Linux 内核代码中随处可见。

# 和 ## 运算符 ​

# 把宏参数变成字符串，## 把两个 token 粘合成一个新的 token：

c
#define STRINGIFY(x) #x
#define MAKE_VAR(prefix, num) prefix ## num

int MAKE_VAR(value, 1) = 10;  // 展开为 int value1 = 10;

条件编译 ​

头文件防护 ​

传统做法用 #ifndef + #define 组合，现代编译器支持更简洁的 #pragma once：

c
// math_utils.h
#pragma once

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

#pragma once 不是 C 标准的一部分，但 GCC、Clang、MSVC 全都支持。在 C++ 项目中已经是事实上的标准做法。

典型用途 ​

Debug/Release 切换、平台适配、功能开关——这些全靠条件编译。

第三步——学会组织头文件和多文件工程 ​

头文件放声明（declaration），源文件放定义（definition）。

extern 的正确使用：在头文件中用 extern 声明，在一个 .c 文件中定义：

c
// config.h
extern int kConfigMaxRetryCount;

// config.c
#include "config.h"
int kConfigMaxRetryCount = 3;

头文件里写 int kConfigMaxRetryCount = 3;（没有 extern）被多个 .c 文件 include 会导致 multiple definition 错误。

多文件编译与链接 ​

每个 .c 文件加上它 #include 的所有头文件构成一个编译单元。编译器对每个编译单元独立处理，链接器负责把所有 .o 文件拼在一起。

static 关键字限制符号可见性在当前编译单元内——链接器看不到它，其他 .c 文件也无法引用。

静态库初步 ​

bash
# 编译为目标文件
gcc -c math_utils.c
# 创建静态库
ar rcs libmath_utils.a math_utils.o
# 使用静态库
gcc -o demo main.c -L. -lmath_utils

C++ 衔接 ​

  • const/constexpr 替代宏常量——有类型、有作用域、可调试
  • inline 函数替代函数宏——参数只求值一次，有类型检查
  • template 替代泛型宏——完整的类型检查和编译期验证
  • namespace 替代文件级 static——更清晰的命名空间组织
  • using 替代 typedef——语法更直观，支持别名模板
  • C++20 Modules——用 export/import 替代文本粘贴的 #include

练习 ​

练习 1：构建多文件模块化项目 ​

难度：基础 · .h/.c 分离加静态库打包

c
// math_utils.h
#pragma once
// 练习： 声明 clamp_int 和 count_digits

// math_utils.c
#include "math_utils.h"
// 练习： 实现 clamp_int（将 value 限制在 [min_val, max_val] 范围内）
// 练习： 实现 count_digits（计算整数的十进制位数）

// main.c
#include <stdio.h>
#include "math_utils.h"
int main(void) {
    // 练习： 调用两个函数，验证结果
    return 0;
}
参考答案

math_utils.h

展开代码收起代码共 37 行
c
#pragma once
/**
 * @brief 返回两个值中的最大值
 *
 * @param a 参与比较的第一个值
 * @param b 参与比较的第二个值
 * @return a 与 b 中较大的那个
 */
#define MAX(a, b)           \
  ({                        \
    __typeof__(a) _a = (a); \
    __typeof__(b) _b = (b); \
    _a > _b ? _a : _b;      \
  })

/**
 * @brief 返回两个值中的最小值
 *
 * @param a 参与比较的第一个值
 * @param b 参与比较的第二个值
 * @return a 与 b 中较小的那个
 */
#define MIN(a, b)           \
  ({                        \
    __typeof__(a) _a = (a); \
    __typeof__(b) _b = (b); \
    _a < _b ? _a : _b;      \
  })

void clamp_int(int *value, int min_val, int max_val);

/**
 * @brief 返回一个整数的十进制位数
 *
 * 不计符号位；0 的位数为 1。
 */
int count_digits(int value);

math_utils.c

c
#include "math_utils.h"

void clamp_int(int *value, int min_val, int max_val)
{
    *value = MAX(min_val, MIN(*value, max_val));
}

int count_digits(int value)
{
    int digits = 0;

    do {
        ++digits;
        value /= 10;
    } while (value != 0);

    return digits;
}

main.c

展开代码收起代码共 22 行
c
#include <stdio.h>

#include "math_utils.h"

int main(void)
{
    int value;

    value = 5;
    clamp_int(&value, 0, 10);
    printf("clamp_int(5, 0, 10) = %d\n", value);

    value = 100;
    clamp_int(&value, 0, 10);
    printf("clamp_int(100, 0, 10) = %d\n", value);

    printf("count_digits(42) = %d\n", count_digits(42));
    printf("count_digits(-12345) = %d\n", count_digits(-12345));

    puts("All tests passed.");
    return 0;
}

编译运行：

bash
gcc -std=c17 -Wall -Wextra main.c math_utils.c -o main

或者是

bash
gcc -std=c17 -Wall -Wextra  -c math_utils.c  # 只编译不链接，生成 math_utils.o
gcc -std=c17 -Wall -Wextra  -c main.c        # 生成 main.o
ar rcs libmath_utils.a math_utils.o            # 把 .o 打进静态库
gcc -std=c17 -Wall -Wextra  -o demo main.o -L. -lmath_utils  # 链接

./demo

注意：math_utils.h 中的宏使用了 GCC 扩展（语句表达式和 __typeof__），因此编译时不启用 -Wpedantic，否则会产生扩展相关的警告。

运行结果：

text
clamp_int(5, 0, 10) = 5
clamp_int(100, 0, 10) = 10
count_digits(42) = 2
count_digits(-12345) = 5
All tests passed.

提示：编译步骤是 gcc -std=c17 -Wall -Wextra -c math_utils.c、gcc -std=c17 -Wall -Wextra -c main.c、gcc -std=c17 -Wall -Wextra -o demo main.o math_utils.o。打包静态库用 ar rcs libmath_utils.a math_utils.o。

练习 2：零开销的 DEBUG_LOG 宏 ​

难度：进阶 · 条件编译加可变参数宏

c
// debug_log.h
#pragma once

#ifdef NDEBUG
// 练习： Release 模式——DEBUG_LOG 展开为空
#else
// 练习： Debug 模式——输出 [DEBUG] 文件名:行号: 格式化消息
// 提示：使用 __FILE__、__LINE__、__VA_ARGS__
#endif
参考答案

debug_log.h

c
#pragma once

#include <stdio.h>

/* 默认开启日志；编译时用 -DNDEBUG 可关闭 */
#ifdef NDEBUG
#define DEBUG_LOG(fmt, ...) ((void)(0))
#else
#define DEBUG_LOG(fmt, ...) \
    fprintf(stderr, "[%s:%d] " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__)
#endif

main.c

展开代码收起代码共 21 行
c
#include <stdio.h>

#include "debug_log.h"

int main(void)
{
    int count = 0;

    DEBUG_LOG("开始运行，初始值 count = %d", count);

    for (int i = 0; i < 3; ++i) {
        DEBUG_LOG("第 %d 次循环", i);
        count += i;
    }

    DEBUG_LOG("结束，最终 count = %d", count);
    DEBUG_LOG("这是不带额外参数的中文消息");

    printf("完成，count = %d\n", count);
    return 0;
}

编译运行：

Debug 模式

bash
gcc -std=c17 -Wall -Wextra main.c -o main && ./main

Release 模式

bash
gcc -std=c17 -Wall -Wextra -DNDEBUG main.c -o main && ./main

运行结果：

Debug 模式：行号取决于 main.c 中的实际行位置，以下用 <line> 表示。

text
[main.c:<line>] 开始运行，初始值 count = 0
[main.c:<line>] 第 0 次循环
[main.c:<line>] 第 1 次循环
[main.c:<line>] 第 2 次循环
[main.c:<line>] 结束，最终 count = 3
[main.c:<line>] 这是不带额外参数的中文消息
完成，count = 3

Release 模式：DEBUG_LOG 被展开为 ((void)(0))，什么都不输出，只留下 printf 的那一行：

text
完成，count = 3

注意：__VA_ARGS__ 是 C99 起标准化的可变参数宏机制，但答案中的 ##__VA_ARGS__ 是 GCC 扩展：它在 DEBUG_LOG("一条消息") 没有额外格式化参数时删除多余的逗号。因此这里的编译命令不启用 -Wpedantic；它可在 GCC 的 C17 模式下使用，却不是严格 ISO C17 的可移植写法。

提示：可变参数宏的标准形式是 #define DEBUG_LOG(fmt, ...) fprintf(stderr, fmt, __VA_ARGS__)。本答案为了支持没有额外格式化参数的调用，使用了 GCC 的 ##__VA_ARGS__ 扩展。

pdf-latest-4-g85128cc · 85128cc · 2026-10-05

Copyright 2025-2026 Charliechen