the usage of void argument

[PengYu.UT]

Hi,

I find I have to declare a function like "int f(void);", if the
function should not accept any arguments. If I declare with "int f();"
instead, the compiler won't give any error if I call the function f
with arguments.

I'm wondering when I should use "f()" instead of "f(void)" to declare
the function. Should I use "f(void)" to define the function after I
have declared the function by "f(void)"? Or I can simply use "f()" to
define the function?

Best wishes,
Peng

[Eric Sosman]

Pe*******@gmail.com wrote:

Hi,

I find I have to declare a function like "int f(void);", if the
function should not accept any arguments. If I declare with "int f();"
instead, the compiler won't give any error if I call the function f
with arguments.

I'm wondering when I should use "f()" instead of "f(void)" to declare
the function. Should I use "f(void)" to define the function after I
have declared the function by "f(void)"? Or I can simply use "f()" to
define the function?

You *can* use plain f() in the function definition, but
it's not a good idea. It's a hold-over from the pre-Standard
days, and is described in the Standard as an "obsolescent
feature." Best practice: declare f(void) and define f(void).

--
Er*********@sun.com

[Malcolm]

<Pe*******@gmail.com> wrote

I'm wondering when I should use "f()" instead of "f(void)"

Basically never. f() is for playing silly games with C's calling system
which hackers do for fun and experienced programmers very occasionally might
have to do to get round some inherent weakness in the language.

[Alan Balmer]

On Wed, 22 Jun 2005 18:25:18 -0400, Eric Sosman <er*********@sun.com>
wrote:

Pe*******@gmail.com wrote:

Hi,

I find I have to declare a function like "int f(void);", if the
function should not accept any arguments. If I declare with "int f();"
instead, the compiler won't give any error if I call the function f
with arguments.

I'm wondering when I should use "f()" instead of "f(void)" to declare
the function. Should I use "f(void)" to define the function after I
have declared the function by "f(void)"? Or I can simply use "f()" to
define the function?

You *can* use plain f() in the function definition, but
it's not a good idea. It's a hold-over from the pre-Standard
days, and is described in the Standard as an "obsolescent
feature." Best practice: declare f(void) and define f(void).

Besides, it's easier. For me, at least - I have an editor macro which
copies the definition and tucks it away in a selected spot, followed
by ';'.

--
Al Balmer
Balmer Consulting
re************************@att.net

[Rajan]

Hi Peng and others,
I thought that f(void) was meant to make it very explicit that function
f() does not receive any arguments.

[Suman]

Rajan wrote:

Hi Peng and others,
I thought that f(void) was meant f(void)
is incomplete - it tells you about a function f that takes *no*
parameters
and nothing else about the return type. to make it very explicit that function I beg to differ, here. f() does not receive any arguments.

f()
is even more incomplete - it tells you about a function f and nothing
else, neither the return type nor the parameter list (it is
unspecified, and hence can be whatever you chose it to be).

Regards,
Suman.

[Suman]

Rajan wrote:

Hi Peng and others,
I thought that f(void) was meant f(void)
is incomplete - it tells you about a function f that takes *no*
parameters
and nothing else about the return type. to make it very explicit that function I beg to differ, here. f() does not receive any arguments.

f()
is even more incomplete - it tells you about a function f and nothing
else, neither the return type nor the parameter list (it is
unspecified, and hence can be whatever you chose it to be).

Regards,
Suman.

[Joel]

If you declare the function like "int f();" the compiler won't give any
error, because by default it will be integer if you don't mention any
data type.So you can pass any integer argument to the function, not
any other data type.

[john_bode]

Pe*******@gmail.com wrote:

Hi,

I find I have to declare a function like "int f(void);", if the
function should not accept any arguments. If I declare with "int f();"
instead, the compiler won't give any error if I call the function f
with arguments.

That's because the declaration "int f();" says f takes an
*indeterminate* number of parameters. This is a holdover from the old
K&R days when there was no compile-time checking for the right number
and types of parameters in a function call. With the introduction of
prototypes, this form of function declaration has become obsolete and
should not be used anymore, even though compilers still support it.
I'm wondering when I should use "f()" instead of "f(void)" to declare
the function.
In C, never[1]. If the function is supposed to take no arguments, you
should always specify that explicitly with "void" as the parameter
list.
Should I use "f(void)" to define the function after I
have declared the function by "f(void)"? Or I can simply use "f()" to
define the function?

Declarations and definitions should always match. If you declare the
function as "int f(void);", the definition should be "int f(void) {
/*code*/ }".
Best wishes,
Peng

1. Note that in C++, "int f();" is the same as "int f(void);" in C.

[forayer]

Joel wrote:

If you declare the function like "int f();" the compiler won't give any
error, because by default it will be integer if you don't mention any
data type.So you can pass any integer argument to the function, not
any other data type.

Guys, please correct me if I am wrong, but given my C++ background, I
think what Joel is trying to say is "int foo()" and "foo()" are same in
that both have _return_ type int! Joel, I don't think either
declaration can take an argument.

cheers,
forayer

[ade ishs]

Suman wrote:

Rajan wrote:

