C语言笔记归纳22：预处理详解

符号	含义	示例输出
FILE	当前编译的源文件路径（字符串）	"C:\code\test.c"
LINE	当前代码的行号（整数）	19
DATE	源文件被编译的日期（字符串）	"Dec 20 2025"
TIME	源文件被编译的时间（字符串）	"10:25:35"
STDC	编译器是否遵循 ANSI C 标准（遵循为 1，否则未定义）	1（GCC）/ 未定义（VS2022）

代码示例 + 易错标注：

#include <stdio.h>
int main() {
    printf("当前文件：%s\n", __FILE__);    // 输出文件路径
    printf("编译日期：%s\n", __DATE__);    // 输出编译日期
    printf("编译时间：%s\n", __TIME__);    // 输出编译时间
    printf("当前行号：%d\n", __LINE__);    // 输出：19（取决于代码位置）
    // printf("%d\n", __STDC__);          // ❌ 易错：VS2022不完全遵循ANSI C，会报错
    // 注：GCC编译器支持__STDC__，输出1
    return 0;
}

实用场景：

调试日志：打印错误所在的文件和行号（比如printf("错误：文件%s，行号%d\n", __FILE__, __LINE__);）；
版本标记：记录程序的编译时间。

3. 🔧 #define：定义常量与宏（预处理核心）

#define是预处理最核心的指令，主要用于 “文本替换”，分为两种用法：定义常量（符号常量）、定义宏（带参数的文本替换）。

3.1 #define 定义常量（符号常量）

基本语法：

#define 常量名 常量值  // 注意：末尾不要加分号

核心作用：

替代魔法数字（比如用#define MAX 1000代替代码中的 1000，便于修改和理解）；
定义字符串、表达式等。

代码示例 + 易错标注：

#include <stdio.h>

// 正确示例：定义常量（无分号）
#define MAX 1000
#define STR "hello bit"
#define REG register  // 替代关键字（简化代码）
#define DO_FOREVER for(;;)  // 定义死循环（文本替换）

// ❌ 错误示例：宏定义加了分号
#define MIN 0;

int main() {
    int m = MAX;
    printf("%d\n", MAX);  // 输出：1000（替换为1000）
    printf("%s\n", STR);  // 输出：hello bit（替换为字符串）
    
    REG int a = 5;  // 等价于 register int a = 5;
    
    // DO_FOREVER;  // 等价于 for(;;); （死循环，需注释避免程序卡住）

    // ❌ 错误：MIN后有分号，导致语法错误
    // if (a > MIN) { ... }  // 替换后：if (a > 0;) { ... }（多了分号）
    
    return 0;
}

关键注意点：

末尾不要加分号：宏是文本替换，分号会被一起替换，导致语法错误；

续行符\：如果宏定义太长，可用\换行（\后不能有任何空格）：

#define DEBUG_PRINT printf("文件：%s\t行号：%d\n" \
                          "日期：%s\t时间：%s\n", \
                          __FILE__, __LINE__, \
                          __DATE__, __TIME__)

3.2 #define 定义宏（带参数的文本替换）

宏不仅能定义常量，还能接收参数 —— 本质是 “带参数的文本替换”，不是函数（没有调用开销）。

基本语法：

#define 宏名(参数列表) 替换文本
// 注意：宏名与左括号之间不能有空格！否则参数列表会被当作替换文本的一部分

示例 1：计算一个数的平方（宏的优先级坑）

#include <stdio.h>

// ❌ 错误版本：没有加括号，优先级混乱
#define SQUARE(x) x*x

// ✅ 正确版本：参数和整体都加括号，避免优先级问题
#define SQUARE_CORRECT(x) ((x)*(x))

int main() {
    int a = 5;
    printf("错误版本：%d\n", SQUARE(a+1));  // 输出：11（替换为a+1*a+1=5+1*5+1=11）
    printf("正确版本：%d\n", SQUARE_CORRECT(a+1));  // 输出：36（替换为((5+1)*(5+1))=36）
    return 0;
}

示例 2：计算一个数的两倍（再遇优先级坑）

#include <stdio.h>

// ❌ 错误版本：整体未加括号
#define DOUBLE(x) (x)+(x)

// ✅ 正确版本：整体加括号
#define DOUBLE_CORRECT(x) ((x)+(x))

