CSC295 2014S, Class 13: Variadic Functions
==========================================

_Overview_

* Preliminaries.
    * Admin.
    * Questions.
* Writing C functions that take variable numbers of parameters.
* C's "varargs" facility.
* Some examples.
* Design issues.
* Variadic macros.
* Behind the scenes.

Preliminaries
-------------

### Admin

* Welcome to any trustees who are visiting today!
* Because next Thursday is the CS senior lunch, today is our last formal class.
    * I haven't received evaluation forms yet, so I'm not sure what we'll
      do about that.
* Snowden TED Talk CS Extra at 4:30 today.
* Snowden CS Table at noon tomorrow.
* Baseball Sunday at 1:00.

### Questions

Writing C functions that take variable numbers of parameters
------------------------------------------------------------

In Scheme, we have wonderful functions like +

* (+ 1)
* (+ 1 2 3)
* (+ 1 1 4 1 1 4 234 23 1 12 34 23  890)
* (define fun (lambda args ...) ...)

Is this technique used (useful) in C?

* printf (and fprintf and sprintf) all take variable numbers of parameters
* Do you need variable-parameter printf?
    * printf("val: %d\n", md); vs printf("val"); printf(md), printf("\n");
       * That's long
    * We could concatenate strings in C, just like we do in Java
       * printf(concat("val",concat(i2s(md), "\n")));
       * Where does that string get stored?  When does it get freed?

Language design question: What is the role of variadic functions?

* Don't allow them.  Hard to type check, and generally lead to problems.
* Alllow them only for built-in functions.
* Allow them for both built-in and user-defined functions.
* Make them the primary model for procedures.

What are some use cases for this technique?

* Process a bunch of items
    * Turn them into an array.
    * Or more generally, do something with each one
* Procedures that have default parameters and some options.
* Some functions like sum
    * x = sum(4, 1.0, 2.0, 3.0, 4.0);
    * x = sum(1, 1.0);
    * We provide that extra "number of parameters" argument.

In C
----

Declare a function that takes variable numbers of parameters with
ellipses for the extra parameters.

        int printf(char *pattern, ...);
        int sum(int count, ...);
        int parseJSON(char *string, object *target, ...);

In the function definition,

        va_list args;
        va_start (args, pattern);       // For printf
        val = va_next(args, type);
        ...
        va_end(arg

Some examples
-------------

See the code.

Design issues
-------------

How do you know what your parameters are (number, type), if all you have
are ellipses?

* We need to trust our user.
* One strategy: First parameter gives the number of parameters,
  assume they are all the same type.  [Sum strategy]
* Another strategy: Pass in pointers, last pointer is NULL. 
  [simonsays strategy]
   * Or use some other set of values and sentinel.
* And another: Pass in a sequence of pairs, the first is the type 
  and the second is the value.  There's one type for "DONE"
* Assume the types of the extra parameters.
* format string that tells you what the types are. [printf strategy]

Behind the scenes
-----------------

Variadic macros
---------------