Is there a way to make a single function operate on different structures (having common members) in c

Question

After passing a void* pointer as argument to a function, is there a way to specify the type to which it is cast as another parameter. If I have two structs like:

struct A{
  int key;
  char c;
}

struct B { 
  int key;
  float d;
}

Is it possible to define a function,

void func(void * ptr, ...){
//operate on key
}

and pass a pointer to either structs to the function after casting to void* and access the key element from within the function.

Trying to understand the use of void*, how structure definitions are stored ( How are the offsets of various elements determined from the structure definition? ) and how ploymorphism may be implemented in c.

Was trying to see if I could write Binary Search tree functions that could deal with nodes of any struct.

Answer 1

After passing a void* pointer as argument to a function, is there a way to specify the type to which it is cast as another parameter.

Yes and no.

I suppose you're hoping for something specific to this purpose, such as a variable that conveys a type name that the function can somehow use to perform the cast. Something along the lines of a type parameter in a C++ template, or a Java generic method, for example. C does not have any such thing.

But of course, you can use an ordinary integer to convey a code representing which of several known-in-advance types to cast to. If you like, you can even use an enum to give those codes meaningful names. For example:

enum arg_type { STRUCT_A_TYPE, STRUCT_B_TYPE };

void func(void *ptr, enum arg_type type) {
    int key = 0;

    switch (type) {
        case STRUCT_A_TYPE:
            key = ((struct A *) ptr)->key;
            break;
        case STRUCT_B_TYPE:
            key = ((struct B *) ptr)->key;
            break;
        default:
            assert(0);
    }
    // ...
}

Note well that that approach allows accessing any member of the pointed-to structure, but if you only want to access the first member, and it has the same type in every structure type of interest, then you don't need to know the specific structure type. In that particular case, you can cast directly to the member type:

void func(void *ptr) {
    int key = *(int *)ptr;
    // ...
}

That relies on C's guarantee that a pointer to any structure, suitably cast, points to that structure's first member.

Trying to understand the use of void*, how structure definitions are store and how ploymorphism may be implemented in c.

That's awfully broad.

C does not offer polymorphism as a language feature, and C objects do not carry information about their type such as could be used to dispatch type-specific functions. You can, of course, implement that yourself, but it is non-trivial. Available approaches include, but are not limited to,

• passing pointers to functions that do the right thing for the type of your data. The standard qsort() and bsearch() functions are the canonical examples of this approach.

• putting some kind of descriptor object as the first member of every (structure) type. The type of that member can be a structure type itself, so it can convey arbitrarily complex data. Such as a vtable. As long as it is the first member of all your polymorphic structures, you can always access it from a pointer to one of them by casting to its type, as discussed above.

• Using tagged unions of groups of polymorphic types (requiring that all the type alternatives in each group be known at build time). C then allows you to look at any members of the common initial sequence of all union members without knowing which member actually has a value. That initial sequence would ordinarily include the tag, so that you don't have to pass it separately, but it might include other information as well.

• Polymorphism via (single-)inheritance can be implemented by giving each child type an object of its parent type as its first member. That then allows you to cast to (a pointer to) any supertype and get the right thing.

Answer 2

Lets say you had a sort function that takes a function as a parameter which implements the "compare" functionality of the sort. The sort would then be capable of sorting a list of any arbitrary struct, by handing it a comparer function that implements the correct order for your particular struct.

void bubbleSort(Node* start, bool comparerFunction(void* a, void* b))

Consider the following struct definition:

typedef struct {
   int  book_id;
   char title[50];
   char author[50];
   char subject[100];
   char ISBN[13];
} Book;

And this unremarkable linked list definition:

typedef struct node{
  void* item;
  struct node* next;
} Node;

Which can store an arbitrary struct in the item member.

Because you know the type of the members you've placed in your linked list, you can write a comparer function that will do the right thing:

bool sortByTitle(void* left, void* right) {
  Book* a = (Book*)left;
  Book* b = (Book*)right;
 
  return strcmp(a->title, b->title) > 0;
}

And then call your sort like this:

bubbleSort(myList, sortByTitle);

---

For completeness, here is the bubbleSort implementation:

/* Bubble sort the given linked list */
void bubbleSort(Node *start, bool greaterThan(void* a, void* b)) 
{ 
    int swapped, i; 
    Node* ptr1; 
    Node* lptr = NULL; 

    /* Checking for empty list */
    if (start == NULL) 
        return; 

    do
    { 
        swapped = 0; 
        ptr1 = start; 

        while (ptr1->next != lptr) 
        { 
            if (greaterThan(ptr1->item, ptr1->next->item))
            { 
                swap(ptr1, ptr1->next); 
                swapped = 1; 
            } 
            ptr1 = ptr1->next; 
        } 
        lptr = ptr1; 
    } 
    while (swapped); 
} 

/* function to swap data of two nodes a and b*/
void swap(Node *a, Node *b) 
{ 
    void* temp = a->item; 
    a->item = b->item; 
    b->item = temp; 
}