int main() {
    int a = 5;
    printf("错误版本：%d\n", 10 * DOUBLE(a));  // 输出：55（替换为10*(5)+(5)=55）
    printf("正确版本：%d\n", 10 * DOUBLE_CORRECT(a));  // 输出：100（替换为10*((5)+(5))=100）
    return 0;
}

核心结论：

用于数值计算的宏，必须给参数和整体都加括号—— 避免被周围的运算符优先级干扰，这是新手最容易踩的坑！

3.3 带副作用的宏参数（新手高频坑）

“副作用” 是指参数在替换过程中被多次计算，导致值被意外修改（比如a++、++b这类自增 / 自减表达式）。

代码示例 + 详细拆解：

#include <stdio.h>

// 求两个数的较大值
#define MAX(X,Y) ((X)>(Y)?(X):(Y))

int main() {
    int a = 3;
    int b = 5;
    int m = MAX(a++, b++);  // ❌ 带副作用的参数
    // 替换后：int m = ((a++)>(b++)?(a++):(b++));
    // 执行过程：
    // 1. 先比较a++（3）和b++（5）：3<5，条件为假
    // 2. 执行b++：b从5变成6，返回6给m
    // 3. 最终：a=4，b=6，m=6
    printf("m=%d, a=%d, b=%d\n", m, a, b);  // 输出：m=6, a=4, b=6
    return 0;
}

避坑建议：

宏参数尽量用 “无副作用的表达式”（比如a、a+3），避免用a++、--b这类会修改值的表达式！

3.4 宏替换的底层规则（3 步拆解）

预处理器替换宏时，遵循固定流程，搞懂这个流程就能避开大部分替换坑：

扫描参数：检查宏参数中是否包含其他 #define 定义的符号，若有则先替换；
替换文本：将参数值替换到宏的替换文本中，生成新的文本；
二次扫描：对替换后的文本再次扫描，若还有 #define 符号，继续替换（直到没有为止）。

关键注意点：

宏不能递归：比如#define A(A) A，替换时会陷入无限循环，编译器直接报错；
字符串常量不被扫描：比如printf("MAX=%d", MAX)，双引号内的MAX不会被替换为 1000。

示例验证：

#include <stdio.h>
#define N 10
#define M N+5  // M依赖N
#define P M*2  // P依赖M

int main() {
    printf("P=%d\n", P);  // 替换流程：P→M*2→N+5*2→10+5*2=20
    printf("\"M=%d\"\n", M);  // 输出："M=15"（双引号内的M不替换）
    return 0;
}

4. 🆚 宏与函数的终极对比（优缺点 + 适用场景）

宏和函数都能实现 “代码复用”，但底层逻辑完全不同 —— 宏是 “文本替换”，函数是 “代码调用”。很多新手分不清什么时候用宏，什么时候用函数，看这张表就够了！

宏与函数核心对比表：

对比维度	宏（#define）	函数（int Max (int x,int y)）
本质	文本替换（预处理阶段完成）	代码调用（运行时执行）
执行速度	更快（无调用开销：压栈、跳转、返回）	较慢（有函数调用的额外开销）
代码体积	可能增大（每次使用都复制一份代码）	固定（代码只存一份，多次调用复用）
参数类型	类型无关（只要操作合法，支持任意类型）	类型相关（不同类型需写不同函数）
调试难度	无法调试（预处理后宏已消失）	可逐语句调试（运行时可见）
副作用风险	高（参数可能被多次计算）	低（参数只在传参时计算一次）
递归支持	不支持（无法递归替换）	支持（可调用自身）
特殊能力	可接收类型作为参数（如 #define MALLOC (n,type) (type) malloc (nsizeof (type))）	无法接收类型作为参数

示例：宏的特殊能力（函数做不到）

#include <stdio.h>
#include <stdlib.h>

// 宏：接收类型作为参数，动态分配内存
#define MALLOC(n, type) (type*)malloc(n * sizeof(type))

int main() {
    // 分配10个int类型的内存
    int* ptr1 = MALLOC(10, int);  // 替换为：(int*)malloc(10*sizeof(int))
    // 分配5个float类型的内存
    float* ptr2 = MALLOC(5, float);  // 替换为：(float*)malloc(5*sizeof(float))

    free(ptr1);
    free(ptr2);
    return 0;
}

