[C语言]：预编译指令

C语言作为编译型语言，源代码无法直接执行，必须经过预处理、编译、汇编、链接四个核心步骤才能生成可执行文件。其中，预编译是整个过程的第一步，由预处理器完成，主要对源代码中的预编译指令进行处理，为后续编译工作铺路。

一、预编译的核心作用

预编译阶段主要完成以下三项关键操作，且处理结果会直接替换到源代码中：

1. 头文件包含：将#include指定的文件内容完整插入到指令位置；
2. 注释删除：移除所有//和/*...*/格式的注释，避免编译干扰；
3. 宏定义替换：对#define定义的常量、宏进行字符串替换。

预编译仅做“文本层面”的处理，不进行代码语法分析。

二、核心预编译指令详解

2.1 #define：宏定义指令

#define是预编译中最常用的指令，用于定义常量或带参数的宏，本质是字符串替换，替换过程发生在预编译阶段，不占用运行时资源。

2.1.1 定义常量

直接定义一个常量符号，替换时仅做字符串替换，无需加分号（否则会导致额外语法问题）。

#define TWO 2       // 定义常量TWO，值为2
#define FOUR TWO*TWO // 嵌套使用已定义的宏
int main() {
    int x = TWO;    // 预编译后替换为 int x = 2;
    printf("%d\n", x); // 输出2
    x = FOUR;       // 预编译后替换为 x = 2*2;
    printf("%d\n", x); // 输出4
    return 0;
}

注意：定义常量时末尾不要加;，否则会出现类似x = 2;;的语法冗余。

2.1.2 定义带参数的宏

宏可以接收参数，实现简单的运算逻辑，替换时会将参数直接代入宏体。但需注意运算符优先级问题，建议给宏体和参数都加上括号。

// 错误示例：未加括号导致优先级问题
#define SQUARE(x) x*x 
int main() {
    int a = 3;
    printf("%d\n", SQUARE(a+1)); 
    return 0;
}
// 正确示例
#define SQUARE(x) ((x)*(x))
int main() {
    int a = 3;
    printf("%d\n", SQUARE(a+1)); // 预编译后为 ((3+1)*(3+1))=16，符合预期
    return 0;
}

2.1.3 带有副作用的宏参数

宏参数在宏体中出现多次时，若参数是“有副作用的表达式”（如x++、x--，求值后会改变变量本身），会导致不可预测的结果。

#define MAX(a,b) ((a)>(b)?(a):(b))
int main() {
    int x = 10;
    int y = 20;
    int z = MAX(x++, y++); // 宏体中a=x++、b=y++各出现1次，会执行两次自增
    printf("x=%d, y=%d, z=%d\n", x, y, z); // 输出 x=11, y=22, z=21（而非预期的x=11,y=21,z=20）
    return 0;
}

原因：MAX(x++,y++)替换后为((x++)>(y++)?(x++):(y++))，x++和y++各执行两次，导致变量值异常递增。

2.1.4 宏替换规则

宏替换遵循严格的步骤，确保所有相关符号都被正确替换：

1. 扫描宏参数，若参数中包含其他#define定义的符号，先替换这些符号；
2. 将替换后的参数代入宏体，生成替换文本；
3. 再次扫描替换后的文本，若仍有未替换的#define符号，重复上述过程。
   注意事项：

• 宏可以嵌套使用其他宏，但不能递归（如#define FAC(x) (x)*FAC(x-1)会报错）；
• 字符串常量中的符号不会被替换（如printf("MAX=%d", MAX)中，"MAX"里的MAX仅为字符串，不替换）。

2.2 #undef：移除宏定义

#undef用于取消已定义的宏或常量，后续代码中该宏将不再生效。

#include <stdio.h>
#define MAX 100
int main() {
    printf("%d\n", MAX); // 正常输出100，MAX有效
    #undef MAX           // 移除MAX的定义
    // printf("%d\n", MAX); // 报错：MAX未定义
    return 0;
}

实用场景：在调试代码时临时定义宏，调试结束后用#undef取消，切换到生产模式。

2.3 条件编译：按需编译代码

条件编译允许根据指定条件决定代码是否参与编译，核心是“满足条件则保留代码，不满足则剔除”，常用于调试、跨平台适配等场景。

2.3.1 单分支条件编译

语法：#if 常量表达式 + #endif，表达式为真则编译中间代码。

