Help needed with function pointer examples

[Swati]

Hello,

We are doing an analysis on the usage of function pointers.
We have considered one such example as GCC which uses function pointers.
Can you suggest any other application which uses function pointers
extensively.

Regards,
Swati

[Uli Kusterer]

That is a vague, underspecified question if I ever heard one. What
exactly are you looking for with function pointers? Have you
implemented them in your compiler and want some examples to see if
your compiler implements everything necessary?

Anyway, the first example that comes to mind is any application that
can dynamically trigger actions, or that has to translate files or
data into actions. E.g. many interpreters and emulators essentially
look like this (untested C code fragment, never compiled):

struct Instruction { int instructionIndex; int param1; int param2 };
typedef void (*InstructionFuncPtr)( Instruction inInstruction );

InstructionFuncPtr gInstructions[2] = { AddInstruction, SubtractInstruction
};

void main(void)
{
Instruction vInstructions[10];

// ... read instructions from stdin or a file into 'vInstructions' ...

for( int x = 0; vInstructions[x] != -1; x++ )
gInstructions[ vInstructions[x].instructionIndex ]( vInstructions[x] );

return 0;
}

Where AddInstruction and SubtractInstruction are two functions that actually
implement the given operations.

Cheers,
-- Uli Kusterer
http://stacksmith.com

[glen herrmannsfeldt]

Swati <swati...@cse.iitb.ac.in> wrote:

> We are doing an analysis on the usage of function pointers.
> We have considered one such example as GCC which uses function pointers.

You don't specify the language, maybe it matters, maybe not.

Long before function pointers as we usually think of them, Fortran had
the ability to pass a function name as an actual argument. That lets
the called routine call the specified function, but there is no
provision to store such a pointer for later use.

This allows one to write minimization or integration routines (two
popular uses) independent of the function being minimized or
integrated. In a similar way, C's qsort() allows one to supply a
compare routine which is called, but a function pointer isn't saved.

On the other hand, the unix I/O system is built around a structure
array, one element per major device type, containing function
pointers. The pointers might even be compile-time constants. At run
time, then, the I/O system uses a device code to index into the array,
select the appropriate routine for the device, and call it. For many
years, a C compiler was required to sysgen unix, even if the only need
was to compile that table.

> Can you suggest any other application which uses function pointers
> extensively.

I don't know about extensively. Both types of applications are much
more convenient when done using function pointers.

For the former case, you can instead substitute the required function
into the source, compile it and debug it. (For open source routines.)

For the second, you can instead use an indexed jump, such as
switch/case, to a series of function calls.

PL/I has ENTRY variables, which perform a similar function, but
aren't called function pointers.

-- glen
[Any program written in an OO language that allows inheritance or
overloading uses function pointers, since that's how they're
implemented. -John]

[Torben Ægidius Mogensen]

The moderator opined:

> [Any program written in an OO language that allows inheritance or
> overloading uses function pointers, since that's how they're
> implemented. -John]

If the inheritance and overloading can be resolved statically, function
pointers are not needed. But most OO languages use dynamic method
resolution by default, so what you say applies to nearly all OO
implementations.

torben

[Aharon Robbins]

I'm not intimately familiar with the code, but I'm pretty sure Brian
Kernighan's The One True Awk works this way, as does the smaller "hoc"
language presented in The Unix Programming Environment book.

Arnold

Uli Kusterer <ulimakes...@googlemail.com> wrote:
>On 06.01.2012, at 07:43, Swati wrote:
>> We are doing an analysis on the usage of function pointers.
>> We have considered one such example as GCC which uses function pointers.
>> Can you suggest any other application which uses function pointers

>> extensively. ...

[Hans-Peter Diettrich]

Torben Fgidius Mogensen schrieb:

IMO the key is *virtual* methods, which require dynamic lookup in a
Virtual Method Table or similar structure.

In non-OO languages calling conventions like "call by name" also can
require dynamic lookup of function addresses.

Sorting and searching algorithms also typically are implemented with a
compare function (pointer) argument.

DoDi

[Tony Finch]

Function pointers are often a nice way to implement state machines,
for instance http://dotat.at/cgi/git?p=unifdef.git;a=blob;f=unifdef.c

The byte code in a threaded code interpreter is often just a list of
function pointers.

There are a lot of function pointers in the unix kernel. Have a look
at Lions' commentary, Stevens' TCP/IP Illustrated volume 2, and
McKusick & Neville-Neil's Design and Implementation of the FreeBSD
operating system.

Tony.
--
f.anthony.n.finch <d...@dotat.at> http://dotat.at/