CODEWITHSUNDEEP
c
alex
alex

Reputation: 490657

Do C functions support an arbitrary number of arguments?

PHP has a func_get_args() for getting all function arguments, and JavaScript has the functions object.

I've written a very simple max() in C

int max(int a, int b) {
    
    if (a > b) {
        return a;   
    } else {
        return b;
    }
}

I'm pretty sure in most languages you can supply any number of arguments to their max() (or equivalent) built in. Can you do this in C?

I thought this question may have been what I wanted, but I don't think it is.

Please keep in mind I'm still learning too. :)

Many thanks.

Upvotes: 4

Views: 2186

Answers (7)

AndiDog
AndiDog

Reputation: 70239

You could write a variable-arguments function that takes the number of arguments, for example

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

int sum(int numArgs, ...)
{
    va_list args;
    va_start(args, numArgs);

    int ret = 0;

    for(unsigned int i = 0; i < numArgs; ++i)
    {
        ret += va_arg(args, int);
    }    

    va_end(args);

    return ret;
}    

int main()
{
    printf("%d\n", sum(4,  1,3,3,7)); /* prints 14 */
}

The function assumes that each variable argument is an integer (see va_arg call).

Upvotes: 11

paxdiablo
paxdiablo

Reputation: 882776

Yes, C has the concept of variadic functions, which is similar to the way printf() allows a variable number of arguments.

A maximum function would look something like this:

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

static int myMax (int quant, ...) {
    va_list vlst;
    int i;
    int num;
    int max = INT_MIN;

    va_start (vlst, quant);

    for (i = 0; i < quant; i++) {
        if (i == 0) {
            max = va_arg (vlst, int);
        } else {
            num = va_arg (vlst, int);
            if (num > max) {
                max = num;
            }
        }
    }
    va_end (vlst);
    return max;
}

int main (void) {
    printf ("Maximum is %d\n", myMax (5, 97, 5, 22, 5, 6));
    printf ("Maximum is %d\n", myMax (0));
    return 0;
}

This outputs:

Maximum is 97
Maximum is -2147483648

Note the use of the quant variable. There are generally two ways to indicate the end of your arguments, either a count up front (the 5) or a sentinel value at the back.

An example of the latter would be a list of pointers, passing NULL as the last. Since this max function needs to be able to handle the entire range of integers, a sentinel solution is not viable.

The printf function uses the former approach but slightly differently. It doesn't have a specific count, rather it uses the % fields in the format string to figure out the other arguments.

Upvotes: 5

torak
torak

Reputation: 5812

Yes, you can declare a variadic function in C. The most commonly used one is probably printf, which has a declaration that looks like the following

int printf(const char *format, ...);

The ... is how it declares that it accepts a variable number of arguments.

To access those argument it can uses va_start, va_arg and the like which are typically macros defined in stdarg.h. See here

It is probably also worth noting that you can often "confuse" such a function. For example the following call to printf will print whatever happens to be on the top of the stack when it is called. In reality this is probably the saved stack base pointer.

printf("%d");

Upvotes: 1

tenfour
tenfour

Reputation: 36906

Another alternative is to pass in an array, like main(). for example:

int myfunc(type* argarray, int argcount);

Upvotes: 1

pmg
pmg

Reputation: 108986

C can have functions receive an arbitrary number of parameters.

You already know one: printf()

printf("Hello World\n");
printf("%s\n", "Hello World");
printf("%d + %d is %d\n", 2, 2, 2+2);

There is no max function which accepts an arbitrary number of parameters, but it's a good exercise for you to write your own.

Use <stdarg.h> and the va_list, va_start, va_arg, and va_end identifiers defined in that header.

http://www.kernel.org/doc/man-pages/online/pages/man3/stdarg.3.html

Upvotes: 0

Jens Gustedt
Jens Gustedt

Reputation: 79003

In fact, this are two questions. First of all C99 only requires that a C implementation may handle at least:

  • 127 parameters in one function definition
  • 127 arguments in one function call

Now, to your real question, yes there are so-called variadic functions and macros in C99. The syntax for the declaration is with ... in the argument list. The implementation of variadic functions goes with macros from the stdarg.h header file.

Upvotes: 3

Tristan
Tristan

Reputation: 3885

here is a link to site that shows an example of using varargs in c Writing a ``varargs'' Function

You can use the va_args function to retrieve the optional arguments you pass to a function. And using this you can pass 0-n optional parameters. So you can support more then 2 arguments if you choose

Upvotes: 2

Related Questions