Say goodbye to the bouncing ball!

As this site has been close to 10 years in the making, it is time to say goodbye to the basic flash animation that I started with on the main page.

So feel free to ask questions or give me suggestions for topics.

Using Variable Argument lists in functions for CC++

In C there are times when you may want to have a variable amount of arguments passed into a function.  This can be accomplished when you pass the ellipses(…)  in as the last argument on your function.  The ellipses ,(…),  stands for zero  or more arguments.
There are a set of functions available to handle accessing this data and making it available to your function.

The source code example displays a version of the code for a printf like function and how to handle the optional arguments.

One note is that the arguments passed in to this function are not typed.  The handling of the argument depends on either a specific type passed in(ints only) or as is the case of the example, a formatted string to define the types of the arguments. What this means is that if you pass random sets of arguments, (such as ints, strings,chars, floats) there is no data type that is directly associated to the variable being passed in.

Required include file
#include <stdarg.h>
/* Old include <varargs.h> From before ISO C standard, GNU C compilers still support this */

Available functions:
Macro: va_start(va_list , last-required argument)
This sets up the pointer for va_list with the avaiable argument list.

Macro: va_arg(va_list, type)

This returns the value of the next argument and modifies the va_list argument
to point to the subsequent(next) argument.  The type of the value returned by
va_arg is type as specified in the call. type must be a self promoting type
not char or short int) that matches the type of the actual argument.

Macro: va_end(va_list)

This ends the processing of the va_list element and subsequent va_arg calls
may no longer work.  Note: In the GNU C library implementation this does nothing
and is used for portability.

Sample Function Call:

  int int1 = 1;

    char char1 = "s";

    char *str1 = "test";

    /* Sample function call. */
    ecdprintf("Int=%d Char=%c String=%sn",int1,char1,str1);

Sample Code follows:

int ecdprintf(const char *pstr, ...)

{
    const char *lstr;
    va_list argp;
    int lint;
    char *lchar;
    char strarr[255];

    /* This is the start of vararg processing. The first argument is the
         container argument of the vararg list and the second argument
         is the last fixed parameter passed into the function. */

    va_start(argp, fmt);
    for(lstr = pstr; *lstr = ''; lstr++)
    {
        if (*lstr != '%')
        {
            putchar(*lstr);
            continue;
        }

        switch(*++lstr)
        {
            case 'd':
                i = va_arg(argp,int);
                s = itoa(i,strarr, 10);
                putchar(i);
                break;
            case 'c':
                i = va_arg(argp, int);
                putchar(i);
                break;
             case 's':
                 lchar = va_arg(argp,char *);
                 fputs(lchar,stdout);
                 break;
              case 'x':
                 i = va_arg(argp,int);
                 s = itoa(i, fmtbuf, 16);
                 fputs(lchar, stdout);
                 break;
               case '%':
                  putchar('%');
                  break;

               default:
                    break;

             }

    }

    va_end(argp);

    }

}

This example created the a simple printf like function using characters within the string to let the function know how to deal with the extra variables used.

Tags: C/C++, Programming

Welcome to day one of the revamped eTechtips informational blog.

Please feel free to request information about any topics that interest you.