event is a type, not an object or expression. You can't access a member of a structure type, only of an object of a structure type.

So given:

typedef struct {
    void* fn;
    void* param;
} event;

you need to have an object of type event, and you need to assign values to its members.

In your question, you use fn as a member name, but then you refer to something called function. I'll assume here that they're supposed to be the same thing, and that fn is supposed to point to some function.

You can't portably store a function pointer in a void*. On many, probably most, implementations you can get away with it, but it's not guaranteed by the language. (There are systems were function pointers are bigger than data pointers, and converting a function pointer to void* loses information.) On the other hand, all pointer-to-function types are convertible to each other, and a round-trip conversion is guaranteed to give you the original pointer value.

I'll assume (I'm making a lot of assumptions here because you didn't provide a lot of information) that you want fn to point to a function that takes a void* argument and doesn't return a result; then making param a void* makes sense. For consistency with that assumption, we can alter your type definition:

typedef struct {
    void (*fn)(void*);
    void *param;
} event;

(The void (*fn)(void*); syntax is not entirely obvious. I used cdecl to construct it.)

Now you can define an object of type event:

event e = { some_func, NULL };

You have to have defined some_func somewhere, as

void some_func(void *param { /* ... */ }

or equivalent. Now you can call that function indirectly through the event object e:

e.fn(e.param);

Or, if it's more convenient to have a pointer to an event:

event *ptr = malloc(sizeof *ptr);
if (event == NULL) {
    /* error handling here */
}
ptr->fn = some_func;
ptr->param = NULL;

and you can use indirection both on the pointer-to-event and on the function pointer contained in the event object it points to:

ptr->fn(ptr->param);

Depending on what you're trying to accomplish, you might want fn to be able to point to functions of different types. If you do that, you must convert (with an explicit cast) e.fn or ptr->fn to the actual type of the function it points to before making a call through it. You can't blindly mix function pointers of different types; if you do, the result is either a compile-time error or run-time undefined behavior. You can use void (*)(void) (pointer to function with no parameters and returning no result) as a "generic" function pointer type, but unlike with void* any conversions to the type you need must be explicit.)

I want to know how to make the function call both with and without using the additional void* param.

To call a function with no argument, simply use () in the function call. But again, for a given function, you can't choose to call it with or without a parameter; the call has to match the definition. (Except perhaps for variadic functions like printf, but you still need a function pointer of the correct type, and a variadic function can't be called with no arguments.)

Using a void * means that the function can take a pointer that doesn't need to be a specific type. For example, in socket functions, you have

send(void * pData, int nLength)

this means you can call it in many ways, for example

char * data = "blah";
send(data, strlen(data));

POINT p;
p.x = 1;
p.y = 2;
send(&p, sizeof(POINT));

There are a number of problems with the approach:

1) Since the argument array is of type void *, your plan of indexing it based on length will not work—for indexing to work, the length of each element in your array needs to be known as well. You seem to be trying to make a generic function that would work for any type of array, but honestly it's simpler to make a separate function for different types of arrays.

(To see why this is problematic, remember that array[index] is equivalent to *(array + index); by indexing the void * you are applying pointer arithmetic to and then dereferencing the void pointer. Meditate on this.)

2) You are dereferencing a void pointer when you do *randomNum(array, 9). This cannot be done; you need to cast the pointer to an appropriate type first, i.e., *((int *)randomNum(array, 9)), but as I said above, the whole approach with randomNum dealing in void pointers is problematic, so just change the whole thing to:

int *randomNumInt(int *array, size_t length)

The notation

void * (*function)();

means “declare a function pointer named function, which points to a function that takes an unspecified number of arguments, then returns a void *.”

Since this just declares a variable, it doesn’t define a function and so nothing can be said about what value is going to be returned. You’d need to assign this pointer to point to a function before you can call it.

Once you do assign function to point to something, if you call function, you’ll get back a void *, which you can think of as “a pure memory address” since it contains an address but can’t be dereferenced to an object without a cast.

Notice that returning a void * is not the same as as a function that has a void return type. The former means “I return a memory address,” and the latter means “I don’t return anything at all.”