返回列表 发帖

函数的可变参数详谈

可变参数的英文表示为:variable argument.
2 v  H! s$ E6 E它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.% @3 u& h+ Q- M  E
可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不" V; Q. c- D. ~5 H
定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有
( B5 w+ ~: J9 I& H" c, ^* F实际的名称与之相对应.
5 |5 M% A" Y9 R由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.2 K+ W2 G2 t' ^6 e5 ?
然而,更多地自由,同样也加大操作上的难度.  j$ p. ]+ T( y
以下就对可变参数的几个方面作一定的介绍.  a4 Q( D$ B/ ^3 G! P

7 m& P& S, \% Q$ W* M4 v# }1)可变参数的存储形式.4 E9 o( {' ?! P7 }6 u0 i5 M

& B: h4 J% @7 W/ v7 p7 L大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,
( l, r: n& j! f- C2 O9 W. x: N+ b7 g: U存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.8 R8 z- B5 g' a  r# f
在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,
5 [, {! ^% A  a" O这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.
8 {- J$ l+ @4 e( V因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):. T: w/ F! A8 L& h
栈区:1 @4 A8 [& C* j* H4 [/ ?1 W8 E/ V

7 `6 w6 \: b' w/ ^, w8 q8 @- ]|栈顶             低地址
0 M; K1 r0 E. i% a$ P9 N6 [( t* ~8 G" a7 t/ g: c2 p
|第一个固定参数var1
: {  r6 y4 X; k: W2 e& v" q; ~( K: R|可变参数前的第一个固定参数var2" V( W8 I& p# V$ Y5 {6 t
|可变参数的第一个参数/ y. F- a# ?, n& t
|...
+ Z- o' K! L# w+ J, {8 P|可变参数的最后一个参数7 u( G/ `# o6 O8 p$ o
|函数的倒数第二个固定参数var3
, T( U8 t: ~, f8 d) r|函数的最后一个固定参数var4/ f* q! Y4 ~+ w
|...4 ~4 t5 X' f& n7 p, L2 [1 l
|函数的返回地址
4 i0 X7 D0 Q  e$ ^6 w|...
# C& P+ |. W' |/ J( F+ n( c0 C|栈底    高地址& w: z* W' a% G- O! ?8 u6 Z
% k' G0 w; u! Q5 X' R
2)使用可变参数所用到头文件和相关宏说明( N) z4 R- h8 N" e" M9 i

; f* {& f& G% U9 f$ K在此,以TC2.0编译器为参考对象来说明.& P, L- L  [7 v
可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.
6 g% j" L& z+ c6 G此文件为:
) B5 ^8 U% _. S3 `" @/* stdarg.h
2 Y3 e; e+ H/ ^0 U: g* D4 R7 D" {  H) `
Definitions for ACCESSing parameters in functions that accept
+ Q( N8 u. F$ }% Ja variable number of arguments.
3 }5 C0 A! N3 ~# D& r( ]& V/ i: c6 j
Copyright (c) Borland International 1987,1988& V/ _0 a0 m! C
All Rights Reserved.) [7 J. r5 ?5 `" l# u
*/) }& N7 P0 r) o) `% i
#if __STDC__2 A$ M3 V1 Q+ L9 D$ R# J. j
#define _Cdecl
2 O- _( ^; d6 k#else6 J9 K/ N7 h$ H2 I7 F
#define _Cdecl cdecl
5 ?# ]1 M3 J) m& N#endif- Z5 q' \5 P- T6 Y5 |
( t" K9 h* L1 D6 |* B" G: e/ ~4 B
#if !defined(__STDARG)
. s  z7 \. c7 S/ c9 W#define __STDARG
2 ], g5 b+ F5 T* C) U% c9 \
: l, Y$ e' |1 |. [- Y! Atypedef void *va_list;. {: T! `9 A7 \+ Q' J
" @2 o+ W, T$ c. v' l! f0 Q
#define va_start(ap, parmN) (ap = ...)
, o0 a3 f* _4 s) u4 J  k0 o) L#define va_arg(ap, type) (*((type *)(ap))++)& N) T) T+ J0 \8 X
#define va_end(ap)3 Q6 _9 b8 U2 ]' Z  m
#define _va_ptr   (...)
6 P4 |3 e$ a* W8 l0 j" }#endif
: z2 l8 g* D, {; B0 Q
9 m" n% ]8 r  A9 J; K$ {5 v7 t以上为"STDARG.H"的内容./ i1 T* u, x3 I
该文件定义了使用可变参数所用到的数据类型:typedef void  *va_list;
1 {0 A4 o0 E7 ^  ]1 T  `8 Dva_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,
/ v4 b" L2 [1 J: sparmN为可变参数的前面一个固定参数.2 H0 Z- h0 _: h# I; K* E; O# e: ~
va_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.
: z- C0 I+ W) k. l5 K( T2 \. Bva_end(ap) 结束可变参数获取.8 V+ n; Z( g' ~+ X, C
1 y1 d& [7 e5 Q, ~" l* y% a
3)可变参数的使用实例( V% c5 r- q! V" J* v, ]5 ]" e7 x
0 u! F' H$ x, p4 t7 S! j  L
实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
9 ^0 J  ?7 E$ |" n4 b! a( i4 r" P7 v' Q% W0 h
#include<stdio.h>
8 c+ Z: x& s8 T8 |" ~  I" ?#include<conio.h>
- e% M# O* ], E  @/ x' S! r#include<stdarg.h>
. B8 o. o% V! e- N  r5 I, Qvoid tVarArg(int num,...);/*num为可变参数的个数*/
. ?! Z7 @7 x- T& k+ j9 Eint main(void)
4 T- o' Z# \' x" Y! m# N/ e{
5 T0 F" z3 s8 eclrscr();) E; J" T6 L# d5 t$ S) t# O
tVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");
- }, s2 M3 h- Z/ s  ^( FtVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");! a: O+ F& @/ O3 W, x& }. p
getch();
4 K6 n7 m$ T+ K" J7 j+ V6 Nreturn 0;
6 B/ L6 M: r) Y& d}
& ]* d9 Y# u0 W  m- cvoid tVarArg(int num,...)' _; Z( g" i5 W7 z+ g: O0 Z  G
{! K" h1 S, o7 U# q
va_list argp;  /*定义一个指向可变参数的变量*/
& b# y( @# k0 K$ M5 u8 _. }  Yva_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/
% y2 g1 }, [' C/ ?# C+ ?" Iwhile(--num>=0)
0 @" z7 @! j! t) r' h6 U/ q  printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,! `1 n) y# M0 {5 R
    并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/
! n$ M$ X) c! I0 R4 s! mva_end(argp);  /*结束可变参数获取*/) y% n4 [6 O9 J/ _
return ;
+ ~% \! U6 w+ |}
, \' q% S9 H9 H3 U# d( Q6 E( J* t. X) t! ~% T9 I' X
4)可变参数的使用需要注意的问题
) F: \) V+ h% A$ a; L$ @# I8 e: H5 i0 S+ B1 G
1.每个函数的可变参数至多有一个.
" I* q3 d% Q2 R4 U9 n1 o2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.* ^1 W( N6 ~8 I- F/ v$ i
3.可变参数的个数不确定,完全由程序约定.
/ w: z* ^# M  O2 G1 b, J1 b+ ~4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.8 C) q/ a9 h, z/ ~" L: f' o
而printf()中不是实现了识别参数吗?那是因为函数 ! ^- u  P3 L5 R, D
printf()是从固定参数format字符串来分析出参数的类型,再调用va_arg
! u" c! u, ?2 ]" I: P的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通 * |3 W- ~) u! w/ g" I
过在自己的程序里作判断来实现的. , d4 l' F5 W1 A8 ~
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高.

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