社区
C语言
帖子详情
C语言可以重载吗?
jsmj5257
2008-10-22 10:52:58
上次去华为面试,考C语言,有一个题目考官说我做的不对,我说怎么不对?他说要用重载,我听了纳闷????当然是被CANCEL了。
C语言可以重载吗?我做了3年的C语言开发,怎么就没有听说C语言可以重载的,查了很多资料也没有弄明白!至今还在迷惑,如果C语言不可以重载,那我将永不进华为!!
...全文
3124
54
打赏
收藏
C语言可以重载吗?
上次去华为面试,考C语言,有一个题目考官说我做的不对,我说怎么不对?他说要用重载,我听了纳闷????当然是被CANCEL了。 C语言可以重载吗?我做了3年的C语言开发,怎么就没有听说C语言可以重载的,查了很多资料也没有弄明白!至今还在迷惑,如果C语言不可以重载,那我将永不进华为!!
复制链接
扫一扫
分享
转发到动态
举报
AI
作业
写回复
配置赞助广告
用AI写文章
54 条
回复
切换为时间正序
请发表友善的回复…
发表回复
打赏红包
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;
}
ljhhh0123
2012-09-01
打赏
举报
回复
题呢?
Lucky_HDS
2012-09-01
打赏
举报
回复
c语言本身不能实现重载
晚秋
2011-03-14
打赏
举报
回复
本身c语言 实现自身包装 可扩展端口方法少
晚秋
2011-03-14
打赏
举报
回复
什么是真的重载?
晚秋
2011-03-14
打赏
举报
回复
[Quote=引用 38 楼 hrx1989 的回复:]
C的重载还真是第一次听到。
但是利用指针模仿的“重载”也不是真的是重载吧。。不能算的上是。。
越来越崇拜华为的大牛了。。
[/Quote]
你能告诉我不这么做还有其他方法吗
fssf0078
2011-03-14
打赏
举报
回复
可以研究下gobject 好像有个mambar.c什么的例子 就是使用c语言模拟C++的 可以研究下
hrx1989
2011-03-14
打赏
举报
回复
C的重载还真是第一次听到。
但是利用指针模仿的“重载”也不是真的是重载吧。。不能算的上是。。
越来越崇拜华为的大牛了。。
qq120848369
2011-03-14
打赏
举报
回复
可以参考qsort的实现思想,利用地址+偏移量操作内存,根据用户自定义函数进行类型的转化与条件的判定.
晚秋
2011-03-14
打赏
举报
回复
难道没人用过宏吗
没有思想的程序员悲哀啊
孙歌
2011-03-14
打赏
举报
回复
没见过...
加载更多回复(34)
C语言
运算符
重载
C语言
运算符
重载
详解C++之函数
重载
不同于
c语言
,
c语言
没有函数
重载
,函数的本质地址就是函数名 函数
重载
发生在同一个作用域内 类中的
重载
构造函数
重载
普通成员函数
重载
静态成员函数
重载
全局函数、静态成员函数、普通成员函数可以发生
重载
吗? ...
C语言
程序设计课件第7章
重载
与模板.ppt
C语言
程序设计课件第7章
重载
与模板.ppt
华为 C++ 培训资料
第二章
重载
………………………………………………………………………18 2.1 函数
重载
………………………………………………………………………19 2.2 运算符
重载
…………………………………………………………...
【C++入门】你知道为什么C++支持函数
重载
而
C语言
不支持吗?
你知道为什么
C语言
不支持函数
重载
吗?
C语言
70,021
社区成员
243,263
社区内容
发帖
与我相关
我的任务
C语言
C语言相关问题讨论
复制链接
扫一扫
分享
社区描述
C语言相关问题讨论
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章