有没有办法在 C 中实现函数重载？我正在寻找要重载的简单函数，例如
foo (int a)
foo (char b)
foo (float c , int d)
我认为没有直接的方法；如果有的话，我正在寻找解决方法。
问问题
226716 次
14 回答
290
是的！
自从提出这个问题以来，由于在 C11 中添加了关键字，标准 C（无扩展）有效地获得了对函数重载（不是运算符）的支持。_Generic（从 4.9 版开始在 GCC 中支持）
（重载并不是问题中显示的真正“内置”的方式，但实现这样的工作非常容易。）
_Genericsizeof是与和同族的编译时运算符_Alignof。它在标准部分 6.5.1.1 中进行了描述。它接受两个主要参数：一个表达式（不会在运行时计算）和一个看起来有点像switch块的类型/表达式关联列表。_Generic获取表达式的整体类型，然后对其进行“切换”以在列表中为其类型选择最终结果表达式：
_Generic(1, float: 2.0,
char *: "2",
int: 2,
default: get_two_object());
上述表达式的计算结果为2- 控制表达式的类型是int，因此它选择与关联的表达式int作为值。在运行时没有任何内容。（该default子句是可选的：如果您将其关闭并且类型不匹配，则会导致编译错误。）
这对函数重载有用的方式是它可以由 C 预处理器插入，并根据传递给控制宏的参数类型选择结果表达式。因此（来自 C 标准的示例）：
#define cbrt(X) _Generic((X), \
long double: cbrtl, \
default: cbrt, \
float: cbrtf \
)(X)
这个宏实现了一个重载cbrt操作，通过将参数的类型分派给宏，选择适当的实现函数，然后将原始宏参数传递给该函数。
因此，要实现您的原始示例，我们可以这样做：
foo_int (int a)
foo_char (char b)
foo_float_int (float c , int d)
#define foo(_1, ...) _Generic((_1), \
int: foo_int, \
char: foo_char, \
float: _Generic((FIRST(__VA_ARGS__,)), \
int: foo_float_int))(_1, __VA_ARGS__)
#define FIRST(A, ...) A
在这种情况下，我们可以default:为第三种情况使用关联，但这并没有说明如何将原理扩展到多个参数。最终结果是您可以foo(...)在代码中使用而不必担心（很多 [1]）其参数的类型。
对于更复杂的情况，例如函数重载大量参数或变化数量，您可以使用实用宏来自动生成静态调度结构：
void print_ii(int a, int b) { printf("int, int\n"); }
void print_di(double a, int b) { printf("double, int\n"); }
void print_iii(int a, int b, int c) { printf("int, int, int\n"); }
void print_default(void) { printf("unknown arguments\n"); }
#define print(...) OVERLOAD(print, (__VA_ARGS__), \
(print_ii, (int, int)), \
(print_di, (double, int)), \
(print_iii, (int, int, int)) \
)
#define OVERLOAD_ARG_TYPES (int, double)
#define OVERLOAD_FUNCTIONS (print)
#include "activate-overloads.h"
int main(void) {
print(44, 47); // prints "int, int"
print(4.4, 47); // prints "double, int"
print(1, 2, 3); // prints "int, int, int"
print(""); // prints "unknown arguments"
}
（在此处实现）因此，通过一些努力，您可以减少样板文件的数量，使其看起来非常像具有对重载的本机支持的语言。
顺便说一句，在 C99中已经可以重载参数的数量（而不是类型）。
[1] 请注意，C 评估类型的方式可能会让您感到困惑。foo_int例如，如果您尝试将字符文字传递给它，这将选择，如果您希望重载支持字符串文字，则需要稍微弄乱一下。不过总体来说还是很酷的。
于 2014-07-29T23:04:48.273 回答
140
有几种可能：
- printf 样式函数（类型作为参数）
- opengl 风格的函数（输入函数名）
- c++ 的 c 子集（如果您可以使用 c++ 编译器）
于 2009-01-26T09:24:41.883 回答
85
如前所述，C 不支持您所说的重载。解决该问题的常用习惯用法是使函数接受标记的 union。这是由一个struct参数实现的，其中它struct本身由某种类型的指示符组成，例如enuma 和 aunion的不同类型的值。例子：
#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);
}
于 2009-01-26T09:52:11.813 回答
30
这是我发现的在 C 中演示函数重载的最清晰、最简洁的示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int addi(int a, int b) {
return a + b;
}
char *adds(char *a, char *b) {
char *res = malloc(strlen(a) + strlen(b) + 1);
strcpy(res, a);
strcat(res, b);
return res;
}
#define add(a, b) _Generic(a, int: addi, char*: adds)(a, b)
int main(void) {
int a = 1, b = 2;
printf("%d\n", add(a, b)); // 3
char *c = "hello ", *d = "world";
printf("%s\n", add(c, d)); // hello world
return 0;
}
于 2015-07-26T18:20:41.937 回答
19
如果您的编译器是 gcc 并且您不介意每次添加新的重载时都进行手动更新，您可以做一些宏魔术并在调用者方面获得您想要的结果，那么编写起来就不那么好......但它是可能的
查看 __builtin_types_compatible_p，然后使用它来定义一个执行类似操作的宏
#define foo(a) \
((__builtin_types_compatible_p(int, a)?foo(a):(__builtin_types_compatible_p(float, a)?foo(a):)
但是是的，讨厌，只是不要
编辑： C1X 将获得对它们看起来像这样的类型泛型表达式的支持：
#define cbrt(X) _Generic((X), long double: cbrtl, \
default: cbrt, \
float: cbrtf)(X)
于 2010-06-14T21:12:34.580 回答
13
以下方法类似于a2800276，但添加了一些 C99 宏魔术：
// we need `size_t`
#include <stddef.h>
// argument types to accept
enum sum_arg_types { SUM_LONG, SUM_ULONG, SUM_DOUBLE };
// a structure to hold an argument
struct sum_arg
{
enum sum_arg_types type;
union
{
long as_long;
unsigned long as_ulong;
double as_double;
} value;
};
// determine an array's size
#define count(ARRAY) ((sizeof (ARRAY))/(sizeof *(ARRAY)))
// this is how our function will be called
#define sum(...) _sum(count(sum_args(__VA_ARGS__)), sum_args(__VA_ARGS__))
// create an array of `struct sum_arg`
#define sum_args(...) ((struct sum_arg []){ __VA_ARGS__ })
// create initializers for the arguments
#define sum_long(VALUE) { SUM_LONG, { .as_long = (VALUE) } }
#define sum_ulong(VALUE) { SUM_ULONG, { .as_ulong = (VALUE) } }
#define sum_double(VALUE) { SUM_DOUBLE, { .as_double = (VALUE) } }
// our polymorphic function
long double _sum(size_t count, struct sum_arg * args)
{
long double value = 0;
for(size_t i = 0; i < count; ++i)
{
switch(args[i].type)
{
case SUM_LONG:
value += args[i].value.as_long;
break;
case SUM_ULONG:
value += args[i].value.as_ulong;
break;
case SUM_DOUBLE:
value += args[i].value.as_double;
break;
}
}
return value;
}
// let's see if it works
#include <stdio.h>
int main()
{
unsigned long foo = -1;
long double value = sum(sum_long(42), sum_ulong(foo), sum_double(1e10));
printf("%Le\n", value);
return 0;
}
于 2009-01-26T10:25:46.177 回答
13
是的，有点。
举个例子：
void printA(int a){
printf("Hello world from printA : %d\n",a);
}
void printB(const char *buff){
printf("Hello world from printB : %s\n",buff);
}
#define Max_ITEMS() 6, 5, 4, 3, 2, 1, 0
#define __VA_ARG_N(_1, _2, _3, _4, _5, _6, N, ...) N
#define _Num_ARGS_(...) __VA_ARG_N(__VA_ARGS__)
#define NUM_ARGS(...) (_Num_ARGS_(_0, ## __VA_ARGS__, Max_ITEMS()) - 1)
#define CHECK_ARGS_MAX_LIMIT(t) if(NUM_ARGS(args)>t)
#define CHECK_ARGS_MIN_LIMIT(t) if(NUM_ARGS(args)
#define print(x , args ...) \
CHECK_ARGS_MIN_LIMIT(1) printf("error");fflush(stdout); \
CHECK_ARGS_MAX_LIMIT(4) printf("error");fflush(stdout); \
({ \
if (__builtin_types_compatible_p (typeof (x), int)) \
printA(x, ##args); \
else \
printB (x,##args); \
})
int main(int argc, char** argv) {
int a=0;
print(a);
print("hello");
return (EXIT_SUCCESS);
}
它将从 printA 和 printB 输出 0 和 hello ..。
于 2012-10-22T11:22:33.310 回答
13
这可能根本没有帮助，但是如果您使用的是 clang，您可以使用可重载属性 - 即使编译为 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) { ... }
于 2013-09-18T18:50:03.737 回答
11
从你的意思来说——不，你不能。
您可以声明一个va_arg函数，如
void my_func(char* format, ...);
，但是您需要在第一个参数中传递有关变量数量及其类型的某种信息——就像这样printf()做。
于 2009-01-26T09:25:26.500 回答
6
通常，表示类型的疣会附加或附加到名称之前。在某些情况下，您可以摆脱宏，但这取决于您要做什么。C中没有多态性，只有强制。
简单的通用操作可以用宏来完成：
#define max(x,y) ((x)>(y)?(x):(y))
如果您的编译器支持typeof，则可以在宏中放入更复杂的操作。然后，您可以使用符号 foo(x) 来支持不同类型的相同操作，但不能改变不同重载之间的行为。如果您想要实际功能而不是宏，您可以将类型粘贴到名称并使用第二次粘贴来访问它（我没有尝试过）。
于 2009-01-26T09:30:41.827 回答
5
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__ conditionally之后放置逗号，我们可以“轻松”地消除这个问题，具体取决于列表是否为空：
#define NARG(...) ARG4_(__VA_ARGS__ COMMA(__VA_ARGS__) 4, 3, 2, 1, 0)
这看起来很简单，但COMMA宏是一个相当沉重的宏；幸运的是，该主题已经在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;
}
于 2017-09-14T15:13:48.470 回答
1
难道你不能只使用 C++ 而不使用除此之外的所有其他 C++ 功能吗？
如果仍然不只是严格的 C，那么我会推荐可变参数函数。
于 2009-01-26T09:24:47.143 回答
-3
尝试声明这些函数，就extern "C++"好像你的编译器支持这个一样， http: //msdn.microsoft.com/en-us/library/s6y4zxec (VS.80).aspx
于 2009-01-26T10:45:51.190 回答
-6
我希望下面的代码能帮助你理解函数重载
#include <stdio.h>
#include<stdarg.h>
int fun(int a, ...);
int main(int argc, char *argv[]){
fun(1,10);
fun(2,"cquestionbank");
return 0;
}
int fun(int a, ...){
va_list vl;
va_start(vl,a);
if(a==1)
printf("%d",va_arg(vl,int));
else
printf("\n%s",va_arg(vl,char *));
}
于 2016-03-09T04:50:31.300 回答