C 语言预处理指令与宏定义的灵活运用

运行结果：

圆的面积：12.57 1 2 3 4 5 

示例 2：定义代码片段

#include <stdio.h>
// 定义打印调试信息的宏
#define PRINT_DEBUG printf("文件：%s，行号：%d\n", __FILE__, __LINE__);

int main() {
    int a = 10;
    if (a > 5) {
        PRINT_DEBUG printf("a 的值大于 5\n");
    }
    return 0;
}

运行结果：

文件：test.c，行号：8 a 的值大于 5 

💡 技巧：C 语言提供了几个内置宏，常用于调试：

• __FILE__：当前源文件的文件名（字符串）
• __LINE__：当前代码的行号（整数）
• __DATE__：编译日期（字符串）
• __TIME__：编译时间（字符串）

43.2.2 带参数的宏定义

💡 语法格式：#define 宏名 (参数列表) 宏体
功能：类似函数调用，将宏名和参数替换为宏体对应的文本，实现代码复用。
适用场景：实现简单的运算、类型转换、代码封装等。

示例 1：实现两数求和

#include <stdio.h>
// 定义求和宏
#define ADD(a, b) ((a) + (b))

int main() {
    int x = 10, y = 20;
    // 预处理后变为：int sum = (10 + 20);
    int sum = ADD(x, y);
    printf("sum = %d\n", sum);
    return 0;
}

运行结果：

sum = 30 

示例 2：实现数值比较

#include <stdio.h>
// 定义求最大值的宏
#define MAX(a, b) (((a) > (b)) ? (a) : (b))

int main() {
    int m = 15, n = 25;
    int max_val = MAX(m, n);
    printf("最大值：%d\n", max_val);
    // 支持表达式作为参数
    int a = 10, b = 20;
    int res = MAX(a + 5, b - 5);
    printf("表达式最大值：%d\n", res);
    return 0;
}

运行结果：

最大值：25 表达式最大值：15 

⚠️ 注意：带参数的宏定义有多个陷阱，必须注意：

1. 宏定义不检查参数类型，不像函数那样有类型安全检查
2. 宏体不要写过长代码，否则会降低代码可读性

参数和宏体必须加括号，避免运算符优先级导致的错误

// 错误写法：
// #define MUL(a,b) a*b
// 调用 MUL(2+3,4) 会被替换为 2+3*4=14，而非预期的 20

宏名与括号之间不能有空格，否则会被识别为不带参数的宏

// 错误写法：
// #define MAX (a,b) ((a)>(b)?(a):(b))

43.2.3 取消宏定义（#undef）

💡 语法格式：#undef 宏名
功能：取消已定义的宏，使其在后续代码中失效。

示例：取消宏定义

#include <stdio.h>
#define MSG "Hello Macro"

int main() {
    printf("%s\n", MSG); // 正常输出
    // 取消宏定义
    #undef MSG
    // 下面代码会编译错误，因为 MSG 已失效
    // printf("%s\n", MSG);
    return 0;
}

运行结果：

Hello Macro 

43.3 文件包含指令（#include）

#include 指令用于将指定的头文件内容，完整复制到当前源文件中，是实现代码模块化的核心手段。

43.3.1 两种包含方式的区别

💡 C 语言提供了两种头文件包含方式，适用场景不同：

1. 尖括号包含：#include <头文件名>
   • 用于包含系统头文件，如 stdio.h、stdlib.h
   • 预处理器会到系统指定的头文件目录中查找
2. 双引号包含：#include "头文件名"
   • 用于包含自定义头文件，如 myfunc.h
   • 预处理器先在当前源文件目录查找，找不到再去系统目录查找

43.3.2 头文件包含的注意事项

⚠️ 注意：头文件包含是文本复制，不当使用会导致编译错误或代码冗余：

1. 头文件不要包含实现代码
   头文件应只放函数声明、宏定义、结构体定义，函数的实现代码应放在 .c 文件中，否则会导致重复定义错误。
