Declaring Multiple Variables of the Same Type within a Function's Parameters

Question

We've started looking at functions, and our homework requires us to include some simple ones in our programming. As we've left it a little late in the semester to explore functions, we're well-used to declaring/assigning multiple variables of the same type on a single line, as below:

int a, b, c = 0;

This, however, does not appear to work when integers a, b, and c are the parameters to be passed to a function:

int function(int a, int b, int c);

I was wondering if anybody could advise on the reasoning behind this. Is there something I'm misunderstanding, or is this a known convention?

Many thanks, I'm looking forward to any answers.

Answer 1

This is historically grown, and has its roots in the first edition of the K&R in 1978. It has to do with a meaninful order of arguments.

In early C, variables had to be declared at the beginning of a block, following the opening { and before any other statement in that block (p.81). Having several variables separated by a comma was then presented as convenient way for saving some space when no comment was needed (p.37). (This worry for space nowadays look like a joke, but on a 25 lines x 80 columns standard screen without mouse, it was very useful to be able to verify the variable declarations at the beginning of a function without scrolling too much. Nowadays, variables can be defined just before their usage, so it does not matter so much anymore.)

Function arguments at that time were declared in the argument-list without type, and the types did only follow the declaration of the function (p.67):

int foo(a,b)
int a;
char *s; 
{
     ...
}

It was possible at that time to regroup several arguments of a same type:

int bar(a,b,c)
int a,b,c;  
{...}

The only order that mattered was the order of the arguments in the argument list.

Forward declaration of functions and declaration of external functions did not provide the argument list but just (). This was very error prone.

So soon after (but not in the original k&R), function prototypes were introduced, to tell the types of the arguments. This looked like:

int foo(int, int, int); 

What mattered the most here was the order of the types and not the name of the argument. Note that nowadays, the name of the argument is still optional in prototypes (but not in the function declaration).

The standard committee did a great job in harmonizing the syntax, to come with the usage we nowadays know. And to be consistent between the declaration of the function and the definition of the function requires to have each argument separately introduced with its type.

So in the end, this evolution was driven by the order of the types for parameter passing.

Answer 2

The specific language would be helpful. Though i'm going to presume C.

The first example is a shorthand for int a; int b; int c = 0;.

Its a deliberate choice meant to make C look like some of the earlier languages to make it more familiar to those developers. Much like Java and C# look a lot like C++.

That also explains why it won't work in the function definition:

int function(int a, b, c = 0);          //This would expand to
int function(int a; int b; int c = 0);  //and how do you even parse that?
int function(int a, int b, int c);      //Its nowhere close to meaning this.
                                        // given that ; means end of statement.

Answer 3

Since you reference homework it is not clear the purpose of your assignment but I will take a guess. It looks like you are trying to differentiate how commas are used in two different contexts. First it is in how variables are declared and initialized. In the second case it has to do with how function parameters are declared. The C standard defines both of these cases in language definition. If you want to understand this better I suggest getting your hands on a copy of "The C Programming Language" by Brian Kernighan and Dennis Ritchie. There are several sections in there on this topic that you may find informative.