How Do I Declare a Function Pointer in C?

I'm not afraid to admit: I need tools. I need lots and lots of tools to do my job. The more the computer can be used to make my job easier, the better. There is no virtue in hard work for hard work's sake.

Specifically he's talking about typedef'ing structs to a named type to hide that it's a struct. That's different from typedef'ing a function pointer so that you don't need to be a C parsing expert to read the code.

For instance if you need to add an extra parameter, you can easily find all usages. If something else uses the same definition, but is used for a different purpose, it gets much harder to distinguish the different usages. especially for a good ol void (callback)(void context) which a number of event's may use, and then later some may callback with more information which can be changed in once place and the compiler will quickly show you what breaks.

  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.

Do you remember where you picked this up? Any particular book or codebase?

Given that, what's the advantage for "your version" of the idiom?

(This may just be nitpicking.)

And it works with C Blocks!

    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;
    }

For example, if you typedef a callback type like so:

  typedef int callback_t(int foo);

  callback_t my_callback;

  int my_callback(int foo) {
    ...
  }

Edit: The downside is that function declarations done this way will look a little odd--possibly mistaken for a variable definition. And, upon further thought, I'm not sure that this pattern really is a huge benefit since function pointer assignment will also produce an error if the signatures don't match. But interesting nonetheless, I guess.

More specifically, std::function's operator() is virtual, and calls into a subclass that's specialized to function pointers of type void(int). The subclass then performs the actual function pointer call.

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

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

(fixed formatting?)

  int* p; // p is an int pointer

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

http://goshdarnfunctionpointers.com is a more work-friendly mirror.

which states:

Unable to access this site due to the profanity in the URL?

http://goshdarnfunctionpointers.com is a more work-friendly mirror.

which is a possibly an offending link to itself. But, there is also possibly the more benignly named:

http://functionpointers.com/

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

[1] http://eli.thegreenplace.net/2007/11/24/the-context-sensitiv...

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

Pairs nicely with std::bind, too, like so:

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