这个功能函数无法实现：函数的参数是 “值”，而宏的参数是 “文本”，可以直接传递int、float这类类型名。

适用场景总结：

用宏：简单运算（比如求最大值、最小值）、需要支持多类型、追求执行速度；
用函数：复杂逻辑（比如循环、条件判断）、需要调试、避免代码体积过大、有递归需求。

💡 补充：C++ 中的 “内联函数（inline）” 结合了宏和函数的优点 —— 像函数一样可调试、类型安全，像宏一样无调用开销，C 语言中没有内联函数，只能用宏替代简单运算。

5. ✨ #和 ## 运算符（宏的 “字符串化” 与 “符号连接”）

#和##是宏的两个特殊运算符，专门用于 “处理宏参数的文本形式”，是宏的高级用法，也是面试高频考点。

5.1 #运算符：字符串化（把参数转为字符串）

#的作用是：将宏的参数直接转为 “字符串字面值”，仅能用于带参数的宏的替换列表中。

实用场景：批量打印变量值

#include <stdio.h>

// 宏：打印变量名和值（#n把n转为字符串）
#define PRINT(n, format) printf("the value of "#n" is "format"\n", n)

int main() {
    int a = 1;
    int b = 20;
    float f = 5.6f;

    PRINT(a, "%d");  // 替换为：printf("the value of ""a"" is ""%d""\n", a);
    // 输出：the value of a is 1

    PRINT(b, "%d");  // 输出：the value of b is 20
    PRINT(f, "%f");  // 输出：the value of f is 5.600000

    return 0;
}

关键：C 语言中相邻的字符串会自动拼接（比如"a""b"等价于"ab"），所以#n生成的变量名字符串会和其他字符串拼接成完整的格式串。

5.2 ## 运算符：符号连接（把两个符号合并为一个）

##的作用是：将位于它两边的 “符号”（变量名、函数名等）合并为一个新符号，常用于批量生成相似的变量名 / 函数名。

实用场景：批量生成类型专属函数

#include <stdio.h>

// 宏：生成“类型+_max”的函数（比如int_max、float_max）
#define GENERIC_MAX(type)         \
type##_max(type x, type y) {       \
    return x > y ? x : y;          \
}

// 用宏生成两个函数：int_max（int类型最大值）、float_max（float类型最大值）
GENERIC_MAX(int)    // 替换为：int int_max(int x, int y) { return x>y?x:y; }
GENERIC_MAX(float)  // 替换为：float float_max(float x, float y) { return x>y?x:y; }

int main() {
    printf("int最大值：%d\n", int_max(3, 5));        // 输出：5
    printf("float最大值：%f\n", float_max(3.1f, 4.5f));  // 输出：4.500000
    return 0;
}

易错点：##两边的符号必须能合并成合法的标识符（比如不能合并int和123，生成int123_max是合法的，但int##123_max是非法的）。

6. 🚮 #undef：移除宏定义（灵活控制宏的生命周期）

#undef的作用是 “移除已有的宏定义”—— 之后该宏就不能再使用了，常用于 “临时使用宏” 的场景。

语法与示例：

#include <stdio.h>

#define MAX 100  // 定义宏MAX

int main() {
    printf("MAX=%d\n", MAX);  // 输出：100（宏有效）

    #undef MAX  // 移除宏MAX的定义
    // printf("MAX=%d\n", MAX);  // ❌ 错误：MAX未定义

    return 0;
}

实用场景：

宏的 “局部使用”：在代码某一段用宏，之后移除，避免影响后续代码；
重新定义宏：先移除旧宏，再定义新宏（比如#undef MAX后，#define MAX 200）。

7. 🖥️ 命令行定义（编译时动态设置宏）

C 语言支持在 “编译时” 通过命令行参数定义宏 —— 无需修改源代码，就能动态调整宏的值，常用于 “批量编译不同配置的程序”（比如调试版 / 发布版、不同硬件参数）。

实战示例（Linux/GCC 环境）：

编写源代码test.c：

