Question

I have an incr function to increment the value by 1
I want to make it generic,because I don’t want to make different functions for the same functionality.

Suppose I want to increment int,float,char by 1

void incr(void *vp)
{
        (*vp)++;
}

But the problem I know is Dereferencing a void pointer is undefined behaviour. Sometimes It may give error :Invalid use of void expression.

My main funciton is :

int main()
{

int i=5;
float f=5.6f;
char c='a';

incr(&i);
incr(&f);
incr(&c);

return 0;
}

The problem is how to solve this ? Is there a way to solve it in Conly

or

will I have to define incr() for each datatypes ? if yes, then what’s the use of void *

Same problem with the swap() and sort() .I want to swap and sort all kinds of data types with same function.

Answer 1

You can implement the first as a macro:

#define incr(x) (++(x))

Of course, this can have unpleasant side effects if you’re not careful. It’s about the only method C provides for applying the same operation to any of a variety of types though. In particular, since the macro is implemented using text substitution, by the time the compiler sees it, you just have the literal code ++whatever;, and it can apply ++ properly for the type of item you’ve provided. With a pointer to void, you don’t know much (if anything) about the actual type, so you can’t do much direct manipulation on that data).

void * is normally used when the function in question doesn’t really need to know the exact type of the data involved. In some cases (e.g., qsort) it uses a callback function to avoid having to know any details of the data.

Since it does both sort and swap, let’s look at qsort in a little more detail. Its signature is:

void qsort(void *base, size_t nmemb, size_t size,
           int(*cmp)(void const *, void const *));

So, the first is the void * you asked about — a pointer to the data to be sorted. The second tells qsort the number of elements in the array. The third, the size of each element in the array. The last is a pointer to a function that can compare individual items, so qsort doesn’t need to know how to do that. For example, somewhere inside qsort will be some code something like:

// if (base[j] < base[i]) ...
if (cmp((char *)base+i, (char *)base+j) == -1)

Likewise, to swap two items, it’ll normally have a local array for temporary storage. It’ll then copy bytes from array[i] to its temp, then from array[j] to array[i] and finally from temp to array[j]:

char temp[size];

memcpy(temp, (char *)base+i, size);              // temp = base[i]
memcpy((char *)base+i, (char *)base+j, size);    // base[i] = base[j]
memcpy((char *)base+j, temp, size);              // base[j] = temp