func() vs func(void) in C99

by

TL;DR

In declarations,

void func1();     // obsolescent
void func2(void);

the behaviour is quite different. The first one declares a function without any prototype – and it may take any number of arguments! Whereas the latter declares a function with a prototype, that has no parameters and accepts no arguments.

In definitions

void func1() { }     // obsolescent

and 

void func2(void) { }

  • The former declares and defines a function func1 that has no parameters and no prototype

  • The latter declares and defines a function func2 with a prototype that has no parameters.

These two behave distinctly in that whereas the C compiler must print a diagnostic message when calling a prototyped function with wrong number of arguments, it needn’t do so when calling a function without prototype.

I.e, given the definitions above

func1(1, 2, 3); // need not produce a diagnostic message
func2(1, 2, 3); // must always produce a diagnostic message 
                // as it is a constraint violation

However both calls are illegal in strictly-conforming programs as they’re explicitly undefined behaviour as per 6.5.2.2p6.

Furthermore, the empty parentheses are considered an obsolescent feature:

The use of function declarators with empty parentheses (not prototype-format parameter type declarators) is an obsolescent feature.

and

The use of function definitions with separate parameter identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an obsolescent feature.

In detail

There are 2 related, yet distinct concepts: parameters and arguments.

  • arguments are the values passed into the function.

  • parameters are the names/variables within the function that are set to the values of the arguments when the function entered

In the following excerpt:

int foo(int n, char c) {
    ...
}

...

    foo(42, ch);

n and c are parameters. 42 and ch are arguments.

The quoted excerpt only concerns the parameters of a function, but doesn’t mention anything about the prototype or arguments to the function.

The declaration void func1() means that the function func1 can be called with any number of arguments, i.e. no information about the number of arguments is specified (as a separate declaration, C99 specifies this as “function with no parameter specification), whereas the declaration void func2(void) means that the function func2 does not accept any arguments at all.

The quote in your question means that within a function definition, void func1() and void func2(void) both signal them that there are no parameters, i.e. variable names that are set to the values of the arguments when the function is entered. The void func() {} contrasts with void func(); the former declares that func indeed takes no parameters, whereas the latter is a declaration for a function func for which neither parameters nor their types are specified (a declaration without prototype).

However, they yet differ definition-wise in that

  • The definition void func1() {} doesn’t declare a prototype, whereas void func2(void) {} does, because () is not a parameter type list, whereas (void) is a parameter type list (6.7.5.3.10):

    The special case of an unnamed parameter of type void as the only item in the list specifies that the function has no parameters.

    and further 6.9.1.7

    If the declarator includes a parameter type list, the
    list also specifies the types of all the parameters; such a declarator also serves as a function prototype for later calls to the same function in the same translation unit. If the declarator includes an identifier list, the types of the parameters shall be declared in a following declaration list. In either case, the type of each parameter is adjusted as described in 6.7.5.3 for a parameter type list; the resulting type shall be an object type.

    The declarator of function definition for func1 does not contain a parameter type list, and thus the function then doesn’t have a prototype.

  • void func1() { ... } can still be called with any number of arguments, whereas it is a compile-time error to call void func2(void) { ... } with any arguments (6.5.2.2):

    If the expression that denotes the called function has a type that includes a prototype, the number of arguments shall agree with the number of parameters. Each argument shall have a type such that its value may be assigned to an object with the unqualified version of the type of its corresponding parameter.

    (emphasis mine)

    This is a constraint, which according of the standard says that a conforming implementation must display at least one diagnostic message about this problem. But since func1 doesn’t have a prototype, a conforming implementation is not required to produce any diagnostics.

However, if the number of arguments does not equal the number of parameters, the behaviour is undefined 6.5.2.2p6:

If the expression that denotes the called function has a type that does not include a prototype, […] If the number of arguments does not equal the number of parameters, the behavior is undefined.

So in theory a conforming C99 compiler is also allowed to error or diagnose a warning in this case. StoryTeller provided evidence that clang might diagnose this; however, my GCC doesn’t seem to do it (and this might also be required for it to be compatible with some old obscure code too):

void test() { }

void test2(void) { }

int main(void) {
    test(1, 2);
    test2(1, 2);
}

When the above program is compiled with gcc -std=c99 test.c -Wall -Werror, the output is:

test.c: In function ‘main’:
test.c:7:5: error: too many arguments to function ‘test2’
     test2(1, 2);
     ^~~~~
test.c:3:6: note: declared here
 void test2(void) { }
      ^~~~~

That is, the arguments are not checked at all against the parameters of a function whose declaration in definition is not prototyped (test) whereas GCC considers it as a compile-time error to specify any arguments to a prototyped function (test2); any conforming implementation must diagnose this as it is a constraint violation.

More Related Contents:

  1. Printf width specifier to maintain precision of floating-point value
  2. Are there machines, where sizeof(char) != 1, or at least CHAR_BIT > 8?
  3. Is type-punning through a union unspecified in C99, and has it become specified in C11?
  4. Is “inline” without “static” or “extern” ever useful in C99?
  5. Is it possible to iterate over arguments in variadic macros?
  6. Enabling VLAs (variable length arrays) in MS Visual C++?
  7. What does dot (.) mean in a struct initializer?
  8. What is the use of the `inline` keyword in C?
  9. C99 boolean data type?
  10. What is the correct type for array indexes in C?
  11. GCC with -std=c99 complains about not knowing struct timespec
  12. Realistic usage of the C99 ‘restrict’ keyword?
  13. Flexible array member in C-structure
  14. Does C99 guarantee that arrays are contiguous?
  15. Can I omit return from main in C? [duplicate]
  16. C variable declarations after function heading in definition [duplicate]
  17. state machines tutorials [closed]
  18. What is the default C -std standard version for the current GCC (especially on Ubuntu)?
  19. Does the C standard consider that there are one or two ‘struct uperms_entry’ types in this header?
  20. Anonymous union within struct not in c99?
  21. How to wrap printf() into a function or macro?
  22. Why is the fgets function deprecated?
  23. How to properly add hex escapes into a string-literal?
  24. Is there any reason not to use fixed width integer types (e.g. uint8_t)?
  25. How to tell GCC that a pointer argument is always double-word-aligned?
  26. Is there a document describing how Clang handles excess floating-point precision?
  27. Dynamic array allocation on stack in C
  28. Unsigned to signed conversion in C
  29. Declaring an array of negative length
  30. Why are compound literals in C modifiable

Leave a Comment