如果你的编译器支持，试着将这些函数声明为extern " c++ "， http://msdn.microsoft.com/en-us/library/s6y4zxec(VS.80).aspx

如前所述，c不支持重载。解决这个问题的常用方法是让函数接受带标签的联合。这是通过一个struct形参实现的，其中struct本身由某种类型指示符(例如枚举)和不同类型值的并集组成。例子:

#include <stdio.h>

typedef enum {
    T_INT,
    T_FLOAT,
    T_CHAR,
} my_type;

typedef struct {
    my_type type;
    union {
        int a; 
        float b; 
        char c;
    } my_union;
} my_struct;

void set_overload (my_struct *whatever) 
{
    switch (whatever->type) 
    {
        case T_INT:
            whatever->my_union.a = 1;
            break;
        case T_FLOAT:
            whatever->my_union.b = 2.0;
            break;
        case T_CHAR:
            whatever->my_union.c = '3';
    }
}

void printf_overload (my_struct *whatever) {
    switch (whatever->type) 
    {
        case T_INT:
            printf("%d\n", whatever->my_union.a);
            break;
        case T_FLOAT:
            printf("%f\n", whatever->my_union.b);
            break;
        case T_CHAR:
            printf("%c\n", whatever->my_union.c);
            break;
    }

}

int main (int argc, char* argv[])
{
    my_struct s;

    s.type=T_INT;
    set_overload(&s);
    printf_overload(&s);

    s.type=T_FLOAT;
    set_overload(&s);
    printf_overload(&s);

    s.type=T_CHAR;
    set_overload(&s);
    printf_overload(&s); 
}

如果你的编译器支持，试着将这些函数声明为extern " c++ "， http://msdn.microsoft.com/en-us/library/s6y4zxec(VS.80).aspx

这可能没有任何帮助，但如果你使用clang，你可以使用overloadable属性-即使在编译为C时也可以

http://clang.llvm.org/docs/AttributeReference.html#overloadable

头

extern void DecodeImageNow(CGImageRef image, CGContextRef usingContext) __attribute__((overloadable));
extern void DecodeImageNow(CGImageRef image) __attribute__((overloadable));

实现

void __attribute__((overloadable)) DecodeImageNow(CGImageRef image, CGContextRef usingContext { ... }
void __attribute__((overloadable)) DecodeImageNow(CGImageRef image) { ... }

Leushenko的答案真的很酷——仅仅是:foo的例子没有使用GCC编译，它在foo(7)处失败，绊倒了FIRST宏和实际的函数调用((_1，__VA_ARGS__)，剩下一个多余的逗号。此外，如果我们想提供额外的重载，比如foo(double)，就会遇到麻烦。

因此，我决定进一步详细说明答案，包括允许void重载(foo(void) -这造成了相当大的麻烦…)

现在的想法是:在不同的宏中定义多个泛型，让我们根据参数的数量选择正确的一个!

参数的数量很简单，基于这个答案:

#define foo(...) SELECT(__VA_ARGS__)(__VA_ARGS__)

#define SELECT(...) CONCAT(SELECT_, NARG(__VA_ARGS__))(__VA_ARGS__)
#define CONCAT(X, Y) CONCAT_(X, Y)
#define CONCAT_(X, Y) X ## Y

这很好，我们解析为SELECT_1或SELECT_2(或更多参数，如果你想要/需要它们)，所以我们只需要适当的定义:

#define SELECT_0() foo_void
#define SELECT_1(_1) _Generic ((_1),    \
        int: foo_int,                   \
        char: foo_char,                 \
        double: foo_double              \
)
#define SELECT_2(_1, _2) _Generic((_1), \
        double: _Generic((_2),          \
                int: foo_double_int     \
        )                               \
)

好吧，我已经添加了void重载-然而，这实际上是不被C标准覆盖的，它不允许空的可变参数，也就是说，我们依赖于编译器扩展!

首先，一个空宏调用(foo())仍然产生一个令牌，但是是一个空令牌。计数宏实际上返回1而不是0，即使是空宏调用。我们可以“轻松”消除这个问题，如果我们有条件地在__VA_ARGS__后面加上逗号，这取决于列表是否为空:

#define NARG(...) ARG4_(__VA_ARGS__ COMMA(__VA_ARGS__) 4, 3, 2, 1, 0)

这看起来很简单，但是逗号宏是一个相当沉重的宏;幸运的是，这个话题已经在Jens Gustedt的博客中提到了(谢谢，Jens)。基本的技巧是，如果函数宏后面没有括号，就不会展开，要进一步解释，可以看看Jens的博客…我们只需要根据需要稍微修改一下宏(为了简洁起见，我将使用更短的名称和更少的参数)。

