返回列表 发帖

函数的可变参数详谈

可变参数的英文表示为:variable argument.
& M. p: F& ]: J& k4 b  u; ^它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.
3 _) |( L4 s7 F# G* [% D7 w) q可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不  ~# H! c  m1 X) n) d
定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有
  m$ i% V. x# B/ S3 {. @' J% U5 x3 s实际的名称与之相对应." Y6 L# T+ A/ r4 t% I
由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.8 A! d& i) J* L1 f3 d. m" D! l
然而,更多地自由,同样也加大操作上的难度.# z( A4 |' d1 }
以下就对可变参数的几个方面作一定的介绍.6 A7 P2 q" \8 U- L9 m( A
+ q- `. l" @* M# e6 z( n
1)可变参数的存储形式.
3 g# F! I8 ?- O& H8 X2 ?- j. I8 L' _3 q! Y
大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,
3 o' W# L* y5 c: w存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.
4 L0 c0 s3 V, E- c4 o; L在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,
1 Q( D0 s. ]- l; a# g这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存., _$ X( W8 ]; S. g9 v
因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):+ @, H0 A  U5 ^# k, f/ P
栈区:- y& J, i& L( u! L2 o" v1 d
% K5 ?6 S" `" _1 L0 j4 e
|栈顶             低地址
9 A- s. i2 Z3 F( R/ Z
/ ^, ]3 |  }. t0 x8 m|第一个固定参数var1
/ j. K+ B0 |" p% ]; j# B% S  U|可变参数前的第一个固定参数var2
2 m8 r9 l* m. l- U7 n|可变参数的第一个参数
3 U- b0 c: F  P- r4 {$ `0 ||...: S. L3 g8 d: |7 u) N7 W
|可变参数的最后一个参数: v# U, ?- e/ w+ m( j: p2 l. }
|函数的倒数第二个固定参数var3
0 @9 R' ]) G2 l|函数的最后一个固定参数var4
. n9 f! V  y# }* P* `; t|...7 X4 C0 ~& _, O2 c& f
|函数的返回地址# u8 t! M6 A3 v- }2 `' X
|...' y. t) ?& k+ K4 W
|栈底    高地址
$ Y# S5 g; H$ ?- S
* j% u# g: \: k/ }" o& ]' \* Y2)使用可变参数所用到头文件和相关宏说明
, C% Q4 {1 D  a8 F
2 q5 R- _0 D- x( R在此,以TC2.0编译器为参考对象来说明., @, S! w8 B0 P" q3 U; g
可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.
$ _! m+ }  G1 v# c! k& }9 v此文件为:
! ~2 ~  I5 m" t* L% s4 S5 t/* stdarg.h: `6 E& o/ l9 t

# g6 B* e/ [. s/ w: qDefinitions for ACCESSing parameters in functions that accept
% d& |+ N& e$ W; ]% Pa variable number of arguments.
. @/ o, e6 b2 Y8 _& X+ Y6 T  O* {8 {6 O3 n3 b0 I( f4 a0 o, l
Copyright (c) Borland International 1987,19883 Z. \2 ]% L& A7 h) ~- ^
All Rights Reserved.
! q4 G. E& {; q* V9 k" ~; F*/: n5 m& ^# m, a/ a+ H
#if __STDC__
4 Z! S; v5 Q7 I6 b#define _Cdecl5 L* G; f& s8 R7 `7 k- r
#else
0 [$ I8 m2 v8 K9 G#define _Cdecl cdecl
, e3 _- O0 U4 C5 A# L& [#endif1 j- k% T+ i2 k# b3 M! W
: Y6 J( N! b/ E( r. Q. F
#if !defined(__STDARG)3 \6 C4 n2 _0 z
#define __STDARG
  }; M) B1 d, h* }2 z+ h0 G/ i# \- P: J+ l
typedef void *va_list;
' H6 \) ^% {2 @8 y# x# y( ^4 d+ z1 e- `" y  L
#define va_start(ap, parmN) (ap = ...)8 o( G2 D6 M; O: B  b0 h
#define va_arg(ap, type) (*((type *)(ap))++)2 d; D) ?% o0 Y0 b# H5 o! J! \
#define va_end(ap)
" E/ a  ]3 P6 B5 r! O% q$ H#define _va_ptr   (...)& x) I7 N9 f: a; u( I! y
#endif1 _* v: K% W$ a3 T

: u  W$ O3 c! K& ?5 i# k以上为"STDARG.H"的内容.
4 C" P' e; ~/ T4 q0 P( w该文件定义了使用可变参数所用到的数据类型:typedef void  *va_list;
2 c2 \# |9 Z! m; ?4 p; G6 cva_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,
* X  ?% ]# A- G2 K9 WparmN为可变参数的前面一个固定参数.
: W0 F8 d4 u1 V( W4 ova_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.
" Q* v0 g3 C* U$ I- Yva_end(ap) 结束可变参数获取.: p, x! f- M: T

: b0 o' I! `2 ?0 k) \3)可变参数的使用实例8 G* C% z9 Q* c: Z" }- x' E) X

# B" q9 o& v$ ^实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
# p, s2 w9 I/ v& D2 a4 B6 [( I' P/ t2 S' Q$ q
#include<stdio.h>
( o; H% t; a7 Q/ Z  `#include<conio.h>" _2 I2 [9 d5 G$ R9 V" C
#include<stdarg.h>
0 F6 S0 r* b6 M+ {( T! a- P: avoid tVarArg(int num,...);/*num为可变参数的个数*/
, c3 ]4 A4 f' w0 A# ]int main(void). U* k& x2 x) g# t
{
, x* H  h) G% L& `$ Rclrscr();  V/ e! U, Q& I' B+ D3 I! Z
tVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");
) k, w" z/ F; F- D9 _tVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");
4 V" m* C" Y8 Z+ q2 f0 `9 @/ z3 Bgetch();
% ?2 G' n- e- t  M! t- M; k8 D3 W/ ]0 vreturn 0;' n! Q$ D4 P- p7 V. ?
}3 |' N* X, G8 E4 e- w! J- v
void tVarArg(int num,...)
0 b* U3 I/ ~# Z, q, l2 u0 k{
4 ]& a$ ?# b( N8 N6 m" c4 Q5 K' Nva_list argp;  /*定义一个指向可变参数的变量*/
- i* y/ N! ]7 Y; a5 d2 V) v! @& B: i6 Sva_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*// J/ h% W+ I+ d1 M6 A2 w
while(--num>=0)' y. ?. V4 b: {# {) [$ Z0 \
  printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,
  h+ s2 e! w1 i. ]; K$ b  \4 t  ^    并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/* T" J5 g  N8 M' i2 e" N$ T5 x
va_end(argp);  /*结束可变参数获取*/2 Z3 A+ \5 s/ L1 i7 V/ o/ Q
return ;
. `, Z  R% Y* b" m6 e}
, _) b& ^  I0 R4 a
; F1 S1 u. i' ^) j4)可变参数的使用需要注意的问题6 k5 x+ v+ w4 c

8 n5 }0 U2 Z8 Z$ @2 r; }0 |1.每个函数的可变参数至多有一个.& L/ E4 ?' q, T% O& s' o" F2 W1 _
2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.- r& g5 G0 {+ Q% y0 C
3.可变参数的个数不确定,完全由程序约定.
4 s' Y" L) U: R4 y  t$ K9 Z( J4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.( ]' @0 i% u0 s) J. x- v
而printf()中不是实现了识别参数吗?那是因为函数
$ |9 c  ^8 V$ i+ V" nprintf()是从固定参数format字符串来分析出参数的类型,再调用va_arg
4 I& \0 t( ~6 _2 v- X+ a0 L6 R9 A的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
6 K1 v# h* }) U1 C, e过在自己的程序里作判断来实现的. 0 Z3 x8 x+ N) U; S! b
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高.

返回列表
【捌玖网络】已经运行: