C语言可以重载吗？

2008-10-22 10:52:58 3.2k 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

什么是函数重载？C语言中是否支持函数重载？函数重载是一种编程语言特性，允许在同一个作用域中定义多个同名函数，但这些函数的参数列表必须不同。函数重载有助于提高代码的可读性和灵活性，但C语言本身不直接支持函数重载。C语言的设计哲学之一是保持简单性和直接性，强调开发者的责任来管理函数名称和参数。要在C语言中模拟函数重载，你可以使用不同的函数名称、默认参数值或宏等技巧，但需要注意这些方法的局限性和潜在的问题。最终，选择哪种方法取决于项目的需求和代码的可维护性。阅读详情

上次去华为面试，考C语言，有一个题目考官说我做的不对，我说怎么不对？他说要用重载，我听了纳闷？？？？当然是被CANCEL了。
C语言可以重载吗？我做了3年的C语言开发，怎么就没有听说C语言可以重载的，查了很多资料也没有弄明白！至今还在迷惑，如果C语言不可以重载，那我将永不进华为！！

...全文

解释 C 语言中的函数重载机制（注意：C 语言不支持函数重载）？虽然 C 语言不支持函数重载这一直接的特性，但通过合理地设计函数名、利用预处理器或使用函数指针和结构体等方法，我们仍然可以在一定程度上实现类似的功能，以满足不同参数类型的操作需求。然而，这些方法相较于真正的函数重载，在代码的简洁性和可读性上可能存在一定的不足。在实际编程中，选择哪种方法取决于具体的应用场景和编程需求。如果对函数重载有强烈的需求，可能考虑使用支持该特性的编程语言，如 C++。但对于一些简单的 C 语言项目，通过上述的模拟方法也能够有效地处理不同类型参数的函数调用问题。🎉相关推荐。阅读详情

jsmj5257

C语言 70,040 成员 243,237 内容

+ 关注 + 加入社区

切换为时间正序

yapon 2021-07-24

打赏
举报

重载的意义是在统一的语法下的多重意义的实现，如果用c语言重载等号，结果不能用赋值语法书写，那么就没有意义。c＋＋与c的最大不同就是编译不同，c不可能模拟c＋＋，但可以写c＋＋的编译器。

houfire007 2012-10-30

打赏
举报

不能够重载，只能够模拟重载，利用指针实现

arkhe 2012-10-22

打赏
举报

[Quote=引用 50 楼的回复:]

额。 c重载面向对象c、、、沃槽。逆天啊
[/Quote]

有这么逆天吗，30年前的程序员就实现的东西；
现在很多的底层code还不是用的这些？

BIOS中用C实现的OO例子：
http://blog.csdn.net/hgf1011/article/details/4342311

didijiji 2012-10-22

打赏
举报

太神奇了不是？

_暮落_ 2012-10-22

打赏
举报

额。 c重载面向对象c、、、沃槽。逆天啊

RaindaiSong 2012-10-21

打赏
举报

obj-c不是C[Quote=引用 2 楼的回复:]
你没有听过 object-oriented c 吗？
没有具体看过只是有面向对象C，能不能实现重载就不晓得了！
[/Quote]

yy345958406 2012-09-07

打赏
举报

c重入听说过，c重载倒是第一次。
待牛人解。。。

cao_julians 2012-09-01

打赏
举报

用宏屏蔽方法

#define sin(x) (x)*(x)

代码中的正弦函数sin(...)就会被替换为平方运算了

BYD123 2012-09-01

打赏
举报

C本身没有重载。他的意思可能是叫你用C模拟CPP实现一个重载函数，不过话说回来HW的人水平确实很2，拒HW很多次。。。

tuolaji1989 2012-09-01

打赏
举报

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

void va_overload2(int p1, int p2)
{
printf("va_overload2 %d %d\n", p1, p2);
}

void va_overload3(int p1, int p2, int p3)
{
printf("va_overload3 %d %d %d\n", p1, p2, p3);
}

