数组传参
数组作为参数传给函数时传的是指针而不是数组本身,那个指针存储的是数组的首地址,如:fun(char[8])和fun(char[])都等价于fun(char *)。
//在C++里参数传递数组永远都是传递指向数组首元素的指针,编译器不知道数组的大小。
//如果想在函数内知道数组的大小, 可以在进入函数后用memcpy拷贝出来,长度由另一个形参传进去 fun(unsiged char *p1, int len) { unsigned char* buf = new unsigned char[len+1] memcpy(buf, p1, len); }
&和*
“&”这个符号有两个不同的含义:引用和取地址。
引用的声明其实等于变量的别名:
Type &newname = name; //newname是name的别名,在编译器看来对应同一片内存分配
函数形参中的&(引用)和指针*
函数形参使用&是为了改变实参的值。普通形参只是拷贝了值进行操作,实参不受影响(即值不变)。
形参中的指针*同理,因为拷贝的是内存地址!!!所以对指针操作也可改变实参,因为是根据地址操作的。(函数调用时注意参数传递要用地址:fun(&name))
函数形参中指针*和引用&的搭配使用
此时引用&可改变的不是指针存储地址所指向的变量值(*ptr),而是可以对指针*的存储地址进行改变!即&可改变的是指针变量本身的值:存储的内存地址(ptr)!!!例如:在二叉树的类成员函数createNode中,为了在函数中进行指针指向变量的内存地址动态分配(即改变指针存储值),必须是Node* &ptr才行!!!此处&可理解为“取指针(ptr)本身的地址”,即可改变ptr本身的值(实现Node的动态内存分配)。
二维数组传参
形参为二维数组并给定第二维长度
最简单最直观的方法,形参与实参一样,容易理解。
#include <stdio.h> void subfun(int n, char subargs[][5]) { int i; for (i = 0; i < n; i++) { printf("subargs[%d] = %s ", i, subargs[i]); } } void main() { char args[][5] = {"abc", "def", "ghi"}; subfun(3, args); }
形参为指向数组的指针并给出数组长度
#include <stdio.h> void subfun(int n, char (*subargs)[5]) { int i; for (i = 0; i < n; i++) { printf("subargs[%d] = %s ", i, subargs[i]); } } void main() { char args[][5] = {"abc", "cde", "ghi"}; subfun(3, args); }
形参为指针的指针
此方法实参必须为指针,而不能为数组名。
#include <stdio.h> void subfun(int n, char **subargs) { int i; for (i = 0; i < n; i++) { printf("subargs[%d] = %s ", i, subargs[i]); } } void main() { char *a[3]; char args[][5] = {"abc", "def", "ghi"}; a[0] = args[0]; //equals with a[0] = &args[0][0]; a[1] = args[1]; a[2] = args[2]; subfun(3, a); //若此处为subfun(3, args);则会编译出错 }
上述代码等价于下面代码。当然我们这里只是讨论的二维数组传参问题,下面代码只起扩展作用。
#include <stdio.h> void subfun(int n, char **subargs) { int i; for (i = 0; i < n; i++) { printf("subargs[%d] = %s ", i, subargs[i]); } } void main() { char *args[] = {"abc", "def", "ghi"};//equals with char *args[3] = {"abc", "def", "ghi"}; subfun(3, args); }
变参
C语言中函数调用的原理
函数是大多数编程语言都实现的编程要素,调用函数的实现原理就是:执行跳转+参数传递。对于执行跳转,所有的CPU都直接提供跳转指令;对于参数传递,CPU会提供多种方式,最常见的方式就是利用栈来传递参数。C语言标准实现了函数调用,但是却没有限定实现细节,不同的C编译器厂商可以根据底层硬件环境自行确定实现方式。
函数调用的一般实现原理,请参考smstong的博文:C语言中利用setjmp和longjmp做异常处理中的第一段。
变参实现思路
1. 如何取得后续实参地址
以X86架构上的VC++编译器为例进行举例说明:
void f(int x, int y, int z) { printf("%p, %p, %p ", &x, &y, &z); } int main() { f(100, 200, 300); return 0; }
//可能的执行结果:
00FFF674, 00FFF678, 00FFF67C
VC++中函数的参数是通过堆栈传递的,参数按照从右向左的顺序入栈。调用f时参数在堆栈中的情况如下图所示:
可见,我们只要知道x的地址,就可以推算出y,z的地址,从而通过其地址取得参数y,z的值,而不用其参数名称取值。如下代码所示。
void f(int x, int y, int z) { char* px = (char*)&x; char *py = px + sizeof(x); char *pz = py + sizeof(int); printf("x=%d, y=%d, z=%d ", x, *(int*)py, *(int*)pz); } int main(){ f(100, 200, 300); return 0; }
根据函数的第一个参数,以及后续参数的类型,就可以根据偏移量计算出后续参数的地址,从而取得后续参数值。
于是可以把上述代码改写成可变参数的形式。
void f(int x, ...) { char* px = (char*)&x; char *py = px + sizeof(x); char *pz = py + sizeof(int); printf("x=%d, y=%d, z=%d ", x, *(int*)py, *(int*)pz); } int main() { f(100, 200, 300); return 0; }
2. 如何标识后续参数个数和类型
虽然写成了可变参形式,但是函数如何判断后续实参的个数和类型呢?这就需要在固定参数中携带这些信息,如printf(char*, …)使用的格式化字符串方法,通过第一个参数来携带后续参数个数以及类型的信息。我们实现一个简单点的,只能识别%s,%d,%f三种标志。
void f(char* fmt, ...) { char* p0 = (char*)&fmt; char* ap = p0 + sizeof(fmt); char* p = fmt; while (*p) { if (*p == '%' && *(p+1) == 'd') { printf("参数类型为int,值为 %d ", *((int*)ap)); ap += sizeof(int); } else if (*p == '%' && *(p+1) == 'f') { printf("参数类型为double,值为 %f ", *((double*)ap)); ap += sizeof(double); } else if (*p == '%' && *(p+1) == 's') { printf("参数类型为char*,值为 %s ", *((char**)ap)); ap += sizeof(char*); } p++; } } int main() { f("%d,%f,%s", 100, 1.23, "hello world"); return 0; }
输出:
参数类型为int,值为 100 参数类型为double,值为 1.230000 参数类型为char*,值为 hello world
为简化分析参数代码,定义一些宏来简化,如下。
#define va_list char* /* 可变参数地址 */ #define va_start(ap, x) ap=(char*)&x+sizeof(x) /* 初始化指针指向第一个可变参数 */ #define va_arg(ap, t) (ap+=sizeof(t),*((t*)(ap-sizeof(t)))) /* 取得参数值,同时移动指针指向后续参数 */ #define va_end(ap) ap=0 /* 结束参数处理 */ void f(char* fmt, ...) { va_list ap; va_start(ap, fmt); char* p = fmt; while (*p) { if (*p == '%' && *(p+1) == 'd') { printf("参数类型为int,值为 %d ", va_arg(ap, int)); } else if (*p == '%' && *(p+1) == 'f') { printf("参数类型为double,值为 %f ", va_arg(ap, double)); } else if (*p == '%' && *(p+1) == 's') { printf("参数类型为char*,值为 %s ", va_arg(ap, char*)); } p++; } va_end(ap); } int main() { f("%d,%f,%s,%d", 100, 1.23, "hello world", 200); return 0; }
正确的变参函数实现方法
上面的例子中,我们没有使用任何库函数就轻松实现了可变参数函数。别高兴太早,上述代码在X86平台的VC++编译器下可以顺利编译、正确执行。但是在gcc编译后,运行却是错误的。可见GCC对于可变参数的实参传递实现与VC++并不相同。
gcc下编译运行:
[smstong@cf-19 ~]$ ./a.out 参数类型为int,值为 0 参数类型为double,值为 0.000000 Segmentation fault
可见,上述代码是不可移植的。为了在使得可变参函数能够跨平台、跨编译器正确执行,必须使用C标准头文件stdarg.h中定义的宏,而不是我们自己定义的。(这些宏的名字和作用与我们自己定义的宏完全相同,这绝不是巧合!)每个不同的C编译器所附带的stdarg.h文件中对这些宏的定义都不相同。再次重申一下这几个宏的使用范式:
va_list ap; va_start(ap, 固定参数名); /* 根据最后一个固定参数初始化 */ 可变参数1类型 x1 = va_arg(ap, 可变参数类型1); /* 根据参数类型,取得第一个可变参数值 */ 可变参数2类型 x2 = va_arg(ap, 可变参数类型2); /* 根据参数类型,取得第二个可变参数值 */ ... va_end(ap); /* 结束 */
这次,把我们自己的宏定义去掉,换成#include
#include <stdio.h> #include <stdarg.h> void f(char* fmt, ...) { va_list ap; va_start(ap, fmt); char* p = fmt; while (*p) { if (*p == '%' && *(p+1) == 'd') { printf("参数类型为int,值为 %d ", va_arg(ap, int)); } else if (*p == '%' && *(p+1) == 'f') { printf("参数类型为double,值为 %f ", va_arg(ap, double)); } else if (*p == '%' && *(p+1) == 's') { printf("参数类型为char*,值为 %s ", va_arg(ap, char*)); } p++; } va_end(ap); } int main() { f("%d,%f,%s,%d", 100, 1.23, "hello world", 200); return 0; }
代码在VC++和GCC下均可以正确执行了。
关于C和C++的变参列表中宏的使用,详情见:C和C++中可变参数的宏使用
几个需要注意的问题
va_end(ap); 必须不能省略
也许在有些编译器环境中,va_end(ap);确实没有什么作用,但是在其他编译器中却可能涉及到内存的回收,切不可省略。
可变参数的默认类型提升
《C语言程序设计》中提到:在没有函数原型的情况下,char与short类型都将被转换为int类型,float类型将被转换为double类型。实际上,用...标识的可变参数总是会执行这种类型提升。
引用《C陷阱与缺陷》里的话:
**va_arg宏的第2个参数不能被指定为char、short或者float类型**。因为char和short类型的参数会被转换为int类型,而float类型的参数会被转换为double类型 ……
例如,这样写肯定是不对的:c = va_arg(ap,char); 因为我们无法传递一个char类型参数,如果传递了,它将会被自动转化为int类型。上面的式子应该写成:c = va_arg(ap,int);
编译器无法进行参数类型检查
对于可变参数,编译器无法进行任何检查,只能靠调用者的自觉来保证正确。
可变参数函数必须提供一个或更多的固定参数
可变参数必须靠固定参数来定位,所以函数中至少需要提供固定参数,f(固定参数,…)。
当然,也可以提供更多的固定参数,如f(固定参数1,固定参数2,…)。注意的是,当提供2个或以上固定参数时,va_start(ap, x)宏中的x必须是最后一个固定参数的名字(也就是紧邻可变参数的那个固定参数)。
C的可变参函数与C++的重载函数
C++的函数重载特性,允许重复使用相同的名称来定义函数,只要同名函数的参数(类型或数量)不同。例如
void f(int x); void f(int x, double d); void f(char* s);
虽然源代码中函数名字相同,其实编译器处理后生成的是三个具有不同函数名的函数(名字改编name mangling)。虽然在使用上有些类似之处,但这显然与C的可变参数函数完全不是一个概念。
(整理自网络)
参考资料:
https://blog.csdn.net/gqb_driver/article/details/8886687
https://blog.csdn.net/smstong/article/details/50751121