what is the difference, void func(void) and void fucn()

[noblesantosh]

Hi all,
What is the difference between following two function definations?
<1>
void func(void)
{
/* some code */
}

<2>
void func()
{
/* some code */
}

Why would somebody use 2nd one?

--santosh.

[S.Tobias]

no**********@yahoo.com wrote:

Hi all,
What is the difference between following two function definations?
<1>
void func(void)
{
/* some code */
}

<2>
void func()
{
/* some code */
}
Both define a function returning void, and accepting zero arguments.

They define `func' with different types. The first type is a type
with a prototype, the second type is without a prototype.

If in a function call expression the expression designating the
function has a type without a prototype, and any arguments
are passed, compiler is not required to diagnose an error,
but the behaviour is undefined.

void f();
f(x); //UB, no diagnostic

void f(void);
f(x); //diagnostic

(It's a bit longer story when a function hasn't a prototype, and
has arguments - then the number of arguments and types after
promotion count.)
Why would somebody use 2nd one?

For me it's usually laziness. Maybe there are other reasons,
I don't know.
(Note: there may be important reasons to declare a function
_type_ without a prototype.)

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

[noblesantosh]

S.Tobias wrote:

no**********@yahoo.com wrote:

Hi all,
What is the difference between following two function definations?
<1>
void func(void)
{
/* some code */
}

<2>
void func()
{
/* some code */
}

Both define a function returning void, and accepting zero arguments.

They define `func' with different types. The first type is a type
with a prototype, the second type is without a prototype.

If in a function call expression the expression designating the
function has a type without a prototype, and any arguments
are passed, compiler is not required to diagnose an error,
but the behaviour is undefined.

void f();
f(x); //UB, no diagnostic

void f(void);
f(x); //diagnostic

(It's a bit longer story when a function hasn't a prototype, and
has arguments - then the number of arguments and types after
promotion count.)

Why would somebody use 2nd one?

For me it's usually laziness. Maybe there are other reasons,
I don't know.
(Note: there may be important reasons to declare a function
_type_ without a prototype.)

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

Thanks stan.
and how the following function differs with above two functions

3>
void fucn(int a, ...)
{
/*some code*/
}
Can't we use 2nd as variable number of arguments like 3rd.
Can you or anybody further explore it?
--santosh

[Dik T. Winter]

In article <3k************@individual.net> "S.Tobias" <si***@FamOuS.BedBuG.pAlS.INVALID> writes:
....

If in a function call expression the expression designating the
function has a type without a prototype, and any arguments
are passed, compiler is not required to diagnose an error,
but the behaviour is undefined.

void f();
f(x); //UB, no diagnostic
This is only undefined behaviour when the actual function f has not a
single parameter. "void f();" declares a function f that returns void
with an unspecified number of parameters of unspecified type. So
f(x) is undefined behaviour if the actual function does *not* have a
single parameter.

Why would somebody use 2nd one?

[ about void f(); ]
For me it's usually laziness. Maybe there are other reasons,

In pre-standard C (i.e. C without prototypes) that was the standard
way to declare functions.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[S.Tobias]

Dik T. Winter <Di********@cwi.nl> wrote:

In article <3k************@individual.net> "S.Tobias" <si***@FamOuS.BedBuG.pAlS.INVALID> writes:
...

void f();
f(x); //UB, no diagnostic

This is only undefined behaviour when the actual function f has not a
single parameter. "void f();" declares a function f that returns void
with an unspecified number of parameters of unspecified type. So
f(x) is undefined behaviour if the actual function does *not* have a
single parameter.

Yes, thanks. I was thinking only about the simple case that
the OP asked about, and should have written: `void f(){}'.

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

[S.Tobias]

no**********@yahoo.com wrote:

S.Tobias wrote:

no**********@yahoo.com wrote:

> What is the difference between following two function definations?
> <1>
> void func(void)
> {
> /* some code */
> }
>
> <2>
> void func()
> {
> /* some code */
> }
Both define a function returning void, and accepting zero arguments.

They define `func' with different types. The first type is a type
with a prototype, the second type is without a prototype.

[snip] and how the following function differs with above two functions

3>
void fucn(int a, ...)
{
/*some code*/
}
Can't we use 2nd as variable number of arguments like 3rd.

No, the third declares a type wich is not compatible with the second
case.

typedef void f_t();

`f_t' is compatible with:

void f();
void f(void);
void f(int);
void f(int, int);

but is not compatible with:

int f();
void f(int, ...);

--
Stan Tobias
mailx `echo si***@FamOuS.BedBuG.pAlS.INVALID | sed s/[[:upper:]]//g`