Why no generic function pointers?

[copx]

Why doesn't the C standard include generic function pointers?

I use function pointers a lot and the lack of generic ones is not so cool.

There is a common compiler extension (supported by GCC and lccwin32 for example)
which I consider to be perfectly reasonable: you can cast every kind of function pointer
to a void pointer and void pointers to any kind of function pointer.

This follows the general "generics through void scheme" of C. In fact, it seems to be quite
"irregular" to me that you can't cast function pointers to void.

I mean, of course, generic function pointers are "dangerous" , because they allow
you to call a function with bad arguments and the compiler can't detect that.
But it's not any more "dangerous" than unsigned char pointers to any type of data i.e.
not against the "C spirit" IMO.

In fact, K&R compilers supported semi-generic function pointers IIRC. You were
able to leave out the parameter declaration (but not the return type declaration) e.g.
int (*foo)();

So why did the comittee decide against making generic function pointers standard?

[Nick Bowler]

On Sat, 21 Jun 2008 02:54:25 +0200, copx wrote:

Why doesn't the C standard include generic function pointers?

It does, in a way: you can convert (using a cast) a function pointer to a
different function pointer type and back again: the result shall compare
equal to the original pointer. This is similar to the semantics of
void *, except that the conversion is not implicit.

This follows the general "generics through void scheme" of C. In fact,
it seems to be quite "irregular" to me that you can't cast function
pointers to void.

On some systems, function pointers are significantly larger than object
pointers.

In fact, K&R compilers supported semi-generic function pointers IIRC.
You were able to leave out the parameter declaration (but not the return
type declaration) e.g. int (*foo)();

You can still do this.

[Eric Sosman]

copx wrote:

Why doesn't the C standard include generic function pointers?

I use function pointers a lot and the lack of generic ones is not so cool.

There is a common compiler extension (supported by GCC and lccwin32 for example)
which I consider to be perfectly reasonable: you can cast every kind of function pointer
to a void pointer and void pointers to any kind of function pointer.

And in strictly-conforming C you can cast any function pointer
to any other function pointer type and back again. What's your beef?

This follows the general "generics through void scheme" of C. In fact, it seems to be quite
"irregular" to me that you can't cast function pointers to void.

If you're irregular, try a laxative.

--
Eric Sosman
es*****@ieee-dot-org.invalid

[copx]

"Nick Bowler" <dr*****@gmail. comschrieb im Newsbeitrag news:g3******** **@rumours.uwat erloo.ca...

On Sat, 21 Jun 2008 02:54:25 +0200, copx wrote:

>Why doesn't the C standard include generic function pointers?

It does, in a way: you can convert (using a cast) a function pointer to a
different function pointer type and back again: the result shall compare
equal to the original pointer. This is similar to the semantics of
void *, except that the conversion is not implicit.

Interesting. Thanks, I didn't know that.

[copx]

"Eric Sosman" <es*****@ieee-dot-org.invalidschr ieb im Newsbeitrag news:Z_******** *************** *******@comcast .com...

copx wrote:

[snip]

>This follows the general "generics through void scheme" of C. In fact, it seems to be quite
"irregular" to me that you can't cast function pointers to void.

If you're irregular, try a laxative.

*plonk*

[Keith Thompson]

"copx" <co**@gazeta.pl writes:

"Eric Sosman" <es*****@ieee-dot-org.invalidschr ieb im Newsbeitrag news:Z_******** *************** *******@comcast .com...

>copx wrote:

[snip]

>>This follows the general "generics through void scheme" of C. In
fact, it seems to be quite "irregular" to me that you can't cast
function pointers to void.

If you're irregular, try a laxative.

*plonk*

Tons of deliberate personal abuse in this newsgroup, and you plonk
someone over a little joke? I suggest you reconsider -- but if you
don't, it's your loss.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Keith Thompson]

"copx" <co**@gazeta.pl writes:

Why doesn't the C standard include generic function pointers?

[...]

Remember that there are two distinct ways in which void* is a
"generic" object pointer.

One is that a conversion from foo* to void* and back again is
guaranteed to yield the original value, where foo is any object or
incomplete type. As others have mentioned, *all* function pointers
behave this way. If you want a single generic function pointer type,
I suggest void(*)(void), just because it's the simplest (a typedef
could be helpful).

The other way is that conversions between void* and foo* (foo as
above) may be done implicitly. This isn't the case for function
pointers, but that's just a matter of syntactic convenience.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Malcolm McLean]

"copx" <co**@gazeta.pl wrote in message

Why doesn't the C standard include generic function pointers?

Because you can't build an argument list on the fly. You can hardcode

switch(type)
{
case 1:
x = (*fp)(1,2,3);
break;
case 2:
y = (*fp)("My name is fred");
}

but you can't pass in a format string and build a list with an arbitrary
number of integers and strings.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[Ben Bacarisse]

"Malcolm McLean" <re*******@btin ternet.comwrite s:

"copx" <co**@gazeta.pl wrote in message

>Why doesn't the C standard include generic function pointers?

Because you can't build an argument list on the fly.

That begs the question of why one can't do *that*. There are macros
to examine an existing var-arg list, and there the could be macros to
build one from scratch. Given such a thing, a function pointer type
like:

void *(*var_arg_fp)( void *, ...);

would be very flexible (you need a dummy first argument to get the var
arg macros going).

I presume the answer is just history. Of course, it may be that there
are real systems for which such argument building macros/functions
would be impossible, but the seems a stretch.

--
Ben.

[Malcolm McLean]

"Ben Bacarisse" <be********@bsb .me.ukwrote in message

"Malcolm McLean" <re*******@btin ternet.comwrite s:

>"copx" <co**@gazeta.pl wrote in message

>>Why doesn't the C standard include generic function pointers?

Because you can't build an argument list on the fly.

That begs the question of why one can't do *that*. There are macros
to examine an existing var-arg list, and there the could be macros to
build one from scratch. Given such a thing, a function pointer type
like:

void *(*var_arg_fp)( void *, ...);

would be very flexible (you need a dummy first argument to get the var
arg macros going).

I presume the answer is just history. Of course, it may be that there
are real systems for which such argument building macros/functions
would be impossible, but the seems a stretch.

I think that's right.
Usually any assembly language routine can be translated to C quite easily.
The exception is those assembly routines that build dynamic argument lists.
Normally this is relatively strightforwards in assembly - just push the
first few arguments into registers and the rest on the stack, but you can't
do it in C.

It would tend to open security holes, but I don't think that was the
historical reason for rejecting the idea. Maybe it was because it doesn't
fit well with the structured programming paradigm.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm