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

|
函数的可变参数详谈
可变参数的英文表示为:variable argument.
' Z6 B1 v, |" }9 h9 P它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.* C( o0 j. y% B' \/ F& E# f
可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不
: d; o) {2 K1 M+ M: ?6 o定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有3 x; V4 S- t' p: m! v4 M( U
实际的名称与之相对应.
, I# Q. J! i* f& y! l由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.# r2 A/ G) }; k) e% n- t
然而,更多地自由,同样也加大操作上的难度.
* x8 g( Q4 T0 A0 s( B# x以下就对可变参数的几个方面作一定的介绍.
4 K& \1 j1 j% h: X$ s8 D) _1 I* O L; s% {9 |4 E4 q
1)可变参数的存储形式.4 \0 q* c6 }9 d3 q
" u0 I6 B9 `& w2 P7 _+ ^大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,5 L7 U2 f- N; f# P, o
存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.; ~7 L+ } T8 g$ \
在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,4 F0 }4 a- C5 x/ Y, f, \
这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.) e0 w; L' U4 p2 z5 N% ^6 f
因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):
+ V4 x3 h; b: i栈区:6 N3 D) Q4 |$ |7 {
, }0 ?( K. K$ n|栈顶 低地址+ E' c/ u, T* E% R0 N
& B w# J4 K+ r0 Q* C: p9 ^: }! @
|第一个固定参数var1
" K, x# [- K. p" |0 T6 _% k% g! Y|可变参数前的第一个固定参数var2
+ L: ?5 N& u- `$ @3 d8 _0 B3 l|可变参数的第一个参数) B6 l3 T/ x" A; _" B* F9 a! y) T
|..., g) ^* X2 B4 \9 L/ t' V
|可变参数的最后一个参数
4 f+ z0 `( x0 u9 w, ?|函数的倒数第二个固定参数var3% R! a9 h: d6 I2 I+ `, `% H4 t
|函数的最后一个固定参数var43 s1 B( D8 O" P( Z+ q8 c# B+ p1 N* [8 N
|...
! i6 K Q2 v$ o|函数的返回地址9 h2 F0 b' _5 r; c% G* E2 q1 L5 z
|...
8 l& [' V& ?( L# U|栈底 高地址
$ Q ^) W! m( n5 r U) a" Y7 Z" a* a8 z9 z
2)使用可变参数所用到头文件和相关宏说明1 S5 H E7 k/ a( x1 R) Z
6 l+ Y9 y* e) |, E1 w w; q' v在此,以TC2.0编译器为参考对象来说明.0 D. {. i c+ o) O
可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.& H/ ~. P7 M( u6 f' g: X; x& h6 x
此文件为:
- @7 |$ _6 z* Y$ X, r1 _/* stdarg.h
5 L; N9 q: z4 c( l
7 P: X9 q. j5 U) S7 [2 N7 jDefinitions for ACCESSing parameters in functions that accept
* v7 W+ @, o* `# Aa variable number of arguments.; i+ ]9 r, `8 h
$ Q- T: A \$ r# p* I* i: ~# \
Copyright (c) Borland International 1987,1988% d) `2 ?7 T* @& v" I
All Rights Reserved.
- Q3 B) i; [) ?8 i4 l*/
* Q! [. `" N# ~% ^8 H* Z6 z! M5 Y( S#if __STDC__
6 a; q& E9 E) h% k- @& }9 M! h#define _Cdecl# n$ g8 Z/ K6 S
#else% H( X1 U- ^5 M& d' W$ E
#define _Cdecl cdecl
5 o3 M" X7 O' U; o6 F#endif1 L- {8 k n/ p
+ g$ G& {7 m4 `* N#if !defined(__STDARG)( c5 @6 g# D9 i. G9 g3 F6 A$ e9 a
#define __STDARG
4 z8 U- ~$ v' R# Z" a" r8 ]4 c! R/ Q. f# C) ^% r% K
typedef void *va_list;
6 b' Z& L- h2 v. H. F# i
* h0 F3 N: T: G' X#define va_start(ap, parmN) (ap = ...)
% O0 q& N( ^2 ~ c, h+ [#define va_arg(ap, type) (*((type *)(ap))++)
3 _, ~! N" R8 d#define va_end(ap)" ]3 ~: i& z) Y. W5 U+ [; U
#define _va_ptr (...)! v$ i# ?3 w5 Z2 c6 h
#endif
# |; r1 l9 Z/ l q5 B8 \; G; b& _. h* A% y) r, L
以上为"STDARG.H"的内容., K) {+ Z. }3 Q& y! `% e. {- ~
该文件定义了使用可变参数所用到的数据类型:typedef void *va_list;
, l' C/ i- _) S3 f6 z8 V1 [va_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,
6 O- K. J6 h4 p2 uparmN为可变参数的前面一个固定参数.& \9 {1 `3 L9 Z- X8 o, b& |2 S4 P
va_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.
4 o& C$ Y7 ~6 n2 M' Xva_end(ap) 结束可变参数获取.
- ^! r2 s; ]1 U" S, q; E- h/ E* k! R1 I
3)可变参数的使用实例9 Z5 U- I* A( u: b' b2 X: M
0 ~4 Z% ?' a' c; f实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
6 W% E" v2 i$ n Y( L' `3 c# ]3 V& u) `" y. l8 }0 I9 F) q
#include<stdio.h>
! [' M4 H: t# u/ {5 ~7 `, P#include<conio.h>
4 K, Z5 T% U* J" F) A" e#include<stdarg.h>7 M2 _# J8 P4 ~7 G
void tVarArg(int num,...);/*num为可变参数的个数*/
3 E: o: }5 D. S* b% C, {) ~7 zint main(void)
' ]& P" v0 ^) Z{) Q4 Y6 a1 [4 D' p5 i( _
clrscr();
" \1 L6 b; M+ Q* I: f4 KtVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");
# g" W' U$ x% I `8 mtVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");
/ h; [! H/ \, T+ U9 A$ y ^* kgetch();# [4 a/ Q, k5 s$ |9 g
return 0;
6 x2 \7 } y5 ^1 i/ r}
, T" } p0 O' x. \void tVarArg(int num,...)
9 u2 |! E- B2 ^- k# f- n{
9 u; e6 I+ y! O/ pva_list argp; /*定义一个指向可变参数的变量*/
$ x" r( U2 k' E3 M8 }va_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/% G5 ?% E; q6 @" z( ]
while(--num>=0)- X H/ f* {7 u2 Y6 U
printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,7 A9 H: X5 g) w$ e
并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/
; ~4 t/ }4 n- l# R% wva_end(argp); /*结束可变参数获取*/
! A: A1 e, l3 m& ?4 k0 Greturn ;, j! R" @9 Q7 N
}
: Z5 I( Q& q/ d4 y+ c6 e
. G$ `- y6 X+ ` S% u9 v: o2 W% j4)可变参数的使用需要注意的问题
6 d, ^$ s4 o# d
+ R& q8 |; U6 d+ I% n( x3 d- J! \1.每个函数的可变参数至多有一个. n6 X4 q+ l3 T9 |' a6 U
2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.: B) q$ E8 H" M# \
3.可变参数的个数不确定,完全由程序约定.
: S/ ^3 ^. C# W! z- D4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.% f Z6 r& F J
而printf()中不是实现了识别参数吗?那是因为函数
0 s h. G; ~) ~. \; o/ V, vprintf()是从固定参数format字符串来分析出参数的类型,再调用va_arg
( i- @: g4 I# X/ W# T的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
. ]1 Z! v; G% h4 d过在自己的程序里作判断来实现的.
/ G s8 Y3 r) A" @" G5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高. |
|