C function syntax, parameter types declared after parameter list

Question

I\'m relatively new to C. I\'ve come across a form of function syntax I\'ve never seen before, where the parameter types are defined after that parameter list. Can someone e

Answer 1

There is no difference, it is just that that is the old syntax for function declarations in C -- it was used pre ANSI. Never write such code unless you plan to give it to your friends from the 80's. Also, never depend upon implicit type assumptions (as another answer seems to suggest)

Answer 2

Its just the same but old fashion. You probably found it is some old, legacy code.

Answer 3

This is the so caller K&R style or old-style declaration.

Note, that this declaration is significantly different from the modern declaration. K&R declaration does not introduce a prototype for the function, meaning that it doesn't expose the types of the parameters to the outside code.

Answer 4

That's the old-style syntax for parameter lists, which is still supported. In K&R C you could also leave off the type declarations and they would default to int. i.e.

main(argc, argv)
char *argv[];
{
    return 0;
}

would be the same function.

Answer 5

Old or not, I would argue what is old and what nat.. like the pyramids are ancient, but none of todays so called scientist have a clue how they where made. Looking back, old programs still work today without memory leaks, but these "new" programs tend to fail more then often. I see a trend here.

Probably they saw functions as structs which have a executable body. Knowledge of ASM is needed here to solve the mystery.

Edit, found a macro which indicates you do not need to supply argument names at all.

#ifndef OF /* function prototypes */
#  ifdef STDC
#    define OF(args)  args
#  else
#    define OF(args)  ()
#  endif
#endif

#ifndef Z_ARG /* function prototypes for stdarg */
#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
#    define Z_ARG(args)  args
#  else
#    define Z_ARG(args)  ()
#  endif
#endif

Here is an usage example, library is zlib-1.2.11.

ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));

So my second guess would be for function overloading, otherwise these arguments had no use. One concrete function, and now infinite amount of functions with same name.

Answer 6

What's also interesting is the calling convention difference of functions with, and functions without a prototype. Consider an old style definition:

void f(a)
 float a; {
 /* ... */
}

In this case, the calling convention is that all arguments are promoted before being passed to the function (for example, a float argument is first promoted to double, before being passed). So if f receives a double but the parameter has type float (which is perfectly valid) the compiler has to emit code that converts the double to a float prior to executing the function's body.

If you include a prototype, the compiler does not do such automatic promotions anymore and any data passed is converted to the types of the parameters of the prototype as if by assignment. So the following is not legal and results in undefined behavior:

void f(float a);
void f(a)
  float a; {

}

In this case, the function's definition would convert the submitted parameter from double (the promoted form) to float because the definition is old-style. But the parameter was submitted as a float, because the function has a prototype. For example, clang gives

main.c:3:9: warning: promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype [-Wknr-promoted-parameter]

Your options of solving the contradictions are the two following:

// option 1
void f(double a);
void f(a)
  float a; {

}

// option 2
// this declaration can be put in a header, but is redundant in this case, 
// since the definition exposes a prototype already if both appear in a 
// translation unit prior to the call. 
void f(float a); 

void f(float a) {

}

Option 2 should be preferred if you have the choice because it gets rid of the old style definition up front. If such contradicting function types for a function appears in the same translation unit, the compiler will usually tell you (but is not required). If such contradictions appear over multiple translation units, the error will possibly go unnoticed and can result in hard to predict bugs. It is best to avoid these old style definitions.