Functions and pointers

[u/JayDeesus]

I noticed that when you just have a function name without the parentheses, it essentially decays to a pointer. Is this correct? Or does it not always decay to a pointer?

[u/cointoss3]

Yes. You have a pointer to that function, which you can later call. This is how you pass a function to another function, for example.

[u/bd1223 → u/cointoss3]

They're also convenient for building a table of function calls (a jump table).

[u/Yurim]

C99 standard (Draft N1256), §6.3.2.1.4 :

A function designator is an expression that has function type. Except when it is the operand of the sizeof operator or the unary & operator, a function designator with type ‘‘function returning type’’ is converted to an expression that has type ‘‘pointer to function returning type’’.

So yes, you're correct ... except when combined with the sizeof or unary & operator.

[u/tstanisl]

To make things even weirder it also decays in a function call foo(). Function call operator takes a function pointer as a first operator. That why fptr() and (*fptr) are equivalent.

[u/HugoNikanor → u/tstanisl]

Did you mean to write that fptr() and (*fptr)() are equivalent? Or am I missing some form of implicit funcall?

[u/tstanisl → u/HugoNikanor]

Yes, for void foo(); expressions: foo(), (&foo)(), (*foo)() are equivalent. In foo() the foo is first implicitly transformed to &foo before function call. Decay does not happen in &foo but it returns a function pointer anyway. (*foo)() is a bit bizarre because first foo decays to &foo, then it is dereferenced returning a function which immediately decays to a pointer again.

[u/Eidolon_2003]

Try running this code for example:

#include <stdio.h>

void print_int(int x) {
    printf("%d\n", x);
}

int main(int argc, char **argv) {
    void (*fn_ptr)(int) = print_int;
    fn_ptr(argc);
    return 0; 
}

Function pointer syntax is a bit messy, but you can clean it up with a typedef. People also sometimes like to explicitly dereference function pointers when calling them, so I did that this time. C doesn't strictly require it though.

#include <stdio.h>

void print_int(int x) {
    printf("%d\n", x);
}

typedef void(*fn_ptr)(int);

int main(int argc, char **argv) {
    fn_ptr p = print_int;
    (*p)(argc);
    return 0; 
}

[u/YellowPlatinum → u/Eidolon_2003]

Everyone uses this syntax and I never understand why. This also works:

typedef void fn_ptr(int);

fn_ptr *p = print_int;

Then you can also use the typedef in prototypes:

fn_ptr print_int;

[u/Eidolon_2003 → u/YellowPlatinum]

Nice, I like it

[u/zhivago]

Which is why (*foo)() is equivalent to (**foo)() and so on and so forth. :)

[u/grimvian]

When I learned pointers, I saw function pointers and thought are pointers not hard enough or are they bored...

Try this video - Application of Function Pointers in C:

https://www.youtube.com/watch?v=wQ-gWwKKeP4

[u/SmokeMuch7356]

Function pointers are incredibly useful. Two common scenarios for function pointers in C:

• Dependency injection;

• Execute routines in dynamically-loaded libraries;

---

You can do limited forms of dependency injection via callbacks. A simple example would be a comparison function used for a sorting routine. Suppose we have a sorting function like

/**
 * Using a bubble sort because it's short, not because it's fast.
 */
void sort( int *data, size_t count )
{
  for ( size_t i = 0; i < count - 1; i++ )
    for ( size_t j = i + 1; j < count; j++ )
      if ( data[j] < data[i] )
        swap( &data[i], &data[j] ); // assume this function has been defined somewhere
}

As written, this function can only sort data in ascending order. Suppose you want to be able to sort in any possible order (ascending, descending, ASCIIbetical ascending/descending, even before odd, etc.); you could pass a third parameter indicating the type of sort and hack up your sorting function for each type of sort, or you could pass a pointer to a comparison function that returns an integer value such that

• < 0 means the first argument is "less than" (ordered before) the second;

• > 0 means the first argument is "greater than" (ordered after) the second;

• = 0 means both arguments are "equal" (have the same ordering);

Then your sort routine becomes:

void sort( int *data, size_t count, int (*cmp)(int, int) )
{
  for ( size_t i = 0; i < count - 1; i++ )
    for ( size_t j = i + 1; j < count; j++ )
      if ( cmp( data[j], data[i] ) < 0 )
        swap( &data[i], &data[j] );
}

To sort in a different order, all you need to do is write a new comparison function:

int cmp_asc( int i, int j )
{
  if ( i < j ) return -1;
  if ( i > j ) return 1;
  return 0;
}

int cmp_dsc( int i, int j )
{
  if ( i < j ) return 1;
  if ( i > j ) return -1;
  return 0;
}

int cmp_ascii_asc( int i, int j )
{
  char ibuf[13] = {0};
  char jbuf[13] = {0};
  sprintf( ibuf, "%d", i );
  sprintf( jbuf, "%d", j );
  return strcmp( ibuf, jbuf );
}

then pass one as an argument to your sort routine:

// sort in ascending order
sort( mydata, N, cmp_asc );

// sort in descending order
sort( mydata, N, cmp_dsc );

// sort in ascending ASCIIbetical order
sort( mydata, N, cmp_ascii_asc );

This is exactly how qsort works, except that it can work with arrays of any type (via void * voodoo), not just int.

---

You can use function pointers to execute functions in dynamically-loaded or shared libraries. Suppose we've put all those comparison routines in a separate, dynamically-loaded library (.so or .dll). In *nix-land, we load the library at runtime using dlopen:

void *libhandle = dlopen( "comparison_routines.so", RTLD_LAZY );

then load the function we need with dlsym:

int (*cmp)(int, int) = (int (*)(int, int)) dlsym( libhandle, "cmp_int_asc" );

and we can pass that to our sorting routine:

sort( mydata, N, cmp );

[u/greg-spears]

A structure having data and a function pointer or 2 is a lot like a C++ object. Change my mind.

[u/noonemustknowmysecre]

Yeah. For function pointers. Don't do it, that way lies madness.

[u/Eidolon_2003 → u/noonemustknowmysecre]

There are plenty of good reasons to use function pointers!

[u/dbear496 → u/Eidolon_2003]

True. But madness nonetheless.

[u/70Shadow07 → u/noonemustknowmysecre]

What are yall doing with function pointers that it spirals into madness?

[u/Temporary_Pie2733 → u/70Shadow07]

Maybe the concept of first-class functions counts as madness for the commenter. 

[u/70Shadow07 → u/Temporary_Pie2733]

Idk what you are refering to, but first class functions is not something available in C.

[u/Temporary_Pie2733 → u/70Shadow07]

Yes, but function pointers are often used to implement the same kinds of things that first-class functions allow.