How Do I Declare a Function Pointer in C?(fuckingfunctionpointers.com)

    a (b);      /* function call or declaration */
    a * b;      /* multiplication or declaration */
    f((a) * b); /* multiplication or deref and cast */

    typedef int *(**fn_t[][2])(void);

    typedef int *(**fn_t[2][])(void);

  int* p; // p is an int pointer

  int *p; // dereferencing p will give an int

  auto greet = std::mem_fn(&Foo::display_greeting);

  Foo foo;
  std::function<void(int)> setter = std::bind(&Foo::setValue, &foo, std::placeholders::_1);
  setter(42);

    typedef int IntegerProcessor(int);

    int executeTheFunctionPointer(IntegerProcessor* function)
    {
        return function(23);
    }

    int executeTheBlock(IntegerProcessor^ block)
    {
        return block(32);
    }

    int doubler(int a)
    {
        return a * 2;
    }

    int main(int argc, const char * argv[])
    {
        IntegerProcessor* myFunctionPtr = &doubler;

        int a = executeTheFunctionPointer(myFunctionPtr);
        printf("%d\n", a); // 46

        IntegerProcessor^ myBlock = ^(int b) {
            return a * b;
        };

        a = executeTheBlock(myBlock);
        printf("%d\n", a); // 1472

        return 0;
    }

  typedef int callback_t(int foo);

  callback_t my_callback;

  int my_callback(int foo) {
    ...
  }

  And as mentioned, there _are_ exceptions. Some types just get _sooo_
  complex that it's inconvenient to type them out, even if they are
  perfectly regular types, and don't depend on any config option. The
  "filldir_t" typedef in fs.h is such an example - it's not really opaque,
  _nor_ is it a config option, but it sure as hell would be inconvenient for
  all low-level filesystems to do
  
    int my_readdir(struct file *filp, void *dirent,
        int (*filldir)(void *, const char *, int, loff_t,
        u64, unsigned))
    {
        ...
    }
  
  because let's face it, having to write out that "filldir" type just made
  me use two lines (and potential for totally unnecessary tupos) because the
  thing was so complex. So at that point, using a typedef is just common
  sense, and we can do
  
  	int my_readdir(struct file *filp, void *dirent, filldir_t filldir)
  	{
  		...
  	}
  
  instead.
  
  But it's really quite hard to make that kind of complex type in C. It's
  almost always a function pointer that takes complex arguments.