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

|
函数的可变参数详谈
可变参数的英文表示为:variable argument.
/ m5 N/ m2 a3 x6 Y/ d8 u& N* u它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔." Z2 y0 I2 F4 p c% f
可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不6 g6 k7 n* P! Q, V$ [( d
定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有5 y% H$ |% W: Z# k4 O1 k7 K
实际的名称与之相对应." M% t! U {% K1 L# k
由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.
% Q/ x/ O& r7 E然而,更多地自由,同样也加大操作上的难度.
! R4 {7 W' a s1 n7 ]. b/ a以下就对可变参数的几个方面作一定的介绍.+ P! q" e. K, t5 ?+ Z& }! G2 E8 c
' U1 m/ q; P- Y1)可变参数的存储形式.
+ [" J! v' x: O& `
n/ A& G, X4 s8 d$ d4 u大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,
& j8 R! ~! P. S! J" P存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.' ^8 y3 e& a% |6 R ^
在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,
8 A6 u& R( i9 S- A6 t. ?) ^这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.
! {' C J* y3 _! i+ I因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):& P7 g8 ?' {! W
栈区:2 t+ { A8 k# A
$ i8 B; v8 H! b/ ?|栈顶 低地址
# k5 D6 u! }, U1 C! U; P4 E# J8 S/ N* N: Z8 m
|第一个固定参数var1+ b3 ?0 b6 z' r9 `! m$ ^
|可变参数前的第一个固定参数var2
% {$ p6 r% Q$ m! Z( e|可变参数的第一个参数. X: X1 e& P' T M" X' D6 y% `
|...8 r" p* ^ M5 x( w6 J/ W
|可变参数的最后一个参数4 z/ `/ x, }# @' b, f) s$ M
|函数的倒数第二个固定参数var36 u y* X3 l5 s e4 @
|函数的最后一个固定参数var47 G, K* x6 R4 a9 e
|...
/ S4 Q# B3 O% Z|函数的返回地址# l9 J% O+ I) q9 k, ]
|...
( o5 X: V6 P. Y6 T4 u0 E- ~1 z|栈底 高地址3 B6 H; w$ i! Q6 O6 W8 ?7 y- w
1 o6 {6 w5 ^& v% y. B
2)使用可变参数所用到头文件和相关宏说明# q7 }3 w/ B% O0 x: o
4 r0 k; Q+ H2 i3 s: G- T在此,以TC2.0编译器为参考对象来说明.! \, w* W% M" C. ~1 D
可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.- o' |! A) f& F& ]# a. H# }6 G) D
此文件为:* a$ m( F! `9 Q6 U4 T4 z
/* stdarg.h7 m( h* L$ k7 P6 Q, i7 ~
; m/ f! h) R8 P! }; _! [2 ]
Definitions for ACCESSing parameters in functions that accept
3 x' l: M; ?$ @# z1 @: J5 ja variable number of arguments.5 v2 h) s' Z9 A( K1 e$ S
4 Y% ?, w0 H4 xCopyright (c) Borland International 1987,1988
& d8 g# _& L+ w: m* y" MAll Rights Reserved.
0 t, I- c! Z: H3 @& C*/
* j. ^" f7 X, S3 U& I#if __STDC__
4 {1 m( L( V9 h9 e5 j#define _Cdecl5 x) }0 M! Q$ e* o5 n* W7 h; z
#else
0 u7 z, J ]- t5 b#define _Cdecl cdecl# M( b/ @3 s# I z5 F/ J% M
#endif) [2 s9 T) j9 Y1 P( u: X+ Q
' K: O. Z# c6 d B
#if !defined(__STDARG)
5 _9 {, N$ C: `$ y Z#define __STDARG
: ~& |% g4 I$ @" h9 g/ w. U8 `& Z" y' o4 ]. |
typedef void *va_list;0 j. U" X6 }' T0 Y( W- t2 `6 c& A
% F& y, N8 e. A: V$ a
#define va_start(ap, parmN) (ap = ...)
) p5 t" U/ I& k: A* F: g9 P#define va_arg(ap, type) (*((type *)(ap))++)' t; @" |; O. t+ b
#define va_end(ap)) o* E: p( R) b
#define _va_ptr (...)
y# g; |- b3 ?) J+ O" H3 `$ I#endif1 ?: S$ T0 V- J4 g6 o/ a9 O& }! V: \
|% a2 D) Z# V( q& o& H以上为"STDARG.H"的内容.
/ I" V' u& t8 h# }. F7 v- \该文件定义了使用可变参数所用到的数据类型:typedef void *va_list;3 ~: r1 x+ C' o8 X7 [+ c
va_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,3 `1 N2 |. j' M7 V5 a! t; p
parmN为可变参数的前面一个固定参数.8 Z" f+ ?" l% c7 L
va_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.& O; x4 s C; e$ t1 V5 R( N- n
va_end(ap) 结束可变参数获取.
. [9 c. g. O* i1 a, \- ]3 M8 e- C9 a! q4 P
3)可变参数的使用实例
( \6 l0 S7 C/ o' M7 m n+ b5 \% K$ J2 F" H
实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.- x* E0 v/ a6 s, w+ T, Q( ~2 ?' G
% K2 Q h# ?! x F
#include<stdio.h>" N0 I) ?6 T B. Q' J t
#include<conio.h>7 o. A2 J+ C3 L& M/ j6 r( [
#include<stdarg.h>
* O7 Q) V) D" T) I' Gvoid tVarArg(int num,...);/*num为可变参数的个数*/$ j8 ]- i# @' H4 d$ g5 r( H! a4 k
int main(void)
8 h+ k$ Y' U% y2 W# \7 c{4 T! }( Z' j0 v5 W, }, g
clrscr();
# X% E2 z0 N+ ?* }! \# JtVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");/ I3 i- ^' n1 S4 N7 K3 U" M/ U
tVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");7 r9 l% ?5 _' y2 L) T2 ^# W$ x
getch();3 Q2 Y) R8 u" `2 v
return 0;# V: o1 o- Q: p+ [3 { [" q- ]
}
. N" U; s) g, N6 Hvoid tVarArg(int num,...)
$ p+ t* S' Z# W6 d4 k{
0 M0 z' t+ e& m5 H3 {- B/ U; m8 Dva_list argp; /*定义一个指向可变参数的变量*/
7 \2 n) [/ c0 _8 U( Xva_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/
# B8 B" v2 L, W! t; V) ?while(--num>=0)4 ]8 p! ~9 l9 |7 G
printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,
& R6 b2 n$ `* k+ i" j 并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/9 T; @! i; R8 I6 x: @. f& u6 u
va_end(argp); /*结束可变参数获取*/
, A: Y5 e" f- n( Sreturn ;
9 j1 X* o$ M: l9 o0 d0 B}
# G! T4 N1 f. z& P- ^* t4 u
r, A/ v- B, {' F4)可变参数的使用需要注意的问题
7 r, B" ?( I# {: I( L, e' K {: q) ], B' m0 [4 q
1.每个函数的可变参数至多有一个.$ Q$ R4 ~" `1 ^# o+ h& g- `
2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.$ {( g% F. e/ d, q8 i8 h
3.可变参数的个数不确定,完全由程序约定.
3 K- x( B7 a4 s5 T4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.
# A# P9 o6 E e- Z9 F5 [而printf()中不是实现了识别参数吗?那是因为函数 ; n2 q. f# \* W* f' X* Z' s
printf()是从固定参数format字符串来分析出参数的类型,再调用va_arg
5 q- H1 o5 W! w* p" ~" {- X# A的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通 6 Q/ u' a5 E; ?& w% s
过在自己的程序里作判断来实现的.
8 E( _- a4 z+ d( b5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高. |
|