12、宏实现泛型编程：使用宏模拟函数重载，_Generic关键字（C11），宏与_Generic的结合

泛型编程，说白了就是「同一份代码，处理不同类型的数据」。C语言没有C++的模板，但别急——我们有预处理宏和C11引入的_Generic。这两样东西组合起来，能让你写出相当优雅的泛型代码。

我个人习惯把这种技术叫做「C语言里的轻量级多态」。它不完美，但够用。我在嵌入式项目中经常用它来处理不同位宽的寄存器读写、不同精度的数学运算，效果还不错。

12.1 宏模拟函数重载：老司机的土办法

先说说函数重载。C语言不支持同名函数不同参数，但宏可以「骗」过编译器。

最简单的思路：用宏把函数名和参数类型拼接起来。

#define print_int(x)   printf("%d\n", (x))
#define print_float(x) printf("%f\n", (x))
#define print_str(x)   printf("%s\n", (x))

// 再定义一个统一的宏
#define print(x) _Generic((x), \
    int: print_int, \
    float: print_float, \
    char*: print_str, \
    default: print_str \
)(x)

你看，这里其实已经用到了_Generic。但早期没有这个关键字的时候，我们怎么做的？

嗯，那时候只能用「宏+函数名拼接」的笨办法：

// 老式做法：靠宏展开选择函数
#define print(x) \
    do { \
        if (sizeof(x) == sizeof(int)) \
            printf("%d\n", (int)(x)); \
        else if (sizeof(x) == sizeof(double)) \
            printf("%f\n", (double)(x)); \
    } while(0)

这方法有个致命问题：sizeof是在编译期求值的，但类型信息在宏展开时已经丢失了。你传一个char进去，它可能被提升为int，结果就错了。

12.2 _Generic关键字：C11带来的救星

_Generic是C11标准引入的「类型泛型表达式」。它的工作原理很简单：根据表达式的类型，在编译期选择对应的结果。

基本语法：

_Generic(控制表达式,
    类型1: 结果1,
    类型2: 结果2,
    ...
    default: 默认结果
)

注意：_Generic是编译期求值的，不会产生运行时开销。这一点在嵌入式系统里特别重要——我经常跟团队说：「能用编译期解决的问题，绝不要拖到运行时。」

来看个实际例子：

#include <stdio.h>

#define type_name(x) _Generic((x), \
    int: "int", \
    float: "float", \
    double: "double", \
    char: "char", \
    default: "unknown" \
)

int main() {
    int a = 10;
    float b = 3.14f;
    double c = 2.718;
    char d = 'A';

    printf("a is %s\n", type_name(a));  // int
    printf("b is %s\n", type_name(b));  // float
    printf("c is %s\n", type_name(c));  // double
    printf("d is %s\n", type_name(d));  // char

    return 0;
}

输出结果：

a is int
b is float
c is double
d is char

你想想看，如果没有_Generic，要实现同样的效果，你得写多少个重载函数？

12.3 宏与_Generic的黄金组合

单独用_Generic已经不错了，但和宏结合起来才是真正的王炸。宏负责「代码生成」，_Generic负责「类型分发」。

我常用的模式是这样的：

// 定义一个泛型最大值宏
#define max(a, b) _Generic((a), \
    int: max_int, \
    float: max_float, \
    double: max_double, \
    default: max_int \
)(a, b)

// 具体的函数实现
static inline int max_int(int a, int b) {
    return a > b ? a : b;
}

static inline float max_float(float a, float b) {
    return a > b ? a : b;
}

static inline double max_double(double a, double b) {
    return a > b ? a : b;
}

这里有个细节：我用static inline而不是普通函数。为什么？因为内联函数可以避免函数调用开销，而且编译器更容易优化。在嵌入式环境里，每一行代码都值得精打细算。

12.4 实战：泛型数学运算库

让我展示一个更完整的例子。假设我们要写一个支持int、float、double的「平方」运算：

#include <stdio.h>

// 具体实现
static inline int square_int(int x) {
    return x * x;
}

static inline float square_float(float x) {
    return x * x;
}

static inline double square_double(double x) {
    return x * x;
}

// 泛型宏
#define square(x) _Generic((x), \
    int: square_int, \
    float: square_float, \
    double: square_double, \
    default: square_int \
)(x)

int main() {
    int a = 5;
    float b = 2.5f;
    double c = 3.14;

    printf("square_int(%d) = %d\n", a, square(a));
    printf("square_float(%f) = %f\n", b, square(b));
    printf("square_double(%lf) = %lf\n", c, square(c));

    return 0;
}

输出：

square_int(5) = 25
square_float(2.500000) = 6.250000
square_double(3.140000) = 9.859600

你看，调用方完全不需要关心类型。传int就调square_int，传float就调square_float。这就是泛型编程的魅力。

12.5 避坑指南：_Generic的陷阱

好东西也有坑。我总结了几条经验：

• 类型必须精确匹配：_Generic不会做隐式类型转换。比如int和const int是两种类型，需要分别处理。
• 数组和指针要小心：数组名在表达式中会退化为指针，但_Generic判断的是原始类型。
• 字符串字面量是char*吗？ 不，它是char[N]类型，需要单独处理。

12.6 知识体系总览

下面这张图总结了本章的核心逻辑：

12.7 总结与建议

宏和_Generic的组合，是C语言泛型编程的「黄金搭档」。它让你在保持C语言简洁性的同时，获得了一定程度的类型灵活性。

我的建议是：

• 简单场景用宏就够了：比如定义一些常量、简单的运算。
• 需要类型分发的场景用_Generic：比如打印、比较、数学运算。
• 复杂逻辑放在内联函数里：宏只做「路由」，不要塞太多逻辑。
• 注意测试边界情况：特别是const、volatile、数组、指针这些容易出问题的类型。

最后说一句：泛型编程虽好，但不要滥用。C语言的优势在于「你知道每一行代码在干什么」。过度使用宏和_Generic会让代码变得晦涩难懂。适可而止，才是高手之道。

---

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