Passing a pointer to a1 to your function, you can't change where a1 points. The pointer is passed by value, so in f1 you're only changing a copy of the address held by a. If you want to change the pointer, i.e. allocate new memory for the pointer passed in, then you'll need to pass a pointer to a pointer:

void f1(void **a)
{
    // ...
    *a = malloc(sizeof(int));
    // ...

How can I pass void pointer to function in C?

You already are, so that's not your problem.

I am writing about this line which is inside sort function:

comp_double((void *)(ptr + j), (void *)(ptr + j + 1))

OK, it's not passing void* you're having trouble with, but doing pointer arithmetic on it.

The reason is that there's no type associated with void*, so the compiler doesn't know how many bytes ptr+1 should be advanced. If you were using char *ptr, it would be one byte. For double* ptr it would be sizeof(double) bytes, etc.

Since we can't cast ptr to the correct type (it can be different on each call, which is what makes the function reusable), we have to do this pointer arithmetic manually instead:

char *base = (char *)ptr;
...
comp_double(base + j*sizeof_element, base + (j + 1)*sizeof_element);

Notes:

1. the pointer argument can be implicitly cast back to void*, there's no need to do it explicitly
2. any pointer T* such that sizeof(T)==1 will work correctly: char is kind of traditional, uint8 is also fine

Most platforms will in fact allow you to pass a function pointer as a void *, but it's not theoretically allowed. Code might have different pointers to data. You also cannot pass a const-qualified address to a void *.

You need to modify the pointer, not the ponted to data. So you must pass a pointer to the pointer, like this

void f1(void **a)
 {
    int *b;
    b = malloc(sizeof(*b));

    printf("b address = %p \n", b);
    if (b != NULL)
     {
        b[0] = 3;
        printf("data = %d\n", *(int *) b);
     }
    *a = b;
 }

The way you do it, the pointer inside f1 is a copy of the passed pointer, they both contain the same initial value NULL, the value you used in f() to initialize a1, but you alter the value of the local pointer only.

You then dereference a1 which is still NULL, and dereferencing a NULL pointer, causes undefined behavior. In your case the behavior is that a segmentation fault happens.

So as per @charles-srstka suggestion I rewrote the code and then it worked as I wanted

#include<stdio.h>
#include<stdlib.h>


int* int_add(int *x, int *y) {
    int *c = (int *)malloc(sizeof(int));
    *c = *(int*)x + *(int*)y;
    return c;
}

float* float_add(float *x, float *y) {
    float *c = (float*)malloc(sizeof(float));
    *c = *(float*)x + *(float*)y;
    return c;
}

void* do_operation(void* (*op)(void*, void*), void* x, void* y) {
    return op(x, y);
}

void main(void) {

    int a = 1;
    int b = 2;                                               
    int *c;
    c = do_operation(int_add, &a, &b);
    printf("%d\n",*c);
    free(c);

    float x = 1.1;                                               
    float y = 2.2;                                               
    float *z;
    z = do_operation(float_add, &x, &y);
    printf("%f\n",*z);
    free(z);
}

First of all: A function pointer refers to a function only. Parameters come into the game when the function is called, either directly or via a function pointer.

So if you want to achieve what you have in mind, that is binding a (set of) parameters to a specific function varaible you need to use a wrapper function:

int func1(char * pc)
{
  int i;
  /* assigne somehting to "i" and use "pc" */
  return i;
}

int func1_abcd(void)
{
  return func1("abcd")
}

int func1_xyz(void)
{
  return func1("xyz")
}

typedef int (*pfunc1_wrapper_t)(void);

int func2(pfunc1_wrapper_t pfunc1_wrapper)
{
  return pfunc1_wrapper();
}

int main(int argc, char ** argv)
{
  pfunc1_wrapper_t pfunc1_wrapper = NULL;
  int i = 0;

  pfunc1_wrapper = func1_abcd;
  i = func2(pfunc1_wrapper);

  pfunc1_wrapper = func1_xyz;
  i = func2(pfunc1_wrapper);

  ...

  return 0;
}

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

You dereference a non-pointer value. This is the report. I copied the error message as the follow.

=========== Start of #0 stensal runtime message ===========

Runtime error: [dereferencing a non-pointer] Continuing execution can cause undefined behavior, abort!

-
- Reading 4 bytes from an illegit address (0x6).
-
- Stack trace (most recent call first) of the read.
- [0]  file:/prog.c::23, 20
- [1]  [libc-start-main]
-

============ End of #0 stensal runtime message ============