2-D Array with malloc playing tricks

Question

After reading tutorials, I adopted a way to create 2-D array with malloc. But to my surprise, changing allocation code with many variants, gives me the same output.

Consider:

#include<stdio.h>
#include<conio.h>
void main()
{

int **ptr;

int row=3,col=5,i,j;

*ptr=(int **) malloc(sizeof(int *));

for(i=0;i<3;i++)
{

ptr[i]=(int *) malloc(sizeof(int )*col);

}


for(i=0;i<row;i++)
{

for(j=0;j<col;j++)
  {
ptr[i][j]=1;

  }
}


for(i=0;i<row;i++)
{

   for(j=0;j<col;j++)
  {
   printf("val %d",ptr[i][j]);
   free(ptr[i][j]);
  }
printf("\n");
}


free(ptr);

getch();
}

(sorry for an old compiler-turboc 3 , its a compulsion)

when the statement :

*ptr=(int **) malloc(row*col*sizeof(int *));

is changed to

*ptr=(int **) malloc(sizeof(int *));

or to

*ptr=(int *) malloc(sizeof(int *));

or

*ptr=(int ) malloc(sizeof(int *));

or

*ptr=(int **) malloc(row*sizeof(int *));

....

GIVES me the same output, that is an array of 3*4 with all 1's.

Why is is so?

Answer 1

Malloc allocate a space defined by the size you give to. But when you copy some charracters if there is enought place on the RAM it will works even if you specified a smaller size than the string you wanted to copy. In the other case, it will print random characters, or Glibc - memory corrupted. So even if all these malloc definitions works, maybe it works on your computer "for the moment". But on an other and in other case it won't at all. Moreover Glibc is dangerous.

Answer 2

In an attempt to be a litte bit more efficient, malloc typically assigns a "minimum block of space". This might be 16 bytes, or more - depending on the compiler. I think you are "accidentally" getting a big enough block - capable of seeing 12 ints - without getting a error. But your code is highly suspect and liable to break at any time.

As @H2CO3 pointed out - don't cast the return value of malloc: if your compiler is complaining you didn't include the right headers. Always heed your compiler's warnings - but address them in the right way...

Note - it's not the malloc that gives you the array of ones - that's the job of the loop that follows. malloc sets aside some space. If it sets aside enough space you won't run into a segfault. It does nothing to affect how the compiler considers that piece of memory subsequently. In other words - malloc does not know what it returns (which is why the type is actually void* and you should not cast it).

EDIT you were asking about the different casting you did. A cast does not change the VALUE, just the TYPE (as long as the value can be represented with the new type). Thus, when you say

int* p;
p = (int **)malloc(4);

you are not turning p into a int** - its type was defined by the first line. You will (or should) get some compiler warnings...