void* type to char* type leadng - c

Question

The man has the code
#include <conio.h>
#include <stdio.h>
void dbleInt(void *a) {
*((int*) a) *= 2;
}
void deleteEvenInt(void* a) {
int tmp = *((int*) a);
if (tmp % 2 == 0) {
*((int*) a) = 0;
}
}
void dbleDouble(void *a) {
*((double*) a) *= 2.0;
}
void deleteEvenDouble(void* a) {
int tmp = *((double*) a);
if (tmp % 2 == 0) {
*((double*) a) = 0;
}
}
// Function takes an array, its size, the size of one element and a function //pointer,
// Which is then applied to all the elements of an array
void map(void *arr, unsigned num, size_t size, void (*fun)(void *)) {
unsigned i;
char *ptr = (char*) arr;
for (i = 0; i < num; i++) {
fun((void*) (ptr + i*size));
}
}
Why does he leads void* type to char* type? I can see thats it an error, when I change this code and dont lead it, but why?

Answer 1

You're not allowed to perform arithmetic on void pointers in C. So the following code is illegal:
void *foo = whatever;
foo + 1;
By casting foo to a char *, she can perform arithmetic on the pointer.

Answer 2

My comments are on why void *ptr, one cannot perform address arithmetic. Warning , Long rambling :).
In general
when you do a ptr arithmetic like
ptr = ptr + N ;
The interpretation by C is to perform the following equivalent integer arithmetic (Infact the compiler will produce assembly code equivalent to below integer arithmetic)
ptr = ptr + N* sizeof (typeof(*N)) ;
Hence The compiler has to know the typeof (*N) for it to produce code. typeof (*N) here means, the type of variable "ptr" points to. (typeof is not a standard c construct, it is being bought here for mere explanation).
Take an e.g.
int x ; // Assume x is at addesss 1000
int *ptr = &x ; // ptr has a value of 1000
Then
ptr = ptr + 1 ;
would make ptr as 1004 during run time (assuming size of int is 4 bytes)
Explanation-1: The above statement means that ptr should contain the address of next integer variable after ptr. Since ptr points to x , which is at address 1000, the next integer variable after 1000 would be 1004. So ptr would be 1004.
Explanation-2 This is also in sync with the interpretation of ptr = ptr +N is equivalent to integer arithmeitc
ptr = ptr + N* sizeof (typeof(*N)) ; // typeof (*N)->int
// => 1000 + 1 *sizeof (typeof (int))
// => 1004
To summarize For the ptr arith operation
ptr = ptr + N ;
the compiler produces an equivalent assembly code as
ptr = ptr + N* sizeof (typeof(*N)) // Compiler Needs to typeof(*N)
Hence the compiler needs to know what is the data-type that ptr is pointing to.
Now consider
void foo (int type, void *ptr) {
ptr = ptr + 2 ;
}
f2() {
int x ;
char c ;
f1(&x) ;
f1(&c);
}
The void * ptr is a generic ptr pointing to an addresss. When called with f1(&x) the ptr points to an address of integer, when called with f1(&c) it points to address of a character. So at compile time , compiler cannot determine what is the typeof (*ptr). (for in one case it is integer and another is character). Hence it is not possible for the compiler to generate code for
ptr = ptr + n ;
So you will have to cast the ptr of being a particular known type and then do arithmetic operation.
Hope this helps.