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

|
函数的可变参数详谈
可变参数的英文表示为:variable argument.' ?9 q, T$ P' z+ @
它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.
5 h1 [1 I$ j7 f: [可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不
' Z1 J5 v+ d% }, a' v! P定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有
3 J+ F) \/ m( B) C j实际的名称与之相对应.
% p5 K- [0 Q7 d# n0 x+ E- t由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.
0 d& r' ~/ H8 S+ M4 {; m然而,更多地自由,同样也加大操作上的难度.1 {) X7 ]9 X% K
以下就对可变参数的几个方面作一定的介绍.
8 @9 E4 T2 [& k* R2 u0 w% n7 X
/ C$ S8 v- e( D1)可变参数的存储形式.
d: y! L4 q3 N: z8 j' [# G8 s6 |! k" w% \( v
大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,
% E' O/ @2 I# A& B+ f存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.
7 F- g' u8 @; q8 d6 M# V5 z7 F在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,, |& X" X* b& p# Z7 j' j' u1 P! F
这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.7 H9 C! F }4 d" t" N1 T; Q
因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):
) o6 t5 v; q# o! m4 E2 [ q. k+ N栈区:
! t+ a" h, s( ^) F! H$ C, ?4 x! z4 x! W- }3 x- ?
|栈顶 低地址+ h- }0 U$ ?# q% i
6 r/ h4 l. N- ]' x( ]" N+ F|第一个固定参数var1
' V7 D3 B" ?2 | W" Y|可变参数前的第一个固定参数var2
# y" t# P- _9 ^0 w" a+ y* ^|可变参数的第一个参数
) V( |4 m) u# f4 A|...) q0 M% a& f/ @
|可变参数的最后一个参数
8 _+ H2 k( P8 `8 D$ o! U|函数的倒数第二个固定参数var3( W) o& i2 F! _3 T# J3 X. @4 \6 T
|函数的最后一个固定参数var4
" D+ r( S3 u# q3 h4 g; L0 [|...- w2 U+ e1 j. a
|函数的返回地址
2 a. A1 V; f& U. d|...
5 C) ?! ~& W, l. l; y' R, h|栈底 高地址- q5 Y5 F* Y6 S7 y
" D* V# `. x' W* Y2 C, R2)使用可变参数所用到头文件和相关宏说明
+ p1 T6 w2 [# O, B* n/ A! l4 ?* [. F% U6 P' D0 J1 T: S. j
在此,以TC2.0编译器为参考对象来说明.
- {! @2 M" U7 V3 }3 R' g可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.
6 w' _1 u: X- q+ S- d此文件为:
* c2 p+ j% b% n0 `* k6 [# h/* stdarg.h, w, T# {: A- b9 I
$ ]8 q6 d3 {+ }Definitions for ACCESSing parameters in functions that accept
( o- r% D |' s: J, t; Pa variable number of arguments.
6 f, C8 o3 L1 I; z2 Q$ J/ F' I9 n8 f" @/ Y: h
Copyright (c) Borland International 1987,1988% {3 A6 @3 ]$ {2 v4 c
All Rights Reserved.5 i: X$ D$ b# t: p! J! E# `% H; [9 _
*/- I; M. b8 H7 R' C4 l3 ^
#if __STDC__2 Z- R1 A+ U1 M: l- W" e% J+ n8 _
#define _Cdecl
! w7 U3 g/ B' r+ m. h* N s8 c( u#else; X+ d; X# S8 W2 Z& L: V% _+ j; X
#define _Cdecl cdecl9 @% x5 a, k2 C" b+ Q+ b
#endif
+ L8 T3 m( a6 a: y
6 B4 r, h4 D! }% S- F#if !defined(__STDARG)( `0 h1 H" A) i- E5 ^2 T8 R
#define __STDARG, a: D9 |- }3 X3 z8 c4 n
& c6 S4 e7 U' d1 A; gtypedef void *va_list;
) h5 q$ `, y" v0 l
2 }* Z* C# w |#define va_start(ap, parmN) (ap = ...)6 b1 Y. B# E. u5 J
#define va_arg(ap, type) (*((type *)(ap))++)
2 w7 A" D+ J# m; M#define va_end(ap)
& \% K" B' t) \. }#define _va_ptr (...)
4 ?0 O" l5 r3 x8 g& p" b#endif
3 g; {& j' A8 w- a3 w, H
0 k: _8 c- ^) z0 y以上为"STDARG.H"的内容.6 b- r1 ~$ _2 V
该文件定义了使用可变参数所用到的数据类型:typedef void *va_list;
# t; Y' I+ F, S s1 W# v6 Q9 Mva_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,+ y0 u6 E+ Z* X: O/ ]
parmN为可变参数的前面一个固定参数.& m/ F3 x4 O! M# U( D2 L
va_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.
9 s) s" z5 W- L" `* z- M% } Nva_end(ap) 结束可变参数获取.! i& z+ k4 h5 R. X- r" L6 T
* g4 A% H7 }- `/ l" U4 H7 z) m
3)可变参数的使用实例
, l& E: J, {9 T& x! d" O. I2 {
4 k( r) E& m- i! F实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
0 j* S e9 _3 t# E* ^4 U* |$ L* H: T! H+ w) j3 v' G- {* |: x
#include<stdio.h>
5 x. E6 k2 K: J9 X#include<conio.h># v7 ]. A7 \- c
#include<stdarg.h>
+ p$ F# Z. M0 z& Qvoid tVarArg(int num,...);/*num为可变参数的个数*/2 o: A# A7 n- w+ G7 R3 g) ? O3 h# w( C
int main(void)
8 K" C8 x6 ]+ Y3 Y{9 ?( n B" j, l) j6 B
clrscr();! } {6 y; |8 {
tVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");; R2 `3 P# t7 x, h% B; d0 N' K2 K# K
tVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");) n3 B* e" T+ ?) g$ a3 e9 v |
getch();, s6 C1 M; c+ U+ r7 J
return 0;
4 Y( w2 E. z3 [8 f9 v; {% N}3 U: u% `: b( i5 n7 |; n1 w
void tVarArg(int num,...)
; {+ E8 `9 \& X- Q& z9 I* J{- G& P+ n( k% V2 i$ k7 p
va_list argp; /*定义一个指向可变参数的变量*/
: [2 p9 S/ i# f5 @va_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/* D$ h3 p _* y) F8 C
while(--num>=0)
3 }% E5 A% _/ x& Z. r printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,
- l7 k8 h0 f7 b: S4 i 并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/( w! d* w% e- J3 ?' x) t
va_end(argp); /*结束可变参数获取*/4 l9 y2 D# b& j3 i5 G% b
return ;
; I( z: f, A$ N' D( Y. q} ^, T0 ]* K6 r& M2 `' }
2 d) G+ e X& }6 K5 T: Y5 j
4)可变参数的使用需要注意的问题5 q7 t( t: Z7 z; h* U
; B9 U4 m$ v! D) ^- J
1.每个函数的可变参数至多有一个.
5 p! J/ a& O2 q2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.
% ]) d8 L' h- P9 H7 ~$ D' f3.可变参数的个数不确定,完全由程序约定.
: Q6 u M& R1 N) X9 w, q0 U4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.) f: g U5 {2 z+ v
而printf()中不是实现了识别参数吗?那是因为函数 & Q3 W) o) e* k
printf()是从固定参数format字符串来分析出参数的类型,再调用va_arg 6 t1 Z9 ?1 ] Q, o2 }" j
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
2 C3 W. t; P- I3 h, e/ ]) M) v过在自己的程序里作判断来实现的. ; [9 p5 H2 j/ s" _+ S
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高. |
|