static void va_overload(int p1, int p2, ...)
{
if (p2 == 7)
{
va_list v;
va_start(v, p2);

int p3 = va_arg(v, int);
va_end(v);
va_overload3(p1, p2, p3);

return;
}

va_overload2(p1, p2);
}

static void print_nt_strings(const char *s, ...)
{
va_list v;
va_start(v, s);

/* Stop on NULL */
while (s)
{
printf("%s", s);

/* Grab next parameter */
s = va_arg(v, const char *);
}

va_end(v);
}

#define COUNT_PARMS2(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _, ...) _
#define COUNT_PARMS(...)\
COUNT_PARMS2(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

static void print_strings2(int count, ...)
{
int i;

va_list v;
va_start(v, count);

for (i = 0; i < count; i++)
{
/* Grab next parameter + print it */
const char *s = va_arg(v, const char *);
printf("%s", s);
}

va_end(v);
}

#define print_strings(...)\
print_strings2(COUNT_PARMS(__VA_ARGS__), __VA_ARGS__)

void count_overload1(int p1)
{
printf("One param: %d\n", p1);
}

void count_overload2(double *p1, const char *p2)
{
printf("Two params: %p (%f) %s\n", p1, *p1, p2);
}

void count_overload3(int p1, int p2, int p3)
{
printf("Three params: %c %d %d\n", p1, p2, p3);
}

void count_overload_aux(int count, ...)
{
va_list v;
va_start(v, count);

switch(count)
{
case 1:
{
int p1 = va_arg(v, int);
count_overload1(p1);
break;
}

case 2:
{
double *p1 = va_arg(v, double *);
const char *p2 = va_arg(v, const char *);
count_overload2(p1, p2);
break;
}

case 3:
{
int p1 = va_arg(v, int);
int p2 = va_arg(v, int);
int p3 = va_arg(v, int);
count_overload3(p1, p2, p3);
break;
}

default:
{
va_end(v);

printf("Invalid arguments to function 'count_overload()'");
exit(1);
}
}

va_end(v);
}
#define count_overload(...)\
count_overload_aux(COUNT_PARMS(__VA_ARGS__), __VA_ARGS__)

void cpp_overload1(int p1)
{
printf("CPP One param: %d\n", p1);
}

void cpp_overload2(double *p1, const char *p2)
{
printf("CPP Two params: %p (%f) %s\n", p1, *p1, p2);
}

void cpp_overload3(int p1, int p2, int p3)
{
printf("CPP Three params: %c %d %d\n", p1, p2, p3);
}

#define CAT(A, B) CAT2(A, B)
#define CAT2(A, B) A ## B

#define cpp_overload(...)\
CAT(cpp_overload, COUNT_PARMS(__VA_ARGS__))(__VA_ARGS__)

#define cpp_default1(A) cpp_default2(A, "default string")

void cpp_default2(int x, const char *s)
{
printf("Got %d %s\n", x, s);
}

#define cpp_default(...)\
CAT(cpp_default, COUNT_PARMS(__VA_ARGS__))(__VA_ARGS__)

void sizeof_overload_float(float f)
{
printf("Got float %f\n", f);
}

void sizeof_overload_double(double d)
{
printf("Got double %f\n", d);
}

void sizeof_overload_longdouble(long double ld)
{
printf("Got long double %Lf\n", ld);
}

#define sizeof_overload(A)\
((sizeof(A) == sizeof(float))?sizeof_overload_float(A):\
(sizeof(A) == sizeof(double))?sizeof_overload_double(A):\
(sizeof(A) == sizeof(long double))?sizeof_overload_longdouble(A):(void)0)

struct s1
{
int a;
int b;

double c;
};

struct s2
{
long long a;
long long b;
};

void gcc_overload_s1(struct s1 s)
{
printf("Got a struct s1: %d %d %f\n", s.a, s.b, s.c);
}

void gcc_overload_s2(struct s2 s)
{
printf("Got a struct s2: %lld %lld\n", s.a, s.b);
}

// warning: dereferencing type-punned pointer will break strict-aliasing rules
#define gcc_overload(A)\
__builtin_choose_expr(__builtin_types_compatible_p(typeof(A), struct s1),\
gcc_overload_s1(*(struct s1 *)&A),\
__builtin_choose_expr(__builtin_types_compatible_p(typeof(A), struct s2),\
gcc_overload_s2(*(struct s2 *)&A),(void)0))

void gcc_type_overload_aux(int typeval, ...)
{
switch(typeval)
{
case 1:
{
va_list v;
va_start(v, typeval);

struct s1 s = va_arg(v, struct s1);

va_end(v);

gcc_overload_s1(s);

break;
}

case 2:
{
va_list v;
va_start(v, typeval);

struct s2 s = va_arg(v, struct s2);

va_end(v);

gcc_overload_s2(s);

break;
}

default:
{
printf("Invalid type to 'gcc_type_overload()'\n");
exit(1);
}
}
}

#define gcc_type_overload(A)\
gcc_type_overload_aux(\
__builtin_types_compatible_p(typeof(A), struct s1) * 1\
+ __builtin_types_compatible_p(typeof(A), struct s2) * 2\
, A)

void print_type(int t, va_list *v)
{
switch(t)
{
case 1:
{
int p = va_arg(*v, int);

printf("int :%d\n", p);
break;
}

case 2:
{
long long p = va_arg(*v, long long);

printf("long long :%lld\n", p);
break;
}

case 3:
{
double p = va_arg(*v, double);

printf("double :%f\n", p);
break;
}

case 4:
{
long double p = va_arg(*v, long double);

printf("long double :%Lf\n", p);
break;
}

default:
{
printf("Unknown type\n");
exit(1);
}
}
}

void param_lister1_aux(int t1, ...)
{
va_list v;
va_start(v, t1);

printf("1st param:");
print_type(t1, &v);

va_end(v);
}

void param_lister2_aux(int t1, ...)
{
int t2;
va_list v;
va_start(v, t1);

printf("1st param:");
print_type(t1, &v);

t2 = va_arg(v, int);
printf("2nd param:");
print_type(t2, &v);

va_end(v);
}

void param_lister3_aux(int t1, ...)
{
int t2, t3;
va_list v;
va_start(v, t1);

printf("1st param:");
print_type(t1, &v);

t2 = va_arg(v, int);
printf("2nd param:");
print_type(t2, &v);

t3 = va_arg(v, int);
printf("3rd param:");
print_type(t3, &v);

va_end(v);
}

void param_lister4_aux(int t1, ...)
{
int t2, t3, t4;
va_list v;
va_start(v, t1);

printf("1st param:");
print_type(t1, &v);

t2 = va_arg(v, int);
printf("2nd param:");
print_type(t2, &v);

t3 = va_arg(v, int);
printf("3rd param:");
print_type(t3, &v);

t4 = va_arg(v, int);
printf("4th param:");
print_type(t4, &v);

va_end(v);
}

#define TYPENUM(A)\
__builtin_types_compatible_p(typeof(A), int) * 1\
+ __builtin_types_compatible_p(typeof(A), long long) * 2\
+ __builtin_types_compatible_p(typeof(A), double) * 3\
+ __builtin_types_compatible_p(typeof(A), long double) * 4

#define param_lister1(A)\
param_lister1_aux(TYPENUM(A), A)

#define param_lister2(A, B)\
param_lister2_aux(TYPENUM(A), A, TYPENUM(B), B)

#define param_lister3(A, B, C)\
param_lister3_aux(TYPENUM(A), A, TYPENUM(B), B, TYPENUM(C), C)

#define param_lister4(A, B, C, D)\
param_lister4_aux(TYPENUM(A), A, TYPENUM(B), B, TYPENUM(C), C, TYPENUM(D), D)

#define param_lister(...)\
CAT(param_lister, COUNT_PARMS(__VA_ARGS__))(__VA_ARGS__)

int main()
{
param_lister(1);
param_lister(1, 2.0, 3, 6.0);
return 0;
}