function prototype

charlitos · 04-12-2009, 08:57 PM

Is it ok to omit the parameter's names on functions prototypes? I know it will give you more information about what the function expects exactly, but I always put a comment box on top of my functions explaining what my parameters are gonna be used for.

whats the deal?

IBall · 04-12-2009, 10:28 PM

You can omit the parameter's name on a function prototype, however I would say best practice would be to include it.

You should code in a style that makes it easy for others to see what is going on, easy for you to see what you have written and to prevent mistakes.

One thing about commenting - what if you update the function prototype but forget to update the comment? You will then have unclear code with a contradictory comment. Including the parameter name prevents this.

--Ian

wje_lq · 04-12-2009, 11:37 PM

Quote:

Originally Posted by IBall

One thing about commenting - what if you update the function prototype but forget to update the comment? You will then have unclear code with a contradictory comment. Including the parameter name prevents this.

And what if you update the function definition in a way that changes the name and meaning (but not the type) of one of the parameters, but forget to update the prototype? You will then have unclear code with a prototype which is contradictory for humans, though not for the compiler.

Unlikely, but realize that the parameter name in a prototype is just another comment.

paulsm4 · 04-13-2009, 12:19 AM

Hi -

I actually have to deal with legacy code where the programmer felt, for whatever reason, he didn't need names on his prototypes (and sometimes even his implementation classes: no kidding!)

Syntactically: permissible.

In practice: it's Evil. Don't do it!

IMHO .. PSM

graemef · 04-13-2009, 07:04 AM

There are situations where it can be useful not to include the parameter names. (Whether "useful" is the right word I'm not sure) I have some functions that are used just as callback functions but they do not always require the parameter that will be passed in, for those functions I omit the parameter name in the function definition, thus avoiding warning from the compiler but I still tend to keep them in the declaration, for clarity, but omitting it would indicate (to me) that they were not needed by the function.

wje_lq · 04-13-2009, 09:58 AM

Quote:

Originally Posted by graemef

they do not always require the parameter that will be passed in, for those functions I omit the parameter name in the function definition, thus avoiding warning from the compiler

Just for the record:

they're errors, not warnings; and
one avoids these errors not by omitting parameter names, but including them.

To see this in action, run the following bash script:

Code:

#!/bin/bash

gcc --version | head -1;     \
cat > 1.c <<EOD;             \
cat -n 1.c | sed 's/^    //';\
gcc -Wall 1.c -o 1;          \
if [ $? = 0 ] ; then ./1; fi
#include <stdio.h>

void name_in_no_places  (int      );
void name_in_declaration(int param);
void name_in_definition (int      );
void name_in_both_places(int param);

int main(void)
{
  name_in_no_places  (1);
  name_in_declaration(2);
  name_in_definition (3);
  name_in_both_places(4);

  return 0;

} /* main() */

void name_in_no_places  (int      ){printf("name_in_no_places  ()\n");}
void name_in_declaration(int      ){printf("name_in_declaration()\n");}
void name_in_definition (int kazam){printf("name_in_definition ()\n");}
void name_in_both_places(int kazam){printf("name_in_both_places()\n");}
EOD

When I did so, I got this output:

Code:

gcc (GCC) 4.2.3
 1	#include <stdio.h>
 2	
 3	void name_in_no_places  (int      );
 4	void name_in_declaration(int param);
 5	void name_in_definition (int      );
 6	void name_in_both_places(int param);
 7	
 8	int main(void)
 9	{
10	  name_in_no_places  (1);
11	  name_in_declaration(2);
12	  name_in_definition (3);
13	  name_in_both_places(4);
14	
15	  return 0;
16	
17	} /* main() */
18	
19	void name_in_no_places  (int      ){printf("name_in_no_places  ()\n");}
20	void name_in_declaration(int      ){printf("name_in_declaration()\n");}
21	void name_in_definition (int kazam){printf("name_in_definition ()\n");}
22	void name_in_both_places(int kazam){printf("name_in_both_places()\n");}
1.c: In function 'name_in_no_places':
1.c:19: error: parameter name omitted
1.c: In function 'name_in_declaration':
1.c:20: error: parameter name omitted

graemef · 04-13-2009, 05:05 PM

For the record

Code:

#include <cstdio>

void name_in_no_places  (int      );
void name_in_declaration(int param);
void name_in_definition (int      );
void name_in_both_places(int param);

int main(void)
{
  name_in_no_places  (1);
  name_in_declaration(2);
  name_in_definition (3);
  name_in_both_places(4);

  return 0;

} /* main() */

void name_in_no_places  (int      ){printf("name_in_no_places  ()\n");}
void name_in_declaration(int      ){printf("name_in_declaration()\n");}
void name_in_definition (int kazam){printf("name_in_definition ()\n");}
void name_in_both_places(int kazam){printf("name_in_both_places()\n");}

I get the following output

Code:

$ g++ test.cpp -Wextra -Wall -o test
test.cpp:21: warning: unused parameter ‘kazam’
test.cpp:22: warning: unused parameter ‘kazam’

Just one more language difference between C and C++

wje_lq · 04-14-2009, 12:57 AM

Ooo, good point!

paulsm4 · 04-14-2009, 01:10 AM

charlitos -

Anonymous parameters: Just say "No."

You'll earn a tremendous debt of gratitude from any developers who'll work on your code afterwards ;-)

IMHO .. PSM

PS:
I believe in comments, and I believe that "comment boxes" have their place...

... but I also believe the aphorism "Comments are Lies".

"Self-documenting code" beats comments. And named parameters are arguably a good example of self-documenting code...

wje_lq · 04-14-2009, 07:14 AM

Quote:

Originally Posted by paulsm4

"Self-documenting code" beats comments.

Absolutely.

Quote:

Originally Posted by paulsm4

named parameters are arguably a good example of self-documenting code...

Correct. But seen another way, named parameters in function prototypes (function declarations) are arguably comments.