2. 合理组织头文件结构
   大型项目应按功能模块划分头文件，避免一个头文件包含过多内容。

避免重复包含
同一个头文件被多次包含，会导致重复定义错误。解决方法是使用头文件保护。
方案 1：使用 #ifndef 保护

// myfunc.h
#ifndef _MYFUNC_H_
#define _MYFUNC_H_
// 头文件内容
void func();
#endif

方案 2：使用 #pragma once 保护

// myfunc.h
#pragma once
// 头文件内容
void func();

✅ 结论：#pragma once 是编译器扩展指令，使用更简洁；#ifndef 是标准语法，兼容性更好。

43.4 条件编译指令

条件编译指令可以让预处理器根据指定条件，选择性地编译部分代码，常用于跨平台开发、调试模式切换等场景。

43.4.1 常用条件编译指令

C 语言的条件编译指令组合使用，语法类似 if-else 语句：

• #ifdef 宏名：如果宏已定义，则编译后续代码
• #ifndef 宏名：如果宏未定义，则编译后续代码
• #if 常量表达式：如果表达式为真，则编译后续代码
• #else：条件不满足时的备选代码块
• #elif：相当于 else if
• #endif：结束条件编译块

43.4.2 实战场景 1：跨平台开发

🔧 需求：编写跨 Windows 和 Linux 平台的代码，根据不同系统调用不同的函数。

#include <stdio.h>
// 模拟定义系统宏
// Windows 系统会自动定义 _WIN32 宏
// Linux 系统会自动定义 __linux__ 宏
#define _WIN32

int main() {
#ifdef _WIN32
    printf("当前系统：Windows\n");
    printf("使用 Windows API\n");
#elif defined(__linux__)
    printf("当前系统：Linux\n");
    printf("使用 Linux 系统调用\n");
#else
    printf("当前系统：未知\n");
#endif
    return 0;
}

运行结果：

当前系统：Windows 使用 Windows API 

43.4.3 实战场景 2：调试模式切换

🔧 需求：通过定义 DEBUG 宏，控制调试信息的打印，发布版本关闭调试。

#include <stdio.h>
// 打开调试模式
#define DEBUG

int main() {
    int a = 10, b = 20;
    int sum = a + b;
#ifdef DEBUG
    printf("[调试信息] a=%d, b=%d, sum=%d\n", a, b, sum);
#endif
    printf("计算结果：%d\n", sum);
    return 0;
}

运行结果：

[调试信息] a=10, b=20, sum=30 计算结果：30 

💡 技巧：编译时可以通过编译器参数定义宏，无需修改代码：

# gcc 编译时定义 DEBUG 宏
gcc test.c -o test -D DEBUG

43.4.4 实战场景 3：代码版本控制

🔧 需求：通过宏控制代码的版本，区分基础版和高级版功能。

#include <stdio.h>
// 定义高级版
#define ADVANCED_VERSION

int main() {
    printf("基础功能：数据计算\n");
#ifdef ADVANCED_VERSION
    printf("高级功能：数据加密\n");
    printf("高级功能：数据备份\n");
#endif
    return 0;
}

运行结果：

基础功能：数据计算 高级功能：数据加密 高级功能：数据备份 

43.5 预处理指令的实战案例

43.5.1 案例 1：使用宏定义实现安全的内存分配

🔧 需求：封装 malloc 函数，实现带错误检查的内存分配宏，避免重复编写错误处理代码。

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

// 定义安全内存分配宏
#define SAFE_MALLOC(ptr, type, size) \n    do { \n        ptr = (type*)malloc(sizeof(type) * size); \n        if (ptr == NULL) { \n            printf("内存分配失败：文件%s，行号%d\n", __FILE__, __LINE__); \n            exit(1); \n        } \n    } while (0)

