When was this C function definition style, with type declarations of parameters after the parameter list, invented?

Question

Recently I dug a little bit into old graphics libraries and found libxmi. The site was last updated on 08/09/2000. And in the source code I found the following style of function definitions which I have never seen before:

#include <stdio.h>
int add(a, b)
    int a, b;
{
    return a + b;
}
int main()
{
    printf("%d\n", add(5, 6));
}

Believe it or not but you can compile this with a recent gcc and MSVC (in C mode). When was this type of definitions invented? Is it even standardized ISO C? What is this?

Answer 1

It's the original C syntax as designed by Dennis Ritchie, so bite your tongue :-)

As mentioned in another answer, the style was not unusual at the time. For an example of early art: FORTRAN II (1958) did not have variable declarations at all. A variable existed by being mentioned. The type of an identifier was determined by its initial letter (I to N INTEGER, otherwise REAL). There was a DIMENSION statement for specification of array identifiers.

Subroutine declarations would therefore have no type information in the SUBROUTINE statement, though may be followed by a DIMENSION.

      SUBROUTINE FOO(VALUES, KOUNT)
      DIMENSION VALUES(KOUNT)

VALUES is a REAL array of KOUNT elements. (We all learned the art of bad spelling)

FORTRAN IV (~1962) added type declarations, but they were optional in general. The implicit declaration and "initial letter" rules still applied. The dummy arguments of subroutines could have type specifiers in subsequent statements, but were not required to.

      SUBROUTINE BAR(VALUES, KOUNT)
      DOUBLE PRECISION VALUES
      DIMENSION VALUES(KOUNT)

---

In Algol 60, the argument types are specified after the procedure heading, and before the body of the procedure - here just a single statement. Assignment to the procedure name was how a return value was indicated.

integer procedure square(n);  
    value n; integer n;  
    square := n × n;  

By Algol 68, you might find the formal-parameter style a little more familiar. The returned value is the value of the last expression to be executed. The type of 'square' is read as something like 'proc of int returning int'.

proc square = (int n) int :  
    (n × n);

---

In short, there was nothing unusual at the time about that aspect of C. The style that C initially adopted for function definitions was quite common at the time, so it's not so strange a choice for Ritchie to have made. The style you are more familiar with did not fully emerge in C until ANSI C, in 1989 - 17 years after C was created.

Note too that there was not necessarily a way to state all of the attributes of a formal parameter in a single statement: Algol needed integer for type, and (optionally) value for mechanism.

Incidentally, the reason for the ANSI C change was not so much in the definition of a function -- both forms of function definitions convey the argument types -- but in the declaration of functions, for example in header files. The latter carried no argument information at all - for example all you could say about an external function in K&R style was what it returned: double sin().

This is error-prone; you don't find out (with the compiler technology of the day) until execution time that you've got a mismatch.

While ANSI C added the new syntax, they did not outlaw the old K&R syntax, which remains valid, in the successive ISO standards as well as the original ANSI.

Link: paper from Ritchie on the history of C

Answer 2

As others have explained, it's the original K&R C style. But why is it this way?

C is the successor to B (Wikipedia). It was typeless, so there was no need to specify which type a function argument had:

/* The following function will print a non-negative number, n, to
   the base b, where 2<=b<=10.  This routine uses the fact that
   in the ASCII character set, the digits 0 to 9 have sequential
   code values.  */
printn(n, b) {
        extrn putchar;
        auto a;
        /* Wikipedia note: the auto keyword declares a variable with
           automatic storage (lifetime is function scope), not
           "automatic typing" as in C++11. */
    if (a = n / b)        /* assignment, not test for equality */
            printn(a, b); /* recursive */
    putchar(n % b + '0');

}

(The original source of this example is from the User's Reference to B by Ken Thompson.)

So when Dennis and Ken evolved the language and added types, they needed a way to specify which type an argument had. I don't know the exact reasons for adding this info between ) and { but it does make sense.

A point I remember but don't have a reference to right now: The types default to int if left out, and this was important and intentional. Due to this quirk, some B code can be compiled with C with no or minor changes. This eased porting existing code.

Answer 3

It’s an old style where type declarations were separate from the naming (and positioning) of the arguments. The style dates from at least the 1960s in languages like FORTRAN, Algol 60, and PL/I.

Answer 4

As others have mentioned, this was the style of function declarations before ANSI C. It’s often called K&R C, after Brian Kernighan and Dennis Ritchie. Back in the early ’90s, some books about the then-recent changes to the language complained that the new style of declaring functions was more like C++ than C.

Why was that chosen originally? The calling convention on the computers for which C was originally developed was to pass arguments on the stack. That syntax made it simple to call a function like printf() with any number of arguments of arbitrary type, and have the called function figure out how to interpret them based on the format string. (It was less simple to write the variadic function in K&R C, but that would have been done in assembler back then.) Dennis Ritchie wanted C to be more strongly-typed than B, but not too strictly to write a generic I/O library.

ANSI C provides more complex ways to switch back to the older syntax, to be able to link to existing libraries, or partly back to it for variadic functions. This lets printf() and scanf() be supported, but enables type-checking of function arguments wherever possible. It would later get a simple form of generic function for use in the math library, and later still have that mechanism become available as a building block. Originally, though, there was only one kind of function, and it supported arbitrary arguments.