Why do function prototypes include parameter names when they're not required?

Question

I always thought that a function prototype must contain the parameters of the function and their names. However, I just tried this out:

int add(int,int);

int main()
{
    std::cout << add(3,1) << std::endl;
}

int add(int x, int y)
{
    return x + y;
}

And it worked! I even tried compiling with extreme over-caution:

g++ -W -Wall -Werror -pedantic test.cpp

And it still worked. So my question is, if you don't need parameter names in function prototypes, why is it so common to do so? Is there any purpose to this? Does it have something to do with the signature of the function?

Answer 1

No, these are not necessary, and are in fact ignored by the compiler. You can even give them different names in different declarations; the following is entirely legal:

int foo(int bar);
int foo(int biz);
int foo(int qux) {
    ...
}

The reason to put them in is documentation:

• If someone reads your header file, they can tell at a glance what each parameter is used for.
• If you use a fancy IDE, it can show you the parameter names when you begin typing the function call.
• Documentation tools like Doxygen can parse the parameter names and show them in the documentation.

Answer 2

Parameter names are completely optional, and have no effect on compilation. They may be placed there for better readability of code.

Answer 3

You don't need parameter names in declarations. They are purely documentation.

You don't even need names in definitions:

int f(int)
{
    return 0;
}

compiles just fine in C++ (though not in C). This is sometimes useful for e.g. inheritance, overloading, function pointers.

Answer 4

You do not need to include parameter names in function prototypes. You only need the complete signature, which includes the types of parameters and (in the case of function template specializations) return values.

However, it is still common to include parameter names in order to write self-documenting code. That is, a function with this declaration:

void foo(int number_of_foos_desired, string foo_replacement);

is easier to understand by looking only at the prototype, perhaps, than this one:

void foo(int, string);

Many modern IDEs will also pop up the parameter names as you type when you write code that calls this function. They may not be able to pop up this information if you dont include the parameter names in the prototype.

Answer 5

It has alot to do with the signature of the function.

One of the benefits of using .h files is that when someone comes along and wants to get a sense of what your program/api does, they can look at your header file and get a sense of what operations are being carried out, their inputs and outputs, how everything is going together, etc.

If you were to come across a method like

int doStuff(int,int)

this would be alot less telling than a method with a signature of say:

int doStuff(int firstNumberToAdd, int secondNumberToAdd);

with the second, you at least get some idea of the operations that are being carried out, and what is happening. This is the idea behind writing self documenting code.

If your interested, you may check out Code Complete by Steve McConnell.

Answer 6

There are different scenarios to it. I found it very helpful in dealing with inheritance and virtual functions. If you're using a virtual function that generates unused warning in sub class, you can omit the variable names.