CODEWITHSUNDEEP
c
Alex Ionita
Alex Ionita

Reputation: 13

Can you have in C variable length arguments functions with cases when you don't want to pass any variable?

I want to create a function in C with variable length arguments in which I may not want to pass any variable at some point. I such a thing possible in C? I would like some code snippets if possible. Also, I have to mention that the function will have passed only char* variables when there are passed some variables.

Upvotes: 0

Views: 584

Answers (5)

chux
chux

Reputation: 153592

Can you have in C variable length arguments functions with cases when you don't want to pass any variable?

Yes. In modern C, Code cannot define a ... function with no arguments, yet you can call such a function with no arguments by declaring the a function without function signature. In that way the function can be called with zero arguments.

The function still needs some way to understand the count of arguments. This is often done with the first argument as a count (or format) or a final argument as a sentinel.

Given "will have passed only char*"...

int foo_count(int counter, ...);    
// zero usage example
foo_count(0);    

int foo_sentinel(char *s);    
// zero usage example
foo_sentinel((char*) NULL);

To do so with passing no arguments, the count needs to be conveyed in some other fashion, perhaps with a global variable - although this is not recommended. (Better to simply pass the count.)

Declare function:

int foo_count;
int foo(); // no prototype

Call function

foo_count = 0; foo()
foo_count = 1; foo("one")
foo_count = 2; foo("one", "two")

Define the function

int foo(char *s1, ...) {
  if (foo_count > 0) {
    va_list ap;
    va_start(ap, s1);
    puts(s1);
    for (int i=1; i < foo_count; i++) {
      puts(va_arg(ap, char *));
    }
    va_end(ap);
  }
}

Upvotes: 0

0___________
0___________

Reputation: 67574

no you cant

you need at least one known argument

void foo(int dummy, ...)
{
va_list ap;

Upvotes: 1

dbush
dbush

Reputation: 224102

A function with variable arguments must have at least one names argument in order to read the others.

For your particular case, since you want to pass a list of char * arguments you can use NULL to denote the end of the argument list. So in the case where there is nothing to pass, you just pass a singe NULL argument.

Upvotes: 1

rici
rici

Reputation: 241791

C does not provide any mechanism to allow a called function to determine how many arguments were provided. The mechanism must be part of the calling interface.

For example, printf relies on the % format specifications, while execv requires the caller to place a null pointer as the last argument.

A varargs function can be called with no variable arguments, but the caller must not attempt to access any variable argument in that case. For example, the mode argument to the Posix open() function is only consulted in the case that a new file is created, so it need not be supplied if the flags argument doesn't contain the O_CREAT flag (or some other extension flag, such as O_TMPFILE in Linux, which requests file creation).

The variable-length part of the prototype must follow at least one fixed argument. So it is not possible fir a varargs function to be called with no arguments at all.

Upvotes: 0

Eric Postpischil
Eric Postpischil

Reputation: 222933

This is not supported by standard C.

For a function parameter type list terminated with an ellipsis, there must be at least one named parameter.

For a function defined with an identifier list, the number of arguments in the call must match the number of parameters in the definition; varying numbers of arguments are not supported.

If you will call a function with a varying number of char * arguments, and that number may be zero, you could declare the function with a dummy first argument that is always passed but never used, as with:

void foo(int dummy,...);

Note that passing no arguments is a troublesome design. Normally, routines that accept varying numbers of arguments infer the number of arguments from one or more arguments. For example, the first argument might contain the number of remaining arguments, or it might be a format string (as with printf) from which the number and types of remaining arguments can be deduced. If you want a function to accept zero arguments in some situations, it has to have a way of knowing whether it was called with zero arguments or more. That would require information in some global state, which is typically a bad design.

Upvotes: 1

Related Questions