I don't understand clearly what happens when you cast allocated memory through double pointer, as:
char **ptr;
ptr=(char *)malloc(sizeof(char)*value);
for(i=0;i<value;i++)
ptr[i]=(char **)malloc(sizeof(char *)*another_value);
During the first call of malloc, a void * is casted to char * so, i can access it using *(ptr+i), but during the second call of malloc i don't understand why i need to cast void * to char **, would not be enough to cast it to char * ?
It is a good idea to cast the void pointer returned by malloc to the type of the destination pointer. In this case you can find an error similar to the error in your code snippet.
char **ptr;
ptr=(char *)malloc(sizeof(char)*value);
Here variable ptr has type char ** while the right side of the assignment statement has type char * due to the casting. So the compiler shall issue an error (more precisely a diagnostic message) because there is no implicit conversion from char *. to char **
By the way by this reason in C++ there is not allowed to assign a pointer of type void * to pointers of other types because such a code is unsafe.
The other reason to cast the void pointer returned by malloc is to make your code self-documented. Consider for example the following statement
p = malloc( sizeof( *p ) );
Here it is difficult to understand what is the type of memory is allocated. It would be much better to write for example
p = ( double * )malloc( sizeof( *p ) );
In this case the statement is more clear and you need not to scroll a big program listing that to determine what is the type of p.
Take into account that a good program is a program where each statement provides you as much information as you need that to understand what the statement is trying to do and what types of variables envolved in expressions..
There is one more reason to cast the pointer returned by malloc. If you will try to compile your code with a C++ compiler then it will issue numerous errors for each using of malloc without casting. When you will transfer your code from C to C++ you will estimate the value of such casting.
Here is the correct using of malloc for your example
char **ptr;
ptr = ( char ** )malloc( value * sizeof( char * ) );
for ( i = 0; i < value; i++ )
ptr[i] = ( char * )malloc( another_value * sizeof( char ) );
Casting in the above snippet makes no sense. Do not cast return value of malloc. And allocation is wrong too. It should be like:
ptr = malloc(sizeof(char*)*value);
and
ptr[i] = malloc(another_value);
You are doing it wrong.
First of all no need to cast malloc() Please take a look at the changes below.
Since the return type of malloc() is void * no need to cast malloc()
char **ptr = (char **)malloc(sizeof(char *)*another_value);
for(i=0;i<value;i++)
ptr[i]=(char *)malloc(sizeof(char)*value);
Remove cast and have
char **ptr = malloc(sizeof(char *)*another_value);
for(i=0;i<value;i++)
ptr[i]= malloc(sizeof(char)*value);
The right way is
char **ptr;
ptr = malloc(sizeof(char *) * value); // value pointers of char
for(i=0;i<value;i++)
ptr[i] = malloc(sizeof(char)*another_value); // another_value of chars
your code compiled because void * is automatically converted to any pointer type, but if you turn on warnings, the compiler would notify you that you are assigning pointers of incompatible types.
Without the casts however no warning will be issued.
Another thing, sizeof(char) != sizeof(char *) you need value pointers to char and then each pointer will be pointing to another_value array of chars.
So the first call to malloc you have to allocate value * sizeof(pointer), the syntax for that is
value * sizeof(char *)
/* ^ see the star here. */
and then you don't need sizeof(char) since it's 1, the following is correct
char **ptr;
ptr = malloc(sizeof(char *) * value); // value pointers of char
for(i=0;i<value;i++)
ptr[i] = malloc(another_value); // another_value of chars
void *to any pointer type is automatic, your code is wrong, turn on compiler warnings and see. - Iharob Al Asimichar *in the outer loop and an array ofcharin the inner loop. - Rufflewinddouble*. - Keith Thompson