#include <stdio.h>
int main() {
    // SZ是命令行定义的宏，用于设置数组大小
    int arr[SZ];
    for (int i = 0; i < SZ; i++) {
        arr[i] = i;
    }
    for (int i = 0; i < SZ; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

命令行编译（动态定义SZ=10）：

gcc test.c -D SZ=10 -o test  # -D 选项：定义宏SZ=10

运行程序：

./test  # 输出：0 1 2 3 4 5 6 7 8 9 （数组大小为10）

Windows/VS 环境实现：

在 VS 中无需命令行，可通过 “项目属性” 设置：

右键项目 → 属性 → 配置属性 → C/C++ → 预处理器；
在 “预处理器定义” 中添加SZ=10，点击确定；
编译运行，效果和命令行一致。

8. 🎯 条件编译（选择性编译代码，调试 / 跨平台必备）

条件编译的核心是 “根据条件决定哪些代码参与编译”—— 比如调试代码只在开发时编译，发布时自动剔除；跨平台代码根据系统类型编译不同逻辑。

常见条件编译指令（6 种核心）

1. 单分支条件编译（#if + #endif）

#include <stdio.h>
#define DEBUG 1  // 1：调试模式，0：发布模式

int main() {
    int arr[10] = {0};
    for (int i = 0; i < 10; i++) {
        arr[i] = i;
        #if DEBUG  // 条件为真时，下面的代码参与编译
            printf("arr[%d] = %d\n", i, arr[i]);  // 调试用的打印
        #endif  // 必须配对结束
    }
    return 0;
}

作用：通过修改DEBUG的值，快速切换 “调试版” 和 “发布版”（发布时设为 0，打印代码不编译，减少程序体积）。

2. 多分支条件编译（#if + #elif + #else + #endif）

#include <stdio.h>
#define OS 2  // 1：Windows，2：Linux，3：Mac

int main() {
    #if OS == 1
        printf("运行在Windows系统\n");
    #elif OS == 2
        printf("运行在Linux系统\n");  // 此代码参与编译
    #elif OS == 3
        printf("运行在Mac系统\n");
    #else
        printf("未知系统\n");
    #endif
    return 0;
}

适用场景：跨平台开发（不同系统的 API 不同，比如文件路径分隔符\和/）。

3. 判断宏是否被定义（#ifdef / #ifndef）

这是最常用的条件编译，用于 “判断某个宏是否存在”：

#ifdef symbol：等价于#if defined(symbol)（宏存在则编译）；
#ifndef symbol：等价于#if !defined(symbol)（宏不存在则编译）。

#include <stdio.h>

#define MAX 100  // 定义了MAX

int main() {
    // 写法1：#ifdef
    #ifdef MAX
        printf("MAX已定义：%d\n", MAX);  // 输出：MAX已定义：100
    #endif

    // 写法2：#if defined()
    #if defined(MAX)
        printf("MAX已定义：%d\n", MAX);  // 输出：MAX已定义：100
    #endif

    // 写法3：#ifndef（判断未定义）
    #ifndef MIN
        printf("MIN未定义，默认设为0\n");  // 输出：MIN未定义，默认设为0
    #endif

    return 0;
}

4. 嵌套条件编译（条件编译内部嵌套条件编译）

#include <stdio.h>
#define OS 1  // 1：Windows，2：Linux
#define DEBUG 1  // 1：调试模式

int main() {
    #if OS == 1
        printf("Windows系统\n");
        #ifdef DEBUG
            printf("调试模式：开启日志\n");  // 嵌套编译
        #endif
    #elif OS == 2
        printf("Linux系统\n");
        #ifdef DEBUG
            printf("调试模式：开启日志\n");
        #endif
    #endif
    return 0;
}

5. 强制不编译（#if 0）

#if 0等价于 “注释”，但比/* */更灵活（支持嵌套）：

#include <stdio.h>
int main() {
    printf("正常代码\n");

    #if 0  // 下面的代码不参与编译（等价于注释）
        printf("这部分代码被屏蔽\n");
        printf("支持嵌套屏蔽\n");
    #endif

    return 0;
}

适用场景：临时屏蔽一段代码（比注释方便，不用逐行加//）。

9. 📂 头文件包含（正确姿势 + 避免重复包含）

#include的作用是 “将头文件的内容插入到当前代码中”，是代码复用的核心方式 —— 比如把函数声明、宏定义放在头文件中，多个源文件共同包含。

9.1 两种包含方式："" vs <>（核心区别在查找路径）

包含方式	语法	查找路径（优先级）	适用场景
本地文件包含	#include "filename"	1. 先在当前源文件所在目录查找；2. 再去标准库路径查找	自己写的头文件（比如 add.h）
库文件包含	#include <filename>	直接去标准库路径查找（不查当前目录）	系统库头文件（比如 stdio.h）

易错点：

不要用""包含库文件：比如#include "stdio.h"，虽然可能成功，但会先查当前目录，效率低；
本地头文件路径：如果头文件在子目录，要写相对路径，比如#include "include/add.h"。

9.2 头文件重复包含问题（高频坑）

如果多个源文件都包含同一个头文件，或者头文件内部包含其他头文件，会导致 “重复定义” 错误。比如：

// add.h
int Add(int x, int y);  // 函数声明

// test1.c
#include "add.h"
#include "add.h"  // 重复包含，编译报错：重复声明

// test2.c
#include "add.h"
#include "test1.c"  // 间接重复包含，同样报错

9.3 解决重复包含：两种方案

方案 1：条件编译保护（标准方案，跨编译器兼容）

// add.h（正确写法）
#ifndef __ADD_H__  // 如果__ADD_H__未定义
#define __ADD_H__  // 定义__ADD_H__

int Add(int x, int y);  // 函数声明
struct SS {
    int arr[5];
    int n;
};

#endif  // 结束条件编译

原理：第一次包含时，__ADD_H__未定义，定义它并插入头文件内容；第二次包含时，__ADD_H__已定义，跳过内容，避免重复。
命名规范：__头文件名大写_H__（比如 add.h 对应__ADD_H__），避免和其他宏冲突。

方案 2：#pragma once（编译器扩展，简单高效）

// add.h（简单写法）
#pragma once  // 直接声明：此头文件只包含一次

int Add(int x, int y);
struct SS {
    int arr[5];
    int n;
};

优点：写法简单，不用写#ifndef/#define/#endif；
缺点：不是 C 语言标准（是编译器扩展），大部分编译器（VS、GCC、Clang）都支持，但极少数老编译器可能不兼容。

9.4 头文件包含的最佳实践

头文件只放 “声明”，不放 “定义”：比如放函数声明（int Add(int x,int y);）、宏定义、结构体声明，不要放函数实现（int Add(int x,int y){return x+y;}）—— 否则多个源文件包含会导致 “重复定义”；
每个源文件包含自己需要的头文件，不要多包含（减少编译时间）；
优先用#pragma once，追求跨编译器兼容用#ifndef保护。

10. 📌 其他预处理指令（#error、#pragma 等）

除了上面的核心指令，还有几个实用的预处理指令，虽然用得不多，但关键时刻能帮上忙。

1. #error：编译时强制报错

作用：当满足条件时，编译器直接报错并停止编译，常用于 “检查宏定义是否正确”。

#include <stdio.h>

#define OS 3  // 错误的系统类型

int main() {
    #if OS != 1 && OS != 2
        #error "OS必须定义为1（Windows）或2（Linux）！"  // 编译时报错
    #endif
    return 0;
}

编译结果：error: #error "OS必须定义为1（Windows）或2（Linux）！"

2. #pragma：编译器指令（控制编译器行为）

#pragma是给编译器的 “指令”，不同编译器支持的#pragma不同，常见用法：

#pragma pack(n)：设置结构体的内存对齐系数（比如#pragma pack(4)表示 4 字节对齐）；
#pragma warning(disable: 4996)：禁用特定警告（比如 VS 中禁用 scanf 的安全警告）；
#pragma once：头文件只包含一次（前面讲过）。

示例：禁用 VS 的 scanf 警告

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

#pragma warning(disable: 4996)  // 禁用4996号警告（scanf不安全）

int main() {
    int a;
    scanf("%d", &a);  // 不再报错
    printf("%d\n", a);
    return 0;
}

3. #line：修改行号和文件名（调试用）

作用：强制修改当前的__LINE__和__FILE__的值，常用于调试生成的代码（比如自动生成的代码定位问题）。

#include <stdio.h>

int main() {
    printf("行号：%d\n", __LINE__);  // 输出：5（当前真实行号）

    #line 100 "debug.c"  // 强制设置行号为100，文件名为"debug.c"
    printf("行号：%d，文件：%s\n", __LINE__, __FILE__);  // 输出：101，debug.c

    return 0;
}