Question

Here is a little snippet of code from Wikipedia’s article on malloc():

    int *ptr;
    ptr = malloc(10 * sizeof (*ptr)); // Without a cast
    ptr = (int*)malloc(10 * sizeof (int)); // With a cast

I was wondering if someone could help me understand what is going on here. So, from what I know, it seems like this is what’s happening:

1) initialize an integer pointer that points to NULL. It is a pointer so its size is 4-bytes. Dereferencing this pointer will return the value NULL.

2) Since C allows for this type of automatic casting, it is safe not to include a cast-to-int-pointer. I am having trouble deciphering what exactly is being fed into the malloc function though (and why). It seems like we are getting the size of the dereferenced value of ptr. But isn’t this NULL? So the size of NULL is 0, right? And why are we multiplying by 10??

3) The last line is just the same thing as above, except that a cast is explicitly declared. (cast from void pointer to int pointer).

Answer 1

I’m assuming we’re talking about C here. The answer is different for C++.

1) is entirely off. ptr is a pointer to an int, that’s all. It’s uninitialized, so it has no deterministic value. Dereferencing it is undefined behaviour — you will most certainly not get 0 out! The pointer also will most likely not point to 0. The size of ptr is sizeof(ptr), or sizeof(int*); nothing else. (At best you know that this is no larger than sizeof(void*).)

2/3) In C, never cast the result of malloc: int * p = malloc(sizeof(int) * 10);. The code allocates enough memory for 10 integers, i.e. 10 times the size of a single integer; the return value of the call is a pointer to that memory.