#define ARGN(...) ARGN_(__VA_ARGS__)
#define ARGN_(_0, _1, _2, _3, N, ...) N
#define HAS_COMMA(...) ARGN(__VA_ARGS__, 1, 1, 1, 0)

#define SET_COMMA(...) ,

#define COMMA(...) SELECT_COMMA             \
(                                           \
        HAS_COMMA(__VA_ARGS__),             \
        HAS_COMMA(__VA_ARGS__ ()),          \
        HAS_COMMA(SET_COMMA __VA_ARGS__),   \
        HAS_COMMA(SET_COMMA __VA_ARGS__ ()) \
)

#define SELECT_COMMA(_0, _1, _2, _3) SELECT_COMMA_(_0, _1, _2, _3)
#define SELECT_COMMA_(_0, _1, _2, _3) COMMA_ ## _0 ## _1 ## _2 ## _3

#define COMMA_0000 ,
#define COMMA_0001
#define COMMA_0010 ,
// ... (all others with comma)
#define COMMA_1111 ,

现在我们没事了……

完整的代码在一个块:

/*
 * demo.c
 *
 *  Created on: 2017-09-14
 *      Author: sboehler
 */

#include <stdio.h>

void foo_void(void)
{
    puts("void");
}
void foo_int(int c)
{
    printf("int: %d\n", c);
}
void foo_char(char c)
{
    printf("char: %c\n", c);
}
void foo_double(double c)
{
    printf("double: %.2f\n", c);
}
void foo_double_int(double c, int d)
{
    printf("double: %.2f, int: %d\n", c, d);
}

#define foo(...) SELECT(__VA_ARGS__)(__VA_ARGS__)

#define SELECT(...) CONCAT(SELECT_, NARG(__VA_ARGS__))(__VA_ARGS__)
#define CONCAT(X, Y) CONCAT_(X, Y)
#define CONCAT_(X, Y) X ## Y

#define SELECT_0() foo_void
#define SELECT_1(_1) _Generic ((_1), \
        int: foo_int,                \
        char: foo_char,              \
        double: foo_double           \
)
#define SELECT_2(_1, _2) _Generic((_1), \
        double: _Generic((_2),          \
                int: foo_double_int     \
        )                               \
)

#define ARGN(...) ARGN_(__VA_ARGS__)
#define ARGN_(_0, _1, _2, N, ...) N

#define NARG(...) ARGN(__VA_ARGS__ COMMA(__VA_ARGS__) 3, 2, 1, 0)
#define HAS_COMMA(...) ARGN(__VA_ARGS__, 1, 1, 0)

#define SET_COMMA(...) ,

#define COMMA(...) SELECT_COMMA             \
(                                           \
        HAS_COMMA(__VA_ARGS__),             \
        HAS_COMMA(__VA_ARGS__ ()),          \
        HAS_COMMA(SET_COMMA __VA_ARGS__),   \
        HAS_COMMA(SET_COMMA __VA_ARGS__ ()) \
)

#define SELECT_COMMA(_0, _1, _2, _3) SELECT_COMMA_(_0, _1, _2, _3)
#define SELECT_COMMA_(_0, _1, _2, _3) COMMA_ ## _0 ## _1 ## _2 ## _3

#define COMMA_0000 ,
#define COMMA_0001
#define COMMA_0010 ,
#define COMMA_0011 ,
#define COMMA_0100 ,
#define COMMA_0101 ,
#define COMMA_0110 ,
#define COMMA_0111 ,
#define COMMA_1000 ,
#define COMMA_1001 ,
#define COMMA_1010 ,
#define COMMA_1011 ,
#define COMMA_1100 ,
#define COMMA_1101 ,
#define COMMA_1110 ,
#define COMMA_1111 ,

int main(int argc, char** argv)
{
    foo();
    foo(7);
    foo(10.12);
    foo(12.10, 7);
    foo((char)'s');

    return 0;
}

通常在名称前附加或加一个表示类型的疣子。在某些实例中，可以不使用宏，但这取决于您要做什么。C中没有多态性，只有强制。

简单的泛型操作可以用宏完成:

#define max(x,y) ((x)>(y)?(x):(y))

如果你的编译器支持typeof，更复杂的操作可以放在宏中。然后可以使用符号foo(x)来支持不同类型的相同操作，但不能在不同重载之间改变行为。如果需要实际的函数而不是宏，则可以将类型粘贴到名称上，然后使用第二次粘贴来访问它(我还没有尝试过)。