Hi Peng and others,
I thought that f(void) was meant

f(void)
is incomplete - it tells you about a function f that takes *no*
parameters
and nothing else about the return type.

AFAIK, it implicitly returns an int (in C89). See for example the
programs in K&R2 using "main()".
ishs

[Lawrence Kirby]

On Thu, 23 Jun 2005 08:01:36 -0700, forayer wrote:

Joel wrote:

If you declare the function like "int f();" the compiler won't give any
error, because by default it will be integer if you don't mention any
data type.So you can pass any integer argument to the function, not
any other data type.

The argument type is not limited to int.
Guys, please correct me if I am wrong, but given my C++ background, I
think what Joel is trying to say is "int foo()" and "foo()" are same in
that both have _return_ type int! Joel, I don't think either
declaration can take an argument.

Joel was talking about the arguments, not the return value. This is a case
where C and C++ differ. When you give a completely empty argument list in
a C declaration that isn't a definition, it doesn't mean no arguments it
means unspecified arguments. C99 no longer supports implicit int so just
"foo()" is invalid.

Lawrence

[Suman]

ade ishs wrote:

Suman wrote:

Rajan wrote:

Hi Peng and others,
I thought that f(void) was meant

f(void)
is incomplete - it tells you about a function f that takes *no*
parameters
and nothing else about the return type.

AFAIK, it implicitly returns an int (in C89). See for example the
programs in K&R2 using "main()".

Unfortunately, yes. But from C99, no - it doesn't.

Regards,
Suman.

[Jaspreet]

Pe*******@gmail.com wrote:

Hi,

I find I have to declare a function like "int f(void);", if the
function should not accept any arguments. If I declare with "int f();"
instead, the compiler won't give any error if I call the function f
with arguments.

I'm wondering when I should use "f()" instead of "f(void)" to declare
the function. Should I use "f(void)" to define the function after I
have declared the function by "f(void)"? Or I can simply use "f()" to
define the function?

Best wishes,
Peng

I would suggest you use int f(void) at both places that is decl. and at
definition.

int f() could mean that your function **may** accept variable number of
arguments. Soo, to tell compiler and others that your function does not
accept any parameters, gor for int f(void).

Let me know if I am wrong.

[PengYu.UT]

> That's because the declaration "int f();" says f takes an

*indeterminate* number of parameters. This is a holdover from the old
K&R days when there was no compile-time checking for the right number
and types of parameters in a function call. With the introduction of
prototypes, this form of function declaration has become obsolete and
should not be used anymore, even though compilers still support it.

Could you tell me more about "prototypes"?

[john_bode]

Pe*******@gmail.com wrote:

That's because the declaration "int f();" says f takes an
*indeterminate* number of parameters. This is a holdover from the old
K&R days when there was no compile-time checking for the right number
and types of parameters in a function call. With the introduction of
prototypes, this form of function declaration has become obsolete and
should not be used anymore, even though compilers still support it.

Could you tell me more about "prototypes"?

You'd be better off checking your favorite C reference manual; it will
give a better explanation than I can.

Basically, a function can be declared or defined using a prototype
syntax, meaning that you specify the types of arguments as part of the
parameter list. The best way I can explain is by using examples:

/*
** Function definition using old style, non-prototype syntax (it's been
a
** while since I've written C code using this style, so I may not have
this
** exactly right, but you get the general idea).
*/
int f(x, y, z)
int x;
double y;
char *z;
{
/* code */
}

/*
** Same function definition using prototype syntax
*/
int f(int x, double y, char *z)
{
/* code */
}

/*
** Function declaration using non-prototype syntax
*/
int f();

/*
** Same function declaration using prototype syntax
*/
int f(int x, double y, char *z);
/*
** Function taking no arguments, non-prototype syntax
*/
void f(); /* declaration */

void f() /* definition */
{
/* code */
}

/*
** Same function, using prototype syntax
*/
void f(void); /* declaration */

void f(void) /* definition */
{
/* code */
}

Basically, the presence of a prototype allows the compiler to verify
that you're calling a function with the right number and types of
parameters. You should *always* use prototypes.

[Dave Thompson]

On 23 Jun 2005 21:26:27 -0700, "Jaspreet" <js***********@gmail.com>
wrote:

Pe*******@gmail.com wrote: <snip prototype int f(void) vs oldstyle int f()> I would suggest you use int f(void) at both places that is decl. and at
definition.

int f() could mean that your function **may** accept variable number of
arguments. Soo, to tell compiler and others that your function does not
accept any parameters, gor for int f(void).

Let me know if I am wrong.

Officially you are. int f() means the function accepts an unspecified
but fixed number (and list) of arguments of K&R1-compatible types,
which are those which survive after default promotion = excluding
integer types below int and float.

It is Undefined Behavior to call a variadic (aka varargs) function
without using a prototype declaration specifying ellipsis, so they can
have a different calling convention than "normal" functions including
K&R1-compatible ones, and I have used an implementation which does so
and crashes badly if you confuse them, although _many_ implementations
including all-in-memory register-poor x86 do use a calling convention
which works the same for variadic and non.

- David.Thompson1 at worldnet.att.net