返回列表 发帖

函数的可变参数详谈

可变参数的英文表示为:variable argument.0 c! J8 c6 Z) h  n4 L
它在函数的定义时,用三个点号'.'表示,用逗号与其它参数分隔.& _9 z5 v$ z& k# M& O7 q
可变参数的特点:不像固定参数那样一一对应,也不像固定参数有固定的参数类型和参数名称;可变参数中个数不
  z1 p$ _  Y# W4 [定可是传入的是一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有) G" C& v' M" ]' y
实际的名称与之相对应.
- E3 |! N8 P( W- _! i' h7 n由此可见,可变参数的形式非常自由而富有弹生.因些,它给那些天才程序员有更大地想象和发挥空间.
' l  d9 i# H/ ?' ?然而,更多地自由,同样也加大操作上的难度.
4 L6 C% B0 r7 r" W7 a& o以下就对可变参数的几个方面作一定的介绍.9 f: L0 Z% G3 p, G" \6 O; ?

* N7 N9 V: W( Z1)可变参数的存储形式.1 r3 T! n, E; [5 a  W5 g, d' N6 S7 ^

* v( X; ^2 f% s$ Y大家都知道,一般函数的形参属于局部变量.而局部变量就是存储在内存的栈区(所谓的栈区:由编译器自动分配释放,* d$ Y! g0 M+ ^8 V
存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。).可变参数也是存储在内存栈区.
7 c/ C: u. d( J+ e( ]& }1 L在对函数的形参存储的时侯,编译器是从函数的形参的右边到左边逐一地压栈,
  z" O) R. Q  `1 Z+ {这样保证了栈顶是函数的形参的第一个参数(从左到右数).而80x86平台下的内存分配顺序是从高地址内存到低地址内存.+ m# F* j! Y5 n4 {. H$ Y6 p/ r
因此,函数的形参在内存的存储形式如下图(以fun(int var1,int var2,...,int var3,int var4)为例):# J- ?, g% {1 V3 |# u, j) V0 I
栈区:9 H( e6 ^7 \, c

- `( M' F$ u& u# }  C# s; o; j! g|栈顶             低地址
/ H# Q6 p8 J' \5 D9 `# [. J( W, r0 X2 e( P
|第一个固定参数var1
; L4 y6 y* i7 T+ ||可变参数前的第一个固定参数var2( ^' r, E/ x% E# S' w/ R7 f
|可变参数的第一个参数; b% ], L8 b# H
|...! {8 R) N, G" t) a6 D1 ~! z, Y6 J
|可变参数的最后一个参数1 @8 x' g; x& _6 O
|函数的倒数第二个固定参数var3' {7 p$ Z% L% c* f' v" n& x) d
|函数的最后一个固定参数var4
/ d5 ~3 |+ y- G' \|...
. O' H# M7 q* }. l% ]* R8 O& f6 z& g. r|函数的返回地址
  |) n, K8 _2 l" _|...
- A9 S" U& @$ l; U1 v|栈底    高地址
5 U' _/ j5 e/ ?2 L$ J0 L1 ~3 j" `
( l) e8 J( D; c! a/ F: C2)使用可变参数所用到头文件和相关宏说明  @9 v6 e- z1 R3 S5 ?1 R

0 \0 F/ }( R2 f在此,以TC2.0编译器为参考对象来说明.
9 C- c# o* B0 b  @3 p* {可变参数的相关定义在TC2.0的名为"STDARG.H"的头文件中.4 k2 ~3 \3 i0 d) j
此文件为:
0 I' b+ y, H* k# Z/* stdarg.h, w. D# o, _  z( v0 e
/ S7 K* v% y2 I
Definitions for ACCESSing parameters in functions that accept
, }, T: j& D, b( d9 Sa variable number of arguments.
3 e# B2 d7 L$ Y/ }6 |/ z4 B, x. e' o+ P7 d
Copyright (c) Borland International 1987,1988; S% H# v% E$ `& z1 ~
All Rights Reserved.
! F' c. u6 j: S. d/ y2 Q*/, w1 O4 @) K' p1 C, \/ k
#if __STDC__' u# p5 G$ x! b! u8 r( p! g" A
#define _Cdecl. ^9 _. s' ~" d: j8 O2 g0 ], ]# r6 b
#else" A7 P8 x0 D, a- l9 W
#define _Cdecl cdecl
+ ?# b; r  [. O# K, P% x, Z#endif" {6 x8 `* I( R+ U$ e' K
& V/ m9 B6 l* Q; e9 C4 c& m
#if !defined(__STDARG)
3 N$ k  [8 P" J0 |5 p. z" ^#define __STDARG1 `: u6 n& V# O& ]! v" J9 {

* H! A+ H; Y" N) r0 ?4 u  qtypedef void *va_list;
0 O+ c  A  m5 _5 C2 |$ X( y( J  r( ^
4 d/ r2 P* {! p#define va_start(ap, parmN) (ap = ...)
+ l0 h3 X) Y4 j#define va_arg(ap, type) (*((type *)(ap))++)( Z+ G+ l- p; r8 J7 O
#define va_end(ap)0 `' t  p/ }2 z, j: _
#define _va_ptr   (...)
1 k4 _1 o8 H3 D#endif$ U( k, Y$ B% i8 T6 p# L7 X

) [- {$ Y# P$ y( X6 q6 B9 q以上为"STDARG.H"的内容.
( ?3 C1 H# n. w; X该文件定义了使用可变参数所用到的数据类型:typedef void  *va_list;
2 v' j* K) ^% fva_start(ap,parmN)起到初始化,使用得ap指向可变参数的第一个参数.ap的类型为va_list,' g4 ?6 b9 z% z+ Q4 I
parmN为可变参数的前面一个固定参数.
3 D) l7 b5 `! T4 _8 M+ rva_arg(ap,type)获得当前ap所指向的参数,并使ap指向可变参数的下一个参数,type为需要获得的参数的类型.0 U! r& S; g# F' {
va_end(ap) 结束可变参数获取.
. H: n( Z+ W: |$ X1 n0 @$ ]& t8 W7 f  n( T, v
3)可变参数的使用实例8 D3 J5 @1 K2 O7 g$ {, o

' _# n! R- n5 b! ~实例目的:用可变参数来实现个数不定的字符串的传递,并显示传递过来的字符串.
! m2 Y: j# `# y5 R* T
! u7 y/ A- {6 U  B; C#include<stdio.h>
( q' O/ v6 g- G7 l* a#include<conio.h>
$ x1 x5 A5 ~9 q7 U$ i1 S+ `* X( J7 ]#include<stdarg.h>" c$ h6 F; m! E
void tVarArg(int num,...);/*num为可变参数的个数*/
7 Y/ m1 Q2 e9 qint main(void)$ v6 ^& w8 t7 ?# l5 n4 `, n$ ~# h3 X
{2 `5 Y  `# ?: |1 p8 k+ D: L8 M
clrscr();
. `' ]- a: x! G* jtVarArg(5,"Hello! ","My ","name ","is ","neverTheSame.\n");
& a8 c1 K  C' JtVarArg(8,"This ","is ","an ","example ","about ","variable-argument ","in ","funtion");5 ^$ K, s0 M: {. T
getch();9 c  [' n+ e, k; y6 x: G7 w
return 0;) k, b& m. x( a/ P0 B
}
9 h$ y6 f4 K; k0 O, n1 ^3 I( U4 F% @+ qvoid tVarArg(int num,...)6 n7 F! S, l3 K  P* q# ?
{
9 V! i0 X) P: x' l7 M% e! j- yva_list argp;  /*定义一个指向可变参数的变量*/  y0 G: E% [6 j: c9 E- c
va_start(argp,num); /*初始化,使用argp指向可变参数的第一个参数*/& Q6 K1 s! w8 h  u, u6 l
while(--num>=0)
; c6 m) o5 D. l  printf("%s",(va_arg(argp,char*)));/*va_arg(argp,char*)获得argp所指向的参数,
2 e6 z0 r) e, y" V- c8 U) a' G! a    并使用argp指向下一个参数,char*使用所获得的参数的类型转换为char*型.*/
5 I3 e. S/ E' \, s& d9 v2 Uva_end(argp);  /*结束可变参数获取*/
, F# H' q9 m$ C3 ^" nreturn ;
. W- M# A- _( b4 m- @$ Z) l$ Z  m}" @/ o& V8 @0 E- g- `7 V6 k8 l
  U' G3 I* y7 \% `# j7 k
4)可变参数的使用需要注意的问题
7 d: r  h4 ^" E
9 u* }7 \+ C7 h. v) U" ~1.每个函数的可变参数至多有一个.0 [! u- p; |1 m: O6 c% `
2.va_start(ap,parmN)中parmN为可变参数前的一个固定参数.
9 [* x% F3 ~& {: U& w' i' Z8 ]0 J3.可变参数的个数不确定,完全由程序约定.  n8 }, d: E4 s; V
4.可变参数的类型不确定,完全由va_arg(ap,type)中的type指定,然后就把参数的类型强制转换.3 d6 W9 k: z9 _5 h' B1 r
而printf()中不是实现了识别参数吗?那是因为函数
. r8 }# G1 D. P+ _0 c5 pprintf()是从固定参数format字符串来分析出参数的类型,再调用va_arg
1 M6 @' W3 `" N: ?# }  H的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
9 D0 p! P/ n4 ]过在自己的程序里作判断来实现的. 4 d7 ]6 N8 t( H1 g; n8 q8 E
5.编译器对可变参数的函数的原型检查不够严格,对编程人员要求很高.

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