We are creating a type definition. So the line that says

typedef void (*HeyBuddyPrt) ();

Is basically stating that we are creating a label that will represent a function pointer. Think of this line as saying:

I want to create a label that will act like a datatype. This label will be called HeyBuddyPtr. The HeyBuddyPtr datatype (or TypeDef) will be able to store a pointer to a function that takes no params and returns void.

Try not to over think this... All we are doing is creating a label that represents a pointer to a function that takes no params and returns void. This is really no different than using a typedef for structs like in our C class:

Here is a struct:

struct MyStruct
{
  int x;
};

To declare this in C code I need to do this:

struct MyStruct s;

I can use a typedef to create a label that will represent the struct, so I can rewrite my struct like this:

typedef struct
{
  int x;
} MyStruct;

This allows me to declare the struct like this:

MyStruct s;

You see, by using typedef the label MyStruct can represent a struct that contains an integer called 'x'. You can even use easier examples such as:

typdef int INTEGER;
// Now if I use INTEGER it will represent an int
INTEGER x = 99; // same as int x = 99;

typedef float FLOAT;
// Now if I use FLOAT it will represent a float
FLOAT f = 0.1f; // same as float f = 0.1f;

typedef char* STRING;
STRING s = "Hey Buddy!"; // same as char* s = "Hey Buddy";

I am not sure if that cleared things up, but I will continue anyways.

OK, so now that we have created our typedef (which simply represents a function pointer that takes no params and returns void) I can create a variable that can represend one:

HeyBuddyPrt HeyBuddy;

Later in this code example we are referencing a function that loads a function from a DLL (that takes no params and returns void) and the variable HeyBuddy can be called like a function:

HeyBuddy();

Thanks, Kevin.  I think I'm good on typedef with structs and primitive datatypes, but the function pointer syntax is a little different, isn't it?  For the others, it was:

typdef int INTEGER;

typedef <stuff> <label>;

When creating typedef for a function pointer, it was:

typedef void (*HeyBuddyPtr) ();

Does that follow the same pattern?  

typedef <return type> <name> <params>;

Where, later in the program, you can use it as a datatype...:

HeyBuddyPtr HeyBuddy;

I think I get it.  Here's my question:  In the main function, we use it like this:

HINSTANCE HeyBuddyLib = LoadLibrary("HeyBuddy.dll");

HeyBuddy = (HeyBuddyPrt)GetProcAddress(HeyBuddyLib, "HeyBuddy");

How would you do this without using typedef?  

Ahh.. okay, interesting.  So in the case of a function pointer, typedef isn't really creating some label to stuff, it's just defining it to be treated as a datatype?  So when we say "HeyBuddyPtr HeyBuddy;", are we essentially creating an instance of the HeyBuddyPtr called HeyBuddy?  I noticed you could also do it this way:

#include <stdio.h>

#include <windows.h>

void (*HeyBuddyPrt)();

int main()

{

//Points to a resource

HINSTANCE HeyBuddyLib = LoadLibrary("HeyBuddy.dll");

HeyBuddyPrt = GetProcAddress(HeyBuddyLib, "HeyBuddy");

HeyBuddyPrt();

FreeLibrary(HeyBuddyLib);

return 0;

}

It works, but gives me a warning on the "HeyBuddyPrt();" line.  In what way exactly is using typedef more efficient -- does it let you create multiple void, no-param functions if you have more than one?  

I would like to ask how