28、宏实现字符串操作：字符串拼接宏，字符串化宏，字符串表生成宏

说到C语言的宏，很多人第一反应就是「不就是个文本替换嘛」。嗯，这话没错，但只说对了一半。宏在字符串操作这块，其实藏着不少黑科技。我个人做嵌入式项目这么多年，发现用好这几个字符串相关的宏，能让代码变得特别清爽，尤其是处理那些重复性的枚举、寄存器定义时。

今天咱们就聊聊三个实用技巧：字符串拼接宏、字符串化宏、还有字符串表生成宏。这三个东西单独看都不难，但组合起来威力不小。

28.1 字符串化宏（#运算符）

先说说最简单的。你写代码时有没有遇到过这种情况：想打印某个变量的名字，而不是它的值？比如调试时，我想输出「当前变量 a 的值是 5」，而不是「当前变量 5 的值是 5」。

这时候#运算符就派上用场了。它能把宏参数变成字符串字面量。

#define STRINGIFY(x)   #x

int main() {
    int temperature = 85;
    printf("%s = %d\n", STRINGIFY(temperature), temperature);
    return 0;
}

输出结果：

temperature = 85

你看，宏展开后，STRINGIFY(temperature)直接变成了"temperature"这个字符串。我在调试传感器驱动时经常用这招，把寄存器名字和值一起打印出来，一眼就能看出问题在哪。

#define STRINGIFY2(x)   #x
#define STRINGIFY(x)    STRINGIFY2(x)

#define VERSION  102
printf("Version: %s\n", STRINGIFY(VERSION));  // 输出 "Version: 102"

28.2 字符串拼接宏（##运算符）

##运算符，说白了就是把两个记号粘在一起。这个在生成标识符时特别好用。

举个例子，我做过一个项目，有多个同类型的传感器，每个传感器都有初始化、读取、校准三个函数。如果手动写，代码会又臭又长：

void sensor1_init(void);
int  sensor1_read(void);
void sensor1_calibrate(void);

void sensor2_init(void);
int  sensor2_read(void);
void sensor2_calibrate(void);
// ... 还有 sensor3, sensor4 ...

用##可以这样：

#define DECLARE_SENSOR(n)          \
    void sensor##n##_init(void);   \
    int  sensor##n##_read(void);   \
    void sensor##n##_calibrate(void)

DECLARE_SENSOR(1)
DECLARE_SENSOR(2)
DECLARE_SENSOR(3)

预处理器展开后，就是上面那一大堆声明。代码量瞬间少了一半。

28.3 字符串表生成宏（X-Macro 模式）

这个是我个人最喜欢的技巧。X-Macro，也叫「表格驱动宏」，它能把数据定义和代码生成彻底分开。

你想想看，很多时候我们需要维护一个「名字 ↔ 值」的对应关系。比如错误码：

#define ERR_OK          0
#define ERR_TIMEOUT     1
#define ERR_OVERRUN     2
#define ERR_CRC         3

然后你还得写一个对应的错误描述字符串数组：

const char* err_str[] = {
    "OK",
    "Timeout",
    "Overrun",
    "CRC Error"
};

问题来了：如果新增一个错误码，你得在两个地方同时修改。漏改一个，bug就来了。我曾经就因为这个吃过亏，排查了半天才发现错误码和描述对不上。

X-Macro 可以完美解决这个问题。思路是这样的：

第一步，定义一个「数据表宏」，把所有信息放在一个地方：

#define ERROR_TABLE \
    X(ERR_OK,      0, "OK")          \
    X(ERR_TIMEOUT, 1, "Timeout")     \
    X(ERR_OVERRUN, 2, "Overrun")     \
    X(ERR_CRC,     3, "CRC Error")

第二步，用不同的宏定义来「展开」这张表：

// 生成枚举
#define X(name, val, str)  name = val,
enum ErrorCode {
    ERROR_TABLE
};
#undef X

// 生成字符串数组
#define X(name, val, str)  str,
const char* error_strings[] = {
    ERROR_TABLE
};
#undef X

预处理器展开后，就变成了：

enum ErrorCode {
    ERR_OK = 0,
    ERR_TIMEOUT = 1,
    ERR_OVERRUN = 2,
    ERR_CRC = 3,
};

const char* error_strings[] = {
    "OK",
    "Timeout",
    "Overrun",
    "CRC Error",
};

你看，只需要维护ERROR_TABLE这一个地方，枚举和字符串数组自动同步。新增一个错误码，加一行就行，绝对不会漏。

28.4 组合使用：一个完整的例子

下面我把#、##和X-Macro组合起来，做一个寄存器定义和调试打印的完整示例。

// 寄存器表
#define REG_TABLE \
    X(REG_CTRL,  0x00, "控制寄存器")  \
    X(REG_STATUS,0x01, "状态寄存器")  \
    X(REG_DATA,  0x02, "数据寄存器")  \
    X(REG_INT,   0x03, "中断寄存器")

// 生成寄存器地址枚举
#define X(name, addr, desc)  name = addr,
enum RegAddr {
    REG_TABLE
};
#undef X

// 生成寄存器名字字符串数组
#define X(name, addr, desc)  #name,
const char* reg_name[] = {
    REG_TABLE
};
#undef X

// 生成寄存器描述字符串数组
#define X(name, addr, desc)  desc,
const char* reg_desc[] = {
    REG_TABLE
};
#undef X

// 调试打印函数
void dump_reg(uint8_t addr, uint8_t val) {
    for (int i = 0; i < sizeof(reg_name)/sizeof(reg_name[0]); i++) {
        if (addr == (uint8_t)(REG_CTRL + i)) {  // 这里简化了地址匹配
            printf("[0x%02X] %s (%s) = 0x%02X\n",
                   addr, reg_name[i], reg_desc[i], val);
            return;
        }
    }
    printf("[0x%02X] 未知寄存器 = 0x%02X\n", addr, val);
}

输出效果：

[0x00] REG_CTRL (控制寄存器) = 0xA5
[0x01] REG_STATUS (状态寄存器) = 0x00

这个例子中，#name把枚举名变成了字符串，desc直接就是描述文本。所有信息都集中在REG_TABLE里，维护起来特别方便。

28.5 避坑指南

用这些宏的时候，有几个坑我踩过，分享给你：

• 宏参数不要有副作用：比如STRINGIFY(x++)，宏展开后x++会被当成字符串，不会执行自增。但如果你在宏里用了参数多次，那就惨了。
• X-Macro 的换行符：每行末尾的\后面不能有空格或制表符，否则预处理器会报错。我习惯用\后直接回车，养成肌肉记忆。
• 不要滥用：X-Macro 虽然强大，但过度使用会让代码变得难以调试。毕竟宏展开后的代码，调试器里看不到原始行号。我的原则是：只有「数据定义」和「代码生成」分离的场景才用，简单的常量定义没必要。

28.6 知识体系总览

下面这张图总结了本章的核心内容，你可以对照着回顾一下：

好了，关于宏实现字符串操作的内容就这些。记住一个原则：能用宏减少重复劳动的地方就用，但别为了炫技而用。实际项目中，X-Macro 和字符串化是我用得最多的，拼接宏偶尔用在生成函数名上。你可以在自己的项目里试试，从简单的调试打印开始，慢慢就能体会到它的好处了。

公众号:蓝海资料掘金营，微信deep3321