具有通用指针参数的函数指针

Question

I have an data structure that stores a generic void * for each node which gets casted to the correct type at the appropriate time. In the cleanup function for this object, I would then like to provide a callback so that this generic object can too be "cleaned up."

struct foo {
    void *data;
    // ...
};

void foo_cleanup(struct foo *foo, void (*data_cleanup)(void *data)) {
    data_cleanup(foo->data);
    // ...
}

// ...

void bar_cleanup(void *data) {
    struct bar *bar = (struct bar *)data;
    // ...
}

This works fine, however I would prefer if the signature of bar_cleanup referred to bar directly, rather than void * :

void bar_cleanup(struct bar *bar)

Of course, replacing that code as is creates "parameter type mismatch" warnings. Is there any way to achieve directly what I am trying to do, if not a similar method of achieving the same cleanup task?

Answer 1

What you are doing now is the correct way to deal with it. Your desire to use pointers to cleanup functions with a specific type runs foul of the (strict) rules in C11 (and C99, and probably C90 though I've not formally checked C90).

[§6.3] Conversions

§6.3.2.3 Pointers

¶8 A pointer to a function of one type may be converted to a pointer to a function of another type and back again; the result shall compare equal to the original pointer. If a converted pointer is used to call a function whose type is not compatible with the referenced type, the behavior is undefined.

---

Your existing code is:

struct foo {
    void *data;
    // ...
};

void foo_cleanup(struct foo *foo, void (*data_cleanup)(void *data)) {
    data_cleanup(foo->data);
    // ...
}

void bar_cleanup(void *data) {
    struct bar *bar = (struct bar *)data;
    // ...
}

This code is clean and obeys the rules. The pointer to the bar cleanup function has the signature void (*)(void *) which matches the pointer used by foo_cleanup() . The cast in bar_cleanup() is optional but explicit. Even if you omit the cast notation, that conversion will occur as C automatically converts from void * to struct bar * .

If you try to use the cleanup function:

void bar_cleanup(struct bar *bar);

you would have to make a call equivalent to:

struct foo foo37;
…code initializing foo37…
foo_cleanup(&foo37, (void (*)(void *))bar_cleanup);

This coerces the type of the function to a different pointer type. Unless the code inside foo_cleanup() knows somehow (how?) that the pointer needs to use function with the signature void (*)(struct bar *) and changes it before calling the cleanup function, it runs afoul of the rule in §6.3.2.3.

foo_cleanup(struct foo *foo, void (*data_cleanup)(void *data))
{
    (*data_cleanup)(foo->data);    // Undefined behaviour
    if (data->…)
        (*(void (*)(struct bar *))data_cleanup)(foo->data);  // OK, but…
    …
}

The unconditional call is wrong because the types of the real function pointer and the one claimed by the parameter type are different. The conditional call is clean because it casts the pointer back to its real type before calling the function. (This is C; the conversion from void * to struct bar * is automatic and valid.) . However, having to know what to convert the pointer-to-function to in the foo_cleanup() function defeats the purpose of using a pointer-to-function in the first place. It also isn't clear how foo_cleanup() does determine which cast is correct, and if you add a new type, you have to change the code again to support the new type.

All of this means that a solution using void bar_cleanup(struct bar *bar) is not really acceptable.

If you follow the strict rules laid down by the standard and still want to call void bar_cleanup(struct bar *) , you have to write gruesome, non-maintainable, inflexible code.

If you want absolutely reliable code, you will follow these rules and keep your existing code ( void bar_cleanup(void *data) ). It has the beneficial side-effect of avoiding painful casts — function pointer casts are not pretty — and leaves the foo_cleanup() function unchanged regardless of how many different pointer types are stored in the data member of struct foo as long as the calling code knows which is the correct type (and if the calling code doesn't know, it's a case of "Abandon Hope All Ye Who Enter Here" anyway).

In practice, how serious a problem is this? Actually, you'll probably get away with it at the moment. But it is invoking undefined behaviour and compilers are ever eager to identify and exploit undefined behaviour to 'optimize' the code they generate. You can do as you want without the cast in foo_cleanup() , but you are taking risks which can be simply and painlessly avoided by keeping your current code.

Note that this applies to comparator functions passed to qsort() or bsearch() in the standard library. Those functions should be written to take two const void * parameters and return an int . Doing otherwise runs foul of §6.3.2.3. There are examples in otherwise respected C books that do not keep to these strict rules.

Answer 2

typedef void (*CLEANUP_FUNC)(void *);

void foo_cleanup(struct foo *foo, CLEANUP_FUNC *data_cleanup) {
    data_cleanup(foo->data);
    // ...
}

void bar_cleanup(struct bar *data) {
    // ...
}

foo_cleanup(foo, (CLEANUP_FUNC *)bar_cleanup);

---

The following is a full example featuring generic stack Stack and some elements of type Foo .

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

// ---

typedef void (STACK_DEALLOCATOR)(void *);

typedef struct Stack {
   STACK_DEALLOCATOR *element_deallocator;
   size_t num_elements;
   size_t num_allocated;
   void **elements;
} Stack;

Stack *Stack_New(STACK_DEALLOCATOR *element_deallocator) {
   Stack *this = malloc(sizeof(Stack));
   if (this == NULL)
      goto ERROR;

   this->element_deallocator = element_deallocator;
   this->num_elements = 0;
   this->num_allocated = 4;

   this->elements = malloc(sizeof(void *) * this->num_allocated);
   if (this->elements == NULL)
      goto ERROR2;

   return this;

   ERROR2: free(this);
   ERROR:  return NULL;
}

int Stack_Push(Stack *this, void *element) {
   if (this->num_elements == this->num_allocated) {
      // ...
   }

   this->elements[ this->num_elements++ ] = element;
   return 1;
}

void Stack_Destroy(Stack *this) {
   void **element = this->elements;
   for (size_t i=this->num_elements; i--; ) {
      this->element_deallocator(*(element++));
   }

   free(this->elements);
   free(this);
}

// ---

typedef struct Foo {
   int data;
   // ....
} Foo;


Foo *Foo_New(int data) {
   Foo *this = malloc(sizeof(Foo));
   if (this == NULL)
      return NULL;

   this->data = data;
   return this;
}

void Foo_Destroy(Foo *this) {
   free(this);
}

// ---

int main(void) {
   Stack *stack = Stack_New((STACK_DEALLOCATOR *)Foo_Destroy);
   if (stack == NULL) {
      perror("Stack_New");
      goto ERROR;
   }

   Foo *foo = Foo_New(123);
   if (foo == NULL) {
      perror("Foo_New");
      goto ERROR2;
   }

   if (!Stack_Push(stack, foo)) {
      perror("Stack_Push");
      goto ERROR3;
   }

   Stack_Destroy(stack);
   return 0;

   ERROR3: Foo_Destroy(foo);
   ERROR2: Stack_Destroy(stack);
   ERROR:  return 1;
}