In C, should I define (not declare/prototype) a function that takes no arguments with void or with an empty list?

Question

There may or may not be a duplicate to this question, although I tried to find one but everyone's answer seemed to only be referring to the declaration/prototype. They specify that a definition void foo() { } is the same as void foo(void) { }, but which way should I actually use? In C89? In C99? I believe I should start using void foo(void); for my prototype declarations, but is there any difference at all if I use void or not for the definition?

Answer 1

They are different, void foo(void) declares foo as a function that takes NO argument, and returns nothing.

While for void foo(), the function foo takes UNSPECIFIED number of arguments, and returns void.

You should always use the first one for standard conforming C.

Answer 2

They are semantically different

Given the following functions:

void f(void);
void g();

It is a compile-time error to call f with arguments:

error: too many arguments to function "f"

However, that declaration of g means it takes an unspecified number of arguments. To the compiler, this means it can take any number of arguments, from zero to some implementation-defined upper bound. The compiler will accept:

g();
g(argument);
g(argument1, argument2, ... , argumentN);

Essentially, because g did not specify its arguments, the compiler doesn't really know how many arguments g accepts. So the compiler will accept anything and emit code according to the actual usage of g. If you pass one argument, it will emit code to push one argument, call g and then pop it off the stack.

It's the difference between explicitly saying "no, I don't take any arguments" and not saying anything when questioned. Remaining silent keeps the issue ambiguous, to the point where the statement which calls g is the only concrete information the compiler has regarding which parameters the function accepts. So, it will emit machine code according to that specification.

Recommendations

which way should I actually use?

According to the SEI CERT C Coding Standard, it is recommended to explicitly specify void when a function accepts no arguments.

The article cites, as the basis of its recommendation, the C11 standard, subclause 6.11.6:

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

Declaring a function with an unspecified parameter list is classified as medium severity. Concrete examples of problems that may arise are presented. Namely:

1. Ambiguous Interface
   • Compiler will not perform checks
   • May hide errors
2. Information Outflow
   • Potential security flaw

Information Security has a post exploring not just the security but also the programming and software development implications of both styles.

The issue is more about quality assurance. Old-style declarations are dangerous, not because of evil programmers, but because of human programmers, who cannot think of everything and must be helped by compiler warnings. That's all the point of function prototypes, introduced in ANSI C, which include type information for the function parameters.

Answer 3

Yes, there is a difference. It is better to define functions like void foo(void){} cause it will prevent passing any arguments to function in compilation time with error like:too many arguments to function 'foo'

EDIT: If you want to add such compiler's validation for existing code, this probably can be done changing prototypes in the headers. Without changing the function definitions. But it looks awkward IMHO. So for newly created programs (as pointed by skillful commentators above) it's better to make definition and declaration match verbose, and this is bad and ancient practice to declare and define with empty parentheses

Answer 4

I'll try to answer simply and practically.
From the practice and reference I'm familiar with, c89 and c99 should treat declaration/definition/call of functions which take no arguments and return no value equally. In case one omits the prototype declaration (usually in the header file), the definition has to specify the number and type of arguments taken (i.e. it must take the form of prototype, explicitly void foo(void) for taking no arguments) and should precede the actual function call in the source file (if used in the same program). I've always been advised to write prototypes and decently segmented code as part of good programming practice.

Declaration:

void foo (void); /*not void foo(), in order to conform the prototype definition !*/

Definition:

void foo (void) /*must match its prototype from the declaration !*/
{
  /*code for what this function actually does*/
  return;
}

Function call from within main() or another function:

...
  foo();
...