#define DEBUG 1 // 开启调试模式
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;
}

2.3.2 多分支条件编译

语法：#if + #elif + #else + #endif，支持多条件分支选择。

#define DEBUG_LEVEL 2 // 0=关闭，1=基础调试，2=详细调试
void process_data(int data) {
    #if DEBUG_LEVEL >= 1
    printf("[INFO] 开始处理数据：%d\n", data); // 基础调试信息
    #elif DEBUG_LEVEL >= 2
    printf("[DEBUG] 数据原始值：%d\n", data); // 详细调试信息
    #else
    // 生产模式，无调试输出
    #endif
    data *= 2;
    #if DEBUG_LEVEL >= 1
    printf("[INFO] 处理后数据：%d\n", data);
    #endif
}

2.3.3 判断符号是否定义

用于检查某个宏是否已被定义，有两种等价写法：

• 检查是否定义：#ifdef 符号 等价于 #if defined(符号)
• 检查是否未定义：#ifndef 符号 等价于 #if !defined(符号)

#define MIN 10
int main() {
    #if !defined(MAX) // 若MAX未定义
        #ifdef MIN    // 若MIN已定义
        printf("hello\n"); // 输出hello
        #else
        printf("world\n");
        #endif
    #endif
    return 0;
}

2.3.4 嵌套条件编译

条件编译可以嵌套使用，实现更复杂的编译逻辑：

#define PLATFORM "WINDOWS"
#define DEBUG 1
int main() {
    #ifdef PLATFORM
        #if PLATFORM == "WINDOWS"
            #if DEBUG
            printf("Windows 调试模式\n");
            #else
            printf("Windows 生产模式\n");
            #endif
        #elif PLATFORM == "LINUX"
            printf("Linux 系统\n");
        #endif
    #endif
    return 0;
}

2.4 #include：头文件包含

#include指令用于将其他文件（通常是头文件.h）的内容插入到当前文件中，是代码复用和模块化开发的基础。

2.4.1 两种包含方式的区别

头文件包含有两种语法格式，查找路径不同：

#include <stdio.h>   // 包含系统库头文件，使用尖括号
#include "mytool.h"  // 包含自定义头文件，使用双引号

2.4.2 头文件重复包含问题

当多个头文件相互包含或同一头文件被多次包含时，会导致重复定义错误（如结构体、宏重复声明）。

// 问题场景：main.c 包含 a.h 和 b.h，a.h 和 b.h 都包含 common.h
// common.h 中定义了结构体 Point，会被重复包含两次，编译报错
struct Point { // 第一次定义（来自a.h）
    int x;
    int y;
};
struct Point { // 第二次定义（来自b.h），报错：redefinition of 'struct Point'
    int x;
    int y;
};

2.4.3 解决重复包含的两种方案

方案1：#ifndef 保护（兼容所有编译器）

在头文件开头添加“未定义检查”，确保仅在第一次包含时执行定义：

// common.h
#ifndef COMMON_H   // 若 COMMON_H 未定义
#define COMMON_H   // 定义 COMMON_H，标记已包含
#define MAX_SIZE 100
struct Point {
    int x;
    int y;
};
void print_point(struct Point p);
#endif // 结束检查

方案2：#pragma once

更简洁的方式，直接告诉编译器该文件仅包含一次，无需手动定义标记：

// common.h
#pragma once // 仅包含一次，避免重复
#define MAX_SIZE 100
struct Point {
    int x;
    int y;
};
void print_point(struct Point p);

三、宏与函数的对比

适用场景：

• 宏：简单运算（如求最大值、平方）、代码片段复用（如调试打印），追求执行效率；
• 函数：复杂逻辑、需要类型检查、代码量较大的场景，追求代码严谨性和可维护性。

四、预编译的实用技巧

1. 调试开关：用#define DEBUG 1开启调试，#undef DEBUG关闭，无需删除调试代码；
2. 跨平台适配：通过条件编译判断系统类型，适配不同平台的API（如Windows的Win32和Linux的POSIX）；
3. 简化重复代码：用带参数的宏封装重复逻辑（如内存分配），减少冗余：

#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main() {
    int* p = MALLOC(10, int); // 预编译后为 (int*)malloc(10*sizeof(int))
    free(p);
    return 0;
}

4. 避免宏的副作用：带参数的宏中，参数尽量使用无副作用的表达式（如x+1而非x++）。