|
  
- UID
- 133
- 帖子
- 51
- 精华
- 1
- 积分
- 186
- 金币
- 55
- 威望
- 2
- 贡献
- 0

|
函数的可变参数详谈
可变参数的英文表示为:variable argument.$ A; T1 j: a! A( J- l/ ?3 r9 B
它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.
; N- t2 X7 W* b9 p0 q3 O" v. s可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不% B/ X7 ]2 t* V8 N$ j/ b2 ~
定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有
5 M" e2 R7 F% M5 L实际的名称与之相对应.
# x2 K; k1 ?: s& M0 M! X由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.
" @+ G. O s6 b, l然而,更多地自由,同样也加大操作上的难度.
" s) @$ Q4 a& @1 T1 E# [以下就对可变参数的几个方面作一定的介绍.
# k* D3 W( _4 E4 q* ~- a5 \0 [8 Q" B, V- f
1)可变参数的存储形式.. N3 y4 D6 U4 @# t
7 @ P1 ?7 c4 t( l' F
大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,
7 U7 K1 Q' v" m: ~1 B存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.
" r. `/ @, b7 ~& G# d4 x0 O在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,, O$ u% m! s. ]& Z0 E! M: N
这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.
. K1 W; _' I8 p/ S3 p) k* e因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):6 t% \) K1 }1 y W9 \
栈区:
+ G9 G2 X) C" H! e" w. V
' r- }8 j# [& H8 K y|栈顶 低地址
) l: W) C. H# `- A$ g. j
/ z9 P; E8 A" m: j, w|第一个固定参数var1
m, a1 x* J: `! E- M% Q* `; \|可变参数前的第一个固定参数var2/ b' ?. l" ~4 D1 s3 k8 W
|可变参数的第一个参数% O) m3 F6 g) f, r3 B2 G
|..., x, f4 ]+ F i8 P
|可变参数的最后一个参数+ A& n; J: W; Z$ [' Y
|函数的倒数第二个固定参数var3& o) Z6 A. b$ ~. [- }) _+ B6 Y
|函数的最后一个固定参数var4: I5 d# J7 y4 A
|...: G" }" P" a' \. T- c% |; N z
|函数的返回地址
" m/ y8 g2 A. T+ c# o|..." C4 H. s8 O4 f
|栈底 高地址% q. u* o$ t& J/ ?
2 O+ \ q! u9 Y
2)使用可变参数所用到头文件和相关宏说明; [# @% V6 P3 T4 I, Q$ W. |) ~
. K+ r r! d- w. [
在此,以TC2.0编译器为参考对象来说明.
n: g6 ]4 y; b0 A$ ?9 e! w可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.
- v [6 u5 b' q' |* \此文件为:
$ k `5 S2 E( M# v" }7 K/* stdarg.h: X8 m" w0 A: i; Q+ X
0 d8 a' Q6 c+ K) lDefinitions for ACCESSing parameters in functions that accept
7 X q( h3 j1 u) Y7 ia variable number of arguments.
- L) N! w; R$ w
/ [: k. C% Z/ O* C+ uCopyright (c) Borland International 1987,19888 g) e) x9 c0 F: i! t: O
All Rights Reserved." R( X4 {; M1 l3 S
*/
/ ?. W+ c+ w$ F( c. M3 [#if __STDC__) S# X" q+ V5 R- v
#define _Cdecl
0 ?- v, M7 |3 f& Z# }/ V4 O6 t#else# _; @8 d+ \) ?' C' }
#define _Cdecl cdecl( O5 i9 Y1 d1 z0 M: p
#endif/ B) O, @, q- T* W& Z
# V5 U, [- g" `& E/ _7 F8 d a
#if !defined(__STDARG)
/ k$ e" O, d3 x! \) z#define __STDARG, H6 S* ^! `- A, ^
7 p' X% }6 b8 _" V0 K9 otypedef void *va_list;/ L& u" [) U; m, n" A+ J
, Q, M( }, f& x& i1 m: @
#define va_start(ap, parmN) (ap = ...)
% k* d, u2 B a' N2 |7 g7 r/ u+ `6 E#define va_arg(ap, type) (*((type *)(ap))++)/ a$ R7 [7 E9 X$ P9 T
#define va_end(ap)0 x9 h+ F7 n* P$ h/ D
#define _va_ptr (...)
. u) T- [7 M; d9 X, u2 d+ r#endif. ^1 o! v6 R/ l& ]0 ]2 { i5 _! t
) `2 ^# r7 u# @9 d以上为"STDARG.H"的内容.; X2 L0 T* X+ z1 u8 X
该文件定义了使用可变参数所用到的数据类型:typedef void *va_list;
. i9 H: p7 e T& }; e* u* S; z8 |1 hva_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,
0 f! V3 t" U% O# L* ?+ M" aparmN为可变参数的前面一个固定参数.
5 L, z F |# Uva_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.
3 i7 W! y& y! V/ V5 g4 e3 i% Lva_end(ap) 结束可变参数获取.
, y: a& o9 a; m
: @9 B8 |+ E" @6 p3)可变参数的使用实例# t7 ^" I# `$ d. i$ Z1 v O
! o3 I i' J$ S* @: _' l/ j9 v实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
$ A/ ~4 s3 A8 k w
! n7 J, W& f' S/ c9 C, {. x% j! N, K#include<stdio.h>5 q3 J0 O8 c; e& d8 I
#include<conio.h>
$ W- E7 P7 ?& \* D2 a% G3 S#include<stdarg.h>& t3 T5 r: d8 V* L. @' W
void tVarArg(int num,...);/*num为可变参数的个数*/
( z" }! J$ t- ]int main(void)
o9 o0 G0 F' f" _ U" i{
7 B* S$ p) P0 z( e. Uclrscr();
2 ]! n% Y0 |6 [* q4 \tVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");
6 y9 ?7 ]$ P" dtVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");' Z! i2 G, n5 W
getch();0 i e) ~7 p/ X
return 0;, N0 \) m" f9 T, m f
}
4 T9 L* t( n0 J% V5 E6 y$ Evoid tVarArg(int num,...)
) S6 r c: r; b; @0 U{
! q3 d8 E: |# r) @va_list argp; /*定义一个指向可变参数的变量*/6 }! A" k* Q$ ^
va_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/) m; y/ p3 ^8 l9 T
while(--num>=0)( i0 V% [) l/ b( |) \1 x
printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,7 V( @' X; m! {4 x2 W' X; J! J
并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/8 r x+ o3 c% I6 U' _' G
va_end(argp); /*结束可变参数获取*/) C2 i- A: V. n1 W; M: ] o
return ;
, H& g1 b% o$ ?6 b4 }% m}
0 y0 v8 e. x" O, W. d6 z; T& j* s$ @/ \# k" ?
4)可变参数的使用需要注意的问题
/ r" {9 v; S/ a- B6 H% ?) C. }+ A- Z( I9 j8 M7 r# Q& c
1.每个函数的可变参数至多有一个.
& T: M3 C; ?1 y: @2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.8 }: \# N' r. I* i( v
3.可变参数的个数不确定,完全由程序约定.
7 z: T/ N9 c" Q6 m3 G0 |$ ^4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.2 E% g' x; U( G) Z
而printf()中不是实现了识别参数吗?那是因为函数 - c7 Y% J2 H2 E# b4 B: A
printf()是从固定参数format字符串来分析出参数的类型,再调用va_arg : p+ \7 X" o: D l
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通 " h7 C' O- q6 ]# S4 G9 N
过在自己的程序里作判断来实现的. \6 M. Z! ~! H7 j8 p/ J
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高. |
|