int main() {
    int *arr;
    // 使用宏分配内存
    SAFE_MALLOC(arr, int, 5);
    // 赋值并打印
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
        printf("%d ", arr[i]);
    }
    free(arr); 
    arr = NULL;
    return 0;
}

运行结果：

1 2 3 4 5 

💡 技巧：使用 do-while(0) 包裹宏体，可以让宏支持分号结尾，且能在 if-else 中安全使用。

43.5.2 案例 2：使用条件编译实现日志系统

🔧 需求：实现一个支持不同日志级别的日志系统，通过宏控制日志的输出。

#include <stdio.h>
#include <time.h>

// 定义日志级别
#define LOG_LEVEL 3
// 0-无日志 1-错误 2-警告 3-信息

// 定义获取当前时间的宏
#define GET_TIME() \n    do { \n        time_t now = time(NULL); \n        printf("[%s]", ctime(&now)); \n    } while (0)

// 定义不同级别的日志宏
#if LOG_LEVEL >= 1
#define LOG_ERROR(msg) \n    do { \n        GET_TIME(); \n        printf("[错误] %s\n", msg); \n    } while (0)
#else
#define LOG_ERROR(msg)
#endif

#if LOG_LEVEL >= 2
#define LOG_WARN(msg) \n    do { \n        GET_TIME(); \n        printf("[警告] %s\n", msg); \n    } while (0)
#else
#define LOG_WARN(msg)
#endif

#if LOG_LEVEL >= 3
#define LOG_INFO(msg) \n    do { \n        GET_TIME(); \n        printf("[信息] %s\n", msg); \n    } while (0)
#else
#define LOG_INFO(msg)
#endif

int main() {
    LOG_INFO("程序启动");
    LOG_WARN("内存使用率过高");
    LOG_ERROR("文件读取失败");
    return 0;
}

运行结果：

[Thu May 25 10:00:00 2025] [信息] 程序启动 [Thu May 25 10:00:00 2025] [警告] 内存使用率过高 [Thu May 25 10:00:00 2025] [错误] 文件读取失败 

43.6 预处理指令的常见问题与解决方案

43.6.1 问题 1：宏定义的参数副作用

❌ 错误代码：宏参数使用自增/自减运算符，导致参数被多次计算

#define MAX(a,b) (((a)>(b))?(a):(b))
int x=5, y=10;
// 预处理后变为：((x++)>(y++)?(x++):(y++))
int res = MAX(x++, y++);
// x=6, y=12, res=11，结果不符合预期

✅ 解决方案：避免在宏参数中使用带有副作用的表达式，如 x++、y--、func() 等。

43.6.2 问题 2：头文件重复包含

❌ 错误现象：编译时报错 multiple definition of xxx，原因是同一个头文件被多次包含。
✅ 解决方案：使用 #ifndef 或 #pragma once 为头文件添加保护，避免重复包含。

43.6.3 问题 3：宏定义与关键字重名

❌ 错误代码：宏名使用了 C 语言关键字，导致编译错误

#define if 1
if (a > 5) {...} // 预处理后变为 1 (a>5) { ... }，语法错误

✅ 解决方案：宏名命名时避免使用 C 语言关键字，建议使用大写字母，并添加前缀/后缀，如 MAX_VAL、PRINT_DEBUG。

43.7 本章小结

✅ 预处理是 C 语言程序执行的第一步，预处理指令以 # 开头，作用是对源代码进行文本处理。
✅ 宏定义分为不带参数和带参数两种，核心是文本替换，使用时要注意加括号、避免副作用。
✅ #include 指令用于包含头文件，尖括号用于系统头文件，双引号用于自定义头文件，需添加头文件保护。
✅ 条件编译指令可以实现代码的选择性编译，常用于跨平台开发、调试模式切换、版本控制等场景。
✅ 合理使用预处理指令，能够提升代码的可移植性、可读性和复用性，是 C 语言进阶的必备技能。