Calling atexit

[Kelvin Moss]

Hi all,

The prototype for atexit is 'int atexit(void (*function)(void))';

If I have a function foo defined as
void foo(void)
{

}
then what is the correct way to register the handler -

atexit(&foo); // I think this one
OR
atexit(foo);
Any references to Standard would be appreciated.

Thanks,
Sharad

[dandelion]

"Kelvin Moss" <km**********@yahoo.com> wrote in message
news:11**********************@c13g2000cwb.googlegr oups.com...

Hi all,

The prototype for atexit is 'int atexit(void (*function)(void))';

If I have a function foo defined as
void foo(void)
{

}
then what is the correct way to register the handler -

atexit(&foo); // I think this one
OR
atexit(foo);

The latter. The name of a function evaluates to a pointer to that function.
Much like the name of an array evaluates to a pointer to (the first element
of) that array.

There is a *terribly* good FAQ around.

http://www.eskimo.com/~scs/C-faq/top.html

Eventhough it's not "The Standard" it will answer quite a lot of questions.

http://www.eskimo.com/~scs/C-faq/q4.12.html

and

http://www.eskimo.com/~scs/C-faq/q1.34.html

will probably be of interest to you.

[S.Tobias]

dandelion <da*******@meadow.net> wrote:

"Kelvin Moss" <km**********@yahoo.com> wrote in message
news:11**********************@c13g2000cwb.googlegr oups.com...

atexit(&foo); // I think this one
OR
atexit(foo);

The latter. The name of a function evaluates to a pointer to that function.
Much like the name of an array evaluates to a pointer to (the first element
of) that array.

I think both are correct, see 6.3.2.1#4 and 6.5.3.2#1.

+++++

int a[10];
int *pi;
pi = a; //(1) okay
pi = &a; //(2) *wrong!*, diagnostics

I think it was allowed to use (2) in the distant past (I vaguely remember
even seeing code with such construct). What's the story behind this?

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

[Keith Thompson]

"S.Tobias" <si***@FamOuS.BedBuG.pAlS.INVALID> writes:

dandelion <da*******@meadow.net> wrote:

"Kelvin Moss" <km**********@yahoo.com> wrote in message
news:11**********************@c13g2000cwb.googlegr oups.com...

> atexit(&foo); // I think this one
> OR
> atexit(foo);

The latter. The name of a function evaluates to a pointer to that function.
Much like the name of an array evaluates to a pointer to (the first element
of) that array.

I think both are correct, see 6.3.2.1#4 and 6.5.3.2#1.

+++++

int a[10];
int *pi;
pi = a; //(1) okay
pi = &a; //(2) *wrong!*, diagnostics

I think it was allowed to use (2) in the distant past (I vaguely remember
even seeing code with such construct). What's the story behind this?

Note that you're talking about two different things here, the behavior
of unary "&" when applied to a function, and the behavior of unary "&"
when applied to an array. Presumably the "+++++" marks a change of
topic.

Any occurrence of a function name, except as the operand of a unary
"&" or sizeof operator, is converted to a pointer to the named
function. (The sizeof exception makes "sizeof func" illegal rather
than making it yield the size of a function pointer.) So "func" and
"&func" are equivalent (as expressions, not necessarily as token
sequences). This applies even to function calls; in a call like
foo(42), you're applying the "()" function call operator to the
address of foo.

As for arrays, "a" is converted to a pointer to the first element of a
(a pointer to int), whereas "&a" gives you the address of the array (a
pointer to an array of 10 ints). These are going to be the same
address, and will probably have the same representation. Older
(pre-ANSI) compilers with weaker type checking might treat them as
interchangeable.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[S.Tobias]

Keith Thompson <ks***@mib.org> wrote:

"S.Tobias" <si***@FamOuS.BedBuG.pAlS.INVALID> writes:

int a[10];
int *pi;
pi = a; //(1) okay
pi = &a; //(2) *wrong!*, diagnostics

I think it was allowed to use (2) in the distant past (I vaguely remember
even seeing code with such construct). What's the story behind this?

Note that you're talking about two different things here, the behavior
of unary "&" when applied to a function, and the behavior of unary "&"
when applied to an array.
I saw distant similarity.
Presumably the "+++++" marks a change of
topic.
Is there a better way?

As for arrays, "a" is converted to a pointer to the first element of a
(a pointer to int), whereas "&a" gives you the address of the array (a
pointer to an array of 10 ints). These are going to be the same
address, and will probably have the same representation. Older
(pre-ANSI) compilers with weaker type checking might treat them as
interchangeable.

Thanks. Actually I confused something else (temporary brain black-out).
Array is a non-modifiable (I knew there was something "wrong" with arrays)
lvalue, but still an lvalue and can be an operand to &.

This code is correct:
int a[10];
int (*p)[10] = &a;

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

[Dan Pop]

In <ln************@nuthaus.mib.org> Keith Thompson <ks***@mib.org> writes:

"S.Tobias" <si***@FamOuS.BedBuG.pAlS.INVALID> writes:

int a[10];
int *pi;
pi = a; //(1) okay
pi = &a; //(2) *wrong!*, diagnostics

I think it was allowed to use (2) in the distant past (I vaguely remember
even seeing code with such construct). What's the story behind this?

As for arrays, "a" is converted to a pointer to the first element of a
(a pointer to int), whereas "&a" gives you the address of the array (a
pointer to an array of 10 ints). These are going to be the same
address, and will probably have the same representation. Older
(pre-ANSI) compilers with weaker type checking might treat them as
interchangeable.

Older compilers either didn't allow the & operator to take an array or
function argument or ignored it in such contexts.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Currently looking for a job in the European Union