A function is an address

[Julienne Walker]

Ignoring implementation details and strictly following the C99
standard in terms of semantics, is there anything fundamentally flawed
with describing the use of a (non-inline) function as an address[1]? I
keep feeling like I'm missing something obvious.
-Jul

[1] To keep things in context, this is in reference to describing
functions to a beginner.

[Eric Sosman]

Julienne Walker wrote:

Ignoring implementation details and strictly following the C99
standard in terms of semantics, is there anything fundamentally flawed
with describing the use of a (non-inline) function as an address[1]? I
keep feeling like I'm missing something obvious.

It would probably be better to describe a function as
a custard pie.

-Jul

[1] To keep things in context, this is in reference to describing
functions to a beginner.

Oh, a beginner? In that case, "custard pie" is by far
the best way to introduce the topic. Later, when the pupil
has gained some understanding and experience, you can go
back and explain that "custard pie" is really a simplification;
in full generality a function can be any kind of dessert or
comedic prop whatsoever.

(In other words, have you taken leave of your senses,
or have they taken leave of you? Or are you a disciple of
Humpty Dumpty, determined to make words mean whatever you
want them to and without regard to what others may think
they mean?)

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

[jameskuyper]

Julienne Walker wrote:

Ignoring implementation details and strictly following the C99
standard in terms of semantics, is there anything fundamentally flawed
with describing the use of a (non-inline) function as an address[1]? I
keep feeling like I'm missing something obvious.

A function typically has an associated memory address indicating the
entry point for the function. A function is not an address, any more
than your house is an address.

[Keith Thompson]

Julienne Walker <ha*********@ho tmail.comwrites :

Ignoring implementation details and strictly following the C99
standard in terms of semantics, is there anything fundamentally flawed
with describing the use of a (non-inline) function as an address[1]? I
keep feeling like I'm missing something obvious.

[1] To keep things in context, this is in reference to describing
functions to a beginner.

I can't think of anything *not* fundamentally flawed about describing
the use of a function as an address.

I suspect what you're thinking of is the fact that an expression of
function type (including the name of a function) is, unless it's the
operand of a unary "sizeof" or "&" operator, implicitly converted to
the function's address, and the first operand of a function call
operator is actually a pointer-to-function, not necessarily a
function. I'm sure this is covered in the FAQ.

But this does not imply that a function *is* an address (it isn't),
and it's not necessarily something I'd mention to beginners.

Until a beginner starts to use function pointers explicitly, it
probably sufices to say that a function call func(arg1, arg2) calls
the specified function and passes it the specified arguments. The
fact that there's a conversion to a function pointer happening behind
the scenes can probably wait until later.

--
Keith Thompson (The_Other_Keit h) <ks***@mib.or g>
Looking for software development work in the San Diego area.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Keith Thompson]

Julienne Walker <ha*********@ho tmail.comwrites :
[SNIP]

So please allow me to refine my question: In what cases would the use
of a function name *not* evaluate to a pointer to that function?

When it's the operand of a unary "sizeof" operator (which is a
constraint error, rather than yielding the size of a function
pointer), and when it's the operand of a unary "&" operator (which
yields the address of the function, rather than attempting to compute
the address of the address of the function, which would be a
constraint violation).

Note that this applies to any expression of function type, not just a
function name. For example, if ``p'' is an object of
pointer-to-function type, then ``*p'' is an expression of function
type, which then decays (back) to a pointer to the function.

It's quite similar to the hanlding of array names.

--
Keith Thompson (The_Other_Keit h) <ks***@mib.or g>
Looking for software development work in the San Diego area.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Charlton Wilbur]

>>>>"JW" == Julienne Walker <ha*********@ho tmail.comwrites :

JWSo please allow me to refine my question: In what cases would
JWthe use of a function name *not* evaluate to a pointer to that
JWfunction?

Why does a beginner care?

Have you ever tried to teach programming before? This is a concept
that beginners simply do not need to worry about, and making the
beginners worry about it when you introduce functions is a damn fine
way to confuse them.

Charlton


--
Charlton Wilbur
cw*****@chromat ico.net

[Julienne Walker]

On Dec 7, 4:49 pm, Keith Thompson <[e-mail] rote:

Julienne Walker <happyfro...@ho tmail.comwrites :

[SNIP]

So please allow me to refine my question: In what cases would the use
of a function name *not* evaluate to a pointer to that function?

When it's the operand of a unary "sizeof" operator (which is a
constraint error, rather than yielding the size of a function
pointer), and when it's the operand of a unary "&" operator (which
yields the address of the function, rather than attempting to compute
the address of the address of the function, which would be a
constraint violation).

Note that this applies to any expression of function type, not just a
function name. For example, if ``p'' is an object of
pointer-to-function type, then ``*p'' is an expression of function
type, which then decays (back) to a pointer to the function.

It's quite similar to the hanlding of array names.

--
Keith Thompson (The_Other_Keit h) <[e-mail] g>
Looking for software development work in the San Diego area.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

Thank you. That's what I thought, but a worry kept tickling the back
of my brain that there was something else.
-Jul

[Keith Thompson]

ja*********@ver izon.net writes:
[...]

A function name names a function, it is not the same thing as the
function itself. A function pointer will typically contain an address,
but a function pointer is not an address. A function name will decay
into a function pointer in almost every context, but a function name
is not a function pointer.

[...]

Actually, a function pointer *is* an address; it's the address of the
function. (The standard uses the words "address" and "pointer" almost
interchangeably .)

--
Keith Thompson (The_Other_Keit h) <ks***@mib.or g>
Looking for software development work in the San Diego area.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Julienne Walker]

On Dec 7, 4:40 pm, Charlton Wilbur <cwil...@chroma tico.netwrote:

>>>"JW" == Julienne Walker <happyfro...@ho tmail.comwrites :

JWSo please allow me to refine my question: In what cases would
JWthe use of a function name *not* evaluate to a pointer to that
JWfunction?

Why does a beginner care?

A beginner doesn't care about this exact detail, but I'm intending to
use it to smooth the entire process of learning C. Rest assured that
I'm not going to tell a beginner something like that without a plan.

Have you ever tried to teach programming before?

Yes.

This is a concept
that beginners simply do not need to worry about, and making the
beginners worry about it when you introduce functions is a damn fine
way to confuse them.

I appreciate your concern, but I don't think you're in a position to
make that judgment given nothing more than a quick question from me to
the experts on clc.

Charlton

--
Charlton Wilbur
cwil...@chromat ico.net

[jameskuyper]

Keith Thompson wrote:

ja*********@ver izon.net writes:
[...]

A function name names a function, it is not the same thing as the
function itself. A function pointer will typically contain an address,
but a function pointer is not an address. A function name will decay
into a function pointer in almost every context, but a function name
is not a function pointer.

[...]

Actually, a function pointer *is* an address; it's the address of the
function. (The standard uses the words "address" and "pointer" almost
interchangeably .)

I think that, to the extent that the standard does so, it is
defective. Treating the two terms as interchangeable would, if
normative, prohibit the implementation of pointers as structures which
contain, among other things, the address of the location in memory
that they point at. I doubt that it was the intent of the committee to
prohibit such fat-pointer implementations .

Cross-posting to comp.std.c