函数参数的类型

int arg(unsigned char a);int main(){ float b = 11.0; arg(b); return 0;}int arg(unsigned char a){ float c = 5.0; float d = 6.6; printf("arg = %d/n", a); printf("/n"); printf("c = %f(float)/n", c); printf("c = %d(int)/n", c); printf("(int)c = %d(int)/n", (int)c); printf("(unsigned char)c = %d(int)/n", (unsigned char)c); printf("/n"); printf("d = %f(float)/n", d); printf("d = %d(int)/n", d); printf("(int)d = %d(int)/n", (int)d); printf("(unsigned char)d = %d(int)/n", (unsigned char)d); return 0;}

输出结果：

arg = 11c = 5.000000(float)c = 0(int)(int)c = 5(int)(unsigned char)c = 5(int)d = 6.600000(float)d = 1610612736(int)(int)d = 6(int)(unsigned char)d = 6(int)

这段代码主要是想说明：函数的参数在传入时，是做类型的转换的，也就是参数在入栈时就已经被截取了（例如long 传入 char 时）；其中还包括了强制类型转换的存储结果，和用不符合变量类型的格式输出时，结果的不同。

 

由这段代码想到了printf的实现，想到了printf需要先解析那个const char *str中的格式字符来确定va_list的指针类型，移动大小。下面是一位大侠对printf的解释，很好！！

int    DEFUN(printf,   (format),   CONST   char   *format  DOTS)
{
    va_list   arg;
    int   done;

    va_start(arg,   format);
    done   =   vprintf(format,   arg);
    va_end(arg);

    return   done;
}

可以看到printf其实在内部调用的是vprintf，通过查看vprintf.c中的内容，我们可以看到vprintf其实是通过vfprintf实现的，它的函数原型是这样的：

int     DEFUN(vfprintf,   (s,   format,   args),
            register   FILE   *s  AND   CONST   char   *format   AND   va_list  args)

这个函数的整体执行结构是这样的：

register   CONST   char   *f;                                //可以看到f是一个const  char的指针
   
    f   =   format;                         
    while   (*f   !=   '/0 ')
{                                                          

  ...
  if   (*f   !=   '% ')
  {
    ...
  }

  if   (*f   ==   '% ')
  {
      fc   =   *f++;
      ...
    switch   (fc)
      {
              case   'd ':
                       ...
              case   'c ':
                       ...
                ....
        }
  }
        }
从上面的结构我们可以看出，函数首先读取字符串中的字符，然后一个个比较，如果是%，则马上用switch...case结构判断后续字符

在每一个case语句块里面，都有这样的语句：

  nextarg(...);
  outchar(...);

  nextarg()是一个宏，有如下宏定义

#define   castarg(var,   argtype,   casttype)   /
    var   =   (casttype)   va_arg(args,  argtype)

#define   nextarg(var,   type)   castarg(var,   type,  type)

一出现va_arg，我们就很熟悉了，这个宏的作用就是读取可变参数，在这里的作用就是将args中的内容读入。也就是利用栈顶指针读取
栈中的内容。

outchar(...)也是一个宏，它的定义如下

#define   outchar(x)                                                                        /
    do                                                                                                                          /
        {                                                                                                                           /
            register   CONST   int  outc   =   (x);                      /
            if   (putc(outc,   s)  ==   EOF)                                         /
  RETURN(-1);                                                                                     /
            else                                                                                                          /
  ++done;                                                                                                       /
        }   while   (0)