"TCPL/7.3_Variable-length_Argument_Lists"版本比较

Navigation(slides)

7.3 Variable-length Argument Lists

This section contains an implementation of a minimal version of printf, to show how to write a function that processes a variable-length argument list in a portable way. Since we are mainly interested in the argument processing, minprintf will process the format string and arguments but will call the real printf to do the format conversions.

The proper declaration for printf is

   int printf(char *fmt, ...)

where the declaration ... means that the number and types of these arguments may vary. The declaration ... can only appear at the end of an argument list. Our minprintf is declared as

   void minprintf(char *fmt, ...)

since we will not return the character count that printf does.

The tricky bit is how minprintf walks along the argument list when the list doesn't even have a name. The standard header <stdarg.h> contains a set of macro definitions that define how to step through an argument list. The implementation of this header will vary from machine to machine, but the interface it presents is uniform.

The type va_list is used to declare a variable that will refer to each argument in turn; in minprintf, this variable is called ap, for "argument pointer". The macro va_start initializes ap to point to the first unnamed argument. It must be called once before ap is used. There must be at least one named argument; the final named argument is used by va_start to get started.

Each call of va_arg returns one argument and steps ap to the next; va_arg uses a type name to determine what type to return and how big a step to take. Finally, va_end does whatever cleanup is necessary. It must be called before the program returns.

These properties form the basis of our simplified printf:

   1    #include <stdarg.h>
   2 
   3    /* minprintf: minimal printf with variable argument list */
   4    void minprintf(char *fmt, ...)
   5    {
   6        va_list ap; /* points to each unnamed arg in turn */
   7        char *p, *sval;
   8        int ival;
   9        double dval;
  10 
  11        va_start(ap, fmt); /* make ap point to 1st unnamed arg */
  12        for (p = fmt; *p; p++) {
  13            if (*p != '%') {
  14                putchar(*p);
  15                continue;
  16            }
  17            switch (*++p) {
  18            case 'd':
  19                ival = va_arg(ap, int);
  20                printf("%d", ival);
  21                break;
  22            case 'f':
  23                dval = va_arg(ap, double);
  24                printf("%f", dval);
  25                break;
  26            case 's':
  27                for (sval = va_arg(ap, char *); *sval; sval++)
  28                    putchar(*sval);
  29                break;
  30            default:
  31                putchar(*p);
  32                break;
  33            }
  34        }
  35        va_end(ap); /* clean up when done */
  36    }

Exercise 7-3. Revise minprintf to handle more of the other facilities of printf.

Navigation(siblings)