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

|
函数的可变参数详谈
可变参数的英文表示为:variable argument.6 c) T' A$ c" _! H
它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.
' S9 i5 s/ E _9 w1 Z4 O) g* _: x可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不
1 f3 u8 \" U5 \) e5 ^6 b定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有0 _8 ^" m$ I. |3 ]
实际的名称与之相对应.
! w" m+ o) [2 O9 {' r由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.
; r. k* N4 A' j M& ?" c5 {% z然而,更多地自由,同样也加大操作上的难度.
! _# Z' n4 t7 S; [! t$ G0 c" j以下就对可变参数的几个方面作一定的介绍.
9 l1 z8 R- j5 r+ o
6 s$ J0 V' P; P7 S. f0 @5 K' M1)可变参数的存储形式.! j) ^ B/ ^" L- O2 k' I, e* [9 Y- Q
* F/ y- U, k X( v6 h# v) ?大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,1 I+ U$ G+ L+ p+ D) }5 D( K; [
存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.; r$ g8 I; e, N8 K4 Z
在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,) t2 T0 L5 j f" u e. {9 [
这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.
* g0 c6 C0 t% ~! h因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):
0 {( B( F6 F' J) S. y3 Y6 X栈区:
: a! [4 I, X# B3 f o' @/ p- i- Y) U3 \# H& H: P
|栈顶 低地址! Q9 G' D" L' v& W* r
0 g! x$ E4 v* ^. ~' `* a|第一个固定参数var14 Q: t+ P0 D5 s( X# |0 O, e
|可变参数前的第一个固定参数var2
" X2 h9 ^6 U+ ?6 Q" ]! N* }" L+ s2 d# w|可变参数的第一个参数
( |7 R4 D7 X6 \( P) `/ q/ r|...
( N( X* m' h3 i Z# I3 w: K4 w|可变参数的最后一个参数
1 G3 [& E! p2 `/ K1 x. t0 b/ Q|函数的倒数第二个固定参数var3
1 `4 w/ Y9 R* y f0 G|函数的最后一个固定参数var4# S% j7 {4 o; {5 q- H
|...- z0 {4 B) u) o0 A
|函数的返回地址& n7 _; I$ t% Q! s; j( l5 a' e; R
|...
9 i2 K z2 S1 ]1 M+ M9 Z$ c/ e5 o$ s|栈底 高地址
) q7 r# f7 Q2 q0 {+ }9 V6 X( I! f. [8 i/ Z* m$ Z
2)使用可变参数所用到头文件和相关宏说明3 T) N# u2 U U% `
4 \9 ^7 k8 A" S0 L7 |/ q3 O: R0 q+ X在此,以TC2.0编译器为参考对象来说明.; u5 f+ H" J' t h; G x9 T
可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.- y% j# F- q4 K( f- @, e. F6 M
此文件为:8 s" z+ T o% [& @7 e& h! G( e
/* stdarg.h
( P5 _ F: c, h" ]7 f; a6 v- e9 [- _7 A
Definitions for ACCESSing parameters in functions that accept
3 [% S6 D* j* K3 `+ U& Ca variable number of arguments.
+ [; m7 P; Q; ~; Z0 m9 ^
. {) ]; K' z$ y' d% fCopyright (c) Borland International 1987,1988
( t" e: S D3 i, T# M1 kAll Rights Reserved.; x5 @1 G- E! y0 A' p6 s' ^
*/9 p$ s, n* q" x
#if __STDC__
. B3 r' n8 U' l1 M" `. U1 j7 x#define _Cdecl
5 f$ _: j" `3 R#else! n7 ^% K% n7 t+ v/ q
#define _Cdecl cdecl
2 J4 [# w8 Z x1 k5 m0 {; L, R#endif
3 C3 C% s( p6 O8 y- k# A" y$ p1 Q) x* b. l2 t
#if !defined(__STDARG)& V6 J8 q; r1 C
#define __STDARG$ e( L+ `) s$ d O$ M( N0 d5 T# t; b/ @
* j2 v# U& s4 D4 G; y7 P: etypedef void *va_list;
Z2 _+ |4 Z& J- H6 q
7 z+ {6 R& N' W; J' q# R#define va_start(ap, parmN) (ap = ...)
5 i4 g6 P- W N3 m R#define va_arg(ap, type) (*((type *)(ap))++)
/ C5 [: S% @4 f( c. Q#define va_end(ap)
" e9 I: [; ^. S#define _va_ptr (...)7 j. s2 F0 {" {( j5 P
#endif' i7 ^: Q# P& ?; s/ |
4 u: `5 m( h* H6 O1 Y以上为"STDARG.H"的内容.
% Y/ H& O" P) b( v |6 l该文件定义了使用可变参数所用到的数据类型:typedef void *va_list;! f, O% D, B# x9 y H/ v+ W
va_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,( R# W% _! l' D( C: U8 v
parmN为可变参数的前面一个固定参数.
& H; C" _0 d; U9 b8 ?* ]va_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型." h- n9 i6 |6 r$ }/ A/ h
va_end(ap) 结束可变参数获取.2 ~9 x4 V$ j& u2 {, e2 ?0 H3 h' X
: n1 C3 F/ i& n% F5 w' |* y/ L
3)可变参数的使用实例9 L+ Y2 n: I# N% N x
7 p% _4 M3 G- ^7 c! f. l) I
实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
+ h- ]4 V+ i4 L' u: F6 t0 z# @
$ ]" x+ r: ]2 M: N6 x, O- \1 _#include<stdio.h>
! K, r, C. P5 w! j4 }* U#include<conio.h> k+ b' w: W2 C% ]+ y5 k5 N# i$ G
#include<stdarg.h>
) D% N- @4 D: m, ?- Z# ]void tVarArg(int num,...);/*num为可变参数的个数*/3 o; m2 V" h! l
int main(void)
2 @% z E& u8 T* |( ~2 J4 ]% ^{; M" f1 \# M: O: B5 d5 _7 v5 O
clrscr();
$ L* q$ F% v4 B$ Y6 M/ |9 j+ |tVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");
) v. ~& C' Z! ?2 o) @' T4 u: X. E( x& ^. GtVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");
: M$ p, A- k8 |1 Hgetch();3 `& Z+ ]# r3 Z4 t
return 0;
% r6 M9 a$ Q# n- p) g4 }6 d}8 i: Z* g( H. a6 Q8 n- c$ A
void tVarArg(int num,...)
6 z' a! X( y! k1 c{
5 L3 U! m# b' o$ K% F6 g gva_list argp; /*定义一个指向可变参数的变量*/# p3 O, N0 y! `0 E2 x+ R* Q
va_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/
" Y5 `1 G0 _6 l1 {3 t1 Ewhile(--num>=0); ]( N' e6 j! m" w5 \8 v% A) p
printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,
* b) Q) V& {& W+ o( V 并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/+ D+ L; g) ~+ h) |+ g" S0 p1 V
va_end(argp); /*结束可变参数获取*/8 Y+ t4 R. N* R1 T! X4 u ^+ M
return ;- i( l2 W- X: \- c8 W5 X* O/ k
}4 F1 l, ?* }/ _+ ~
/ J0 q! z3 [' R# e* ]5 R5 i4)可变参数的使用需要注意的问题 E" o3 Q8 k' s7 A
! e0 B1 ^( Y8 C, E: N
1.每个函数的可变参数至多有一个.
( t% a G/ z% |6 V/ l2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.7 e1 `# P. T3 j8 a' l6 c9 U
3.可变参数的个数不确定,完全由程序约定. v2 ]! f4 S1 C3 e% C1 s9 q1 q) b
4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.8 V0 ?) g; {8 h
而printf()中不是实现了识别参数吗?那是因为函数 2 q! Y8 g! W0 Q1 D" |5 E. b
printf()是从固定参数format字符串来分析出参数的类型,再调用va_arg $ L& P7 i% t. x6 d# v- c. v0 u
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通 : y% R- ~, ~7 F& L6 w
过在自己的程序里作判断来实现的. 0 A$ T7 g7 W; S* I. v9 p+ b1 v+ {4 N
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高. |
|