In order to create a variadic function, you have to understand how to reference the variable number of arguments used inside the function, you do not know how many there are and you cannot possibly give them names, you can solve this problem indirectly, through pointers.

The `stdarg.h' header provides you with routines that are implemented as macros, that will allow you to implement your own function with a variable number of arguments. The macros that you need to understand are:

• va_list: This is used in situations in which we need to access optional parameters and it's an argument list, it represents a data object used to hold the parameters corresponding to the ellipsis part of the parameter list.

• va_start: This macro is going to connect our argument list with some argument pointer, the list specified in `va_list' is the first argument, and the second argument is the last mandatory argument.

• va_arg: This will fetch the current argument connected to the argument list, we would need to know the type of the argument that we are reading.

• va_end: This is used when we would like to stop using the variable argument list.

• va_copy: Is used in situations for which we need to save our current location.

  void function (int number, ...);

  int function (const char *string, int n, ...);

  char function (char c1, ..., char c2);

  double
  average (double v1, double v2, ...)
  {
    va_list arguments; // a pointer to the variable argument list
    // More code goes here

    va_start (parg, v2);
    // more code?
  }

  double
  a_function (int lim, ...)
  {
    va_list ap; // declare object to hold arguments
    va_start (ap, lin);

    double tic = va_arg (ap, double); // retrieve first argument
    int toc = va_arg (ap, int);
  }

  double
  a_function (int lim, ...)
  {
    va_list ap; // declare object to hold arguments
    va_start (ap, lin);

    double tic = va_arg (ap, double); // retrieve first argument
    int toc = va_arg (ap, int);

    // Do something with tic and toc?

    va_end (ap);
  }

Consider this example:

  #include <stdio.h>
  #include <stdarg.h>

  double average (double v1, double v2, ...);

  int
  main ()
  {
    double v1 = 10.5, v2 = 2.5;
    int num1 = 6, num2 = 5;
    long num3 = 12L, num4 = 20L;

    printf ("Average = %.2lf\n", average (v1, 3.5, v2, 4.5, 0.0));
    printf ("Average = %.2lf\n", average (1.0, 2.0f, 0.0));
    printf ("Average = %.2lf\n", average ((double) num2, v2, (double) num1,
                                          (double) num3, (double) num4));

    return 0;
  }

  double
  average (double v1, double v2, ...)
  {
    va_list args;
    double sum = v1 + v2;
    double value = 0.0;

    int count = 2;
    va_start (args, v2);

    while ((value = va_arg (args, double)) != 0.0)
      {
        sum += value;
        ++count;
      }

    va_end (args);
    return sum / count;
  }

And this would be the output of that program:

Let's go through that code:

`average' is a function that, basically, calculates the average between two or more arguments, the first thing we did was to create a `va_list' variable called `args' and then we create another variable of type double called sum, whose value is the addition between the two mandatory arguments `v1' and `v2', we will accumulate the sum of all the arguments in the `sum' variable. The other variable we create `value' contains the value of the variable argument we are currently in, this is obtained through `va_arg', the count variable will just count the number of arguments and now, we start our variadic argument list, remember that it takes as arguments the va_list and the last mandatory argument of the function.

We have a while loop whose condition calls another function fom `stdarg.h' which returns the argument value we are currently in, and we are storing this value in the `value' variable and we are comparing this value with `0.0', if `value' is equals to `0.0' stop the execution of the loop. Inside the loop, we just have statements for adding the value to sum and incrementing count by one, finally, we are calling `va_end' to free our va_list and we are returning the division between sum and count.

• There must be at least one fixed parameter.

• You have to call `va_start' to initialise the value of the variable argument list pointer in your function, this pointer must be declared as type of `va_list'.

• There needs to be a mechanism to determine the type of each argument, either there can be a default type assumed or there can be a parameter that allows the argument type to be termined. For example, you could have an extra fixed argument in the `average' function that would have the value 0 if the variable arguments were double and 1 if they were long.

• You must have a way to determine when the list of arguments is finished, for example, the last argument in the variable argument list could have a fixed value - this is called a sentinel value - or the first argument could specify the count of the number of arguments in total or in the variable part of the argument list.

• You must call `va_end' before you exit a function with a variable number of arguments, if you don't, the function will not work properly.