社区
C语言
帖子详情
C语言可以重载吗?
jsmj5257
2008-10-22 10:52:58
上次去华为面试,考C语言,有一个题目考官说我做的不对,我说怎么不对?他说要用重载,我听了纳闷????当然是被CANCEL了。
C语言可以重载吗?我做了3年的C语言开发,怎么就没有听说C语言可以重载的,查了很多资料也没有弄明白!至今还在迷惑,如果C语言不可以重载,那我将永不进华为!!
...全文
3037
54
打赏
收藏
C语言可以重载吗?
上次去华为面试,考C语言,有一个题目考官说我做的不对,我说怎么不对?他说要用重载,我听了纳闷????当然是被CANCEL了。 C语言可以重载吗?我做了3年的C语言开发,怎么就没有听说C语言可以重载的,查了很多资料也没有弄明白!至今还在迷惑,如果C语言不可以重载,那我将永不进华为!!
复制链接
扫一扫
分享
转发到动态
举报
写回复
配置赞助广告
用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语言
重载
PPT学习教案.pptx
C语言
重载
PPT学习教案.pptx
C语言
重载
运算符和
重载
函数.pdf
重载
声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的参数列表和定义(实现)不相同。 当您调用一个
重载
函数或
重载
运算符时,编译器通过把您所使用的参数类型与定义中的参数类型进行比较,决定选用最合适的定义。选择最合适的
重载
函数或
重载
运算符的过程,称为
重载
决策。
C语言
经典运算符
重载
本文以实验的形式详细介绍了运算符
重载
的概念和使用方法,几种常用的运算符
重载
的方法,可以帮你很好的了解转换构造函数的使用方法。
详解C++之函数
重载
函数
重载
本质 c++中通过函数名和函数确定一个函数 所以相同的函数名,不同参数也是可以的 不同于
c语言
,
c语言
没有函数
重载
,函数的本质地址就是函数名 函数
重载
发生在同一个作用域内 类中的
重载
构造函数
重载
普通成员函数
重载
静态成员函数
重载
全局函数、静态成员函数、普通成员函数可以发生
重载
吗? 本质就是函数名和函数参数不同,并且发生在同一个作用域 静态函数和普通成员函数是可以的 全局函数作用域在全局作用域,所以不可以 问题1:当父类的成员函数和子类的成员函数相等,会发生
重载
吗? 本质还是上面说的,因为父类和子类的作用域不在同一个 看一段代码 #include
cla
C语言
69,336
社区成员
243,078
社区内容
发帖
与我相关
我的任务
C语言
C语言相关问题讨论
复制链接
扫一扫
分享
社区描述
C语言相关问题讨论
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章