Function pointers and #defines

Function pointers and #defines

[Justin Carlson]

A fair number of places in the headers, we have stuff like this:

void (*_some_fn)(int arg1, int arg2);
#define some_fn(arg1, arg2) _some_fn(arg1, arg2)

Why do we do this, as opposed to:

void (*some_fn)(int arg1, int arg2);

Both syntaxes result in being able to say

some_fn(1, 2);

but the latter is both clearer and shorter.  Is there some deep,
mystical C reason that we use the former, or did someone do it that way
a long time ago and no one has changed it?

-Justin

Re: Function pointers and #defines

[Daniel Jacobowitz]

On Thu, May 30, 2002 at 12:32:47PM -0700, Justin Carlson wrote:
> A fair number of places in the headers, we have stuff like this:
> 
> void (*_some_fn)(int arg1, int arg2);
> #define some_fn(arg1, arg2) _some_fn(arg1, arg2)
> 
> Why do we do this, as opposed to:
> 
> void (*some_fn)(int arg1, int arg2);
> 
> Both syntaxes result in being able to say
> 
> some_fn(1, 2);
> 
> but the latter is both clearer and shorter.  Is there some deep,
> mystical C reason that we use the former, or did someone do it that way
> a long time ago and no one has changed it?

At a guess, this prevents taking the address of the function
unintentionally...

-- 
Daniel Jacobowitz                           Carnegie Mellon University
MontaVista Software                         Debian GNU/Linux Developer

Re: Function pointers and #defines

[Justin Carlson]

On Thu, 2002-05-30 at 12:50, Daniel Jacobowitz wrote:
> > but the latter is both clearer and shorter.  Is there some deep,
> > mystical C reason that we use the former, or did someone do it that way
> > a long time ago and no one has changed it?
> 
> At a guess, this prevents taking the address of the function
> unintentionally...

But if you're writing code in such a way that the compiler type checking
doesn't flag this, you deserve what you get.  (IMHO, of course.  :)

-Justin

Re: Function pointers and #defines

[Kevin D. Kissell]

From: "Daniel Jacobowitz" <dan@debian.org>
> On Thu, May 30, 2002 at 12:32:47PM -0700, Justin Carlson wrote:
> > A fair number of places in the headers, we have stuff like this:
> > 
> > void (*_some_fn)(int arg1, int arg2);
> > #define some_fn(arg1, arg2) _some_fn(arg1, arg2)
> > 
> > Why do we do this, as opposed to:
> > 
> > void (*some_fn)(int arg1, int arg2);
> > 
> > Both syntaxes result in being able to say
> > 
> > some_fn(1, 2);
> > 
> > but the latter is both clearer and shorter.  Is there some deep,
> > mystical C reason that we use the former, or did someone do it that way
> > a long time ago and no one has changed it?
> 
> At a guess, this prevents taking the address of the function
> unintentionally...

More likely, some ancient early version of the code was
written with a single global function, some_fn(), and it
was easier to override it with a pointer indirection in
the header than to hunt down and change all invocations.
Sometimes that's good software engineering.  Sometimes
it's just laziness...

            Kevin K.

Re: Function pointers and #defines

[Kevin D. Kissell]

From: "Daniel Jacobowitz" <dan@debian.org>
> On Thu, May 30, 2002 at 12:32:47PM -0700, Justin Carlson wrote:
> > A fair number of places in the headers, we have stuff like this:
> > 
> > void (*_some_fn)(int arg1, int arg2);
> > #define some_fn(arg1, arg2) _some_fn(arg1, arg2)
> > 
> > Why do we do this, as opposed to:
> > 
> > void (*some_fn)(int arg1, int arg2);
> > 
> > Both syntaxes result in being able to say
> > 
> > some_fn(1, 2);
> > 
> > but the latter is both clearer and shorter.  Is there some deep,
> > mystical C reason that we use the former, or did someone do it that way
> > a long time ago and no one has changed it?
> 
> At a guess, this prevents taking the address of the function
> unintentionally...

More likely, some ancient early version of the code was
written with a single global function, some_fn(), and it
was easier to override it with a pointer indirection in
the header than to hunt down and change all invocations.
Sometimes that's good software engineering.  Sometimes
it's just laziness...

            Kevin K.

Re: Function pointers and #defines

[Gleb O. Raiko]

"Kevin D. Kissell" wrote:
> 
> From: "Daniel Jacobowitz" <dan@debian.org>
> > On Thu, May 30, 2002 at 12:32:47PM -0700, Justin Carlson wrote:
> > > A fair number of places in the headers, we have stuff like this:
> > >
> > > void (*_some_fn)(int arg1, int arg2);
> > > #define some_fn(arg1, arg2) _some_fn(arg1, arg2)
> > >
> > > Why do we do this, as opposed to:
> > >
> > > void (*some_fn)(int arg1, int arg2);
> > >
> > > Both syntaxes result in being able to say
> > >
> > > some_fn(1, 2);
> > >
> > > but the latter is both clearer and shorter.  Is there some deep,
> > > mystical C reason that we use the former, or did someone do it that way
> > > a long time ago and no one has changed it?
> >
> > At a guess, this prevents taking the address of the function
> > unintentionally...
> 
> More likely, some ancient early version of the code was
> written with a single global function, some_fn(), and it
> was easier to override it with a pointer indirection in
> the header than to hunt down and change all invocations.
> Sometimes that's good software engineering.  Sometimes
> it's just laziness...
> 
>             Kevin K.

Just remove the declaration, compile, and look at the code generated.
So, #define is just a safety belt.

Regards,
Gleb.