void* 指针指向的调用函数

Question

I have an event struct that looks like this

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

How can I call this function by pointer as part of the struct. For example, these do not work:

event->(*function)();
event->function();
(*event->function)();

I want to know how to make the function call both with and without using the additional void* param. I was originally using this link as a reference:

http://www.cprogramming.com/tutorial/function-pointers.html

I've used these function pointers before, but have trouble getting the syntax correct.

Answer 1

You need to cast void* pointer to the function pointer first:

#include <stdio.h>

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

void print()
{
        printf("Hello\n");
}


int main()
{
    event e;
        e.fn = print;
        ((void(*)())e.fn)();
        return 0;
}

Of course, if this is really what you want. If you want your struct to contain pointer to the function, instead of void* pointer, use the proper type at the declaration:

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

Here you have fn declared as a pointer to the void function, and the param as void* pointer.

Answer 2

If I understood correctly, you're probably looking for this:

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


event *E;

E->fn();
E->param();

Answer 3

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.)

Answer 4

What you are trying to do is not possible in a valid C program that does not cause undefined behavior (UB). void * can point to a valid objects, one byte after the last object of an array or to NULL , but functions are not objects. What you can do is converting between different pointer to function. But please keep in mind that you have to cast the function pointer back to the right type before you call the function pointer. Calling a function pointer that points to a function with a different type causes UB.

Many embedded platforms have separate storage for functions and the functions are not loaded into RAM, there a pointer to void * is often smaller than a pointer to function. On Posix compatible platforms you can convert pointers to function to void * and back, without causing UB. But that is a Posix extension and required for functions like dlsym() , it is not part of C.