Nsryjdtyk

So I've read the documentation for calloc and it says that it will initialize n objects of size size and initialize each of them to 0.

So before making my implementation of a generic dynamic array in C I decided to make it with int type to make things simpler. I used to call calloc and every integer in the buffer would be initialized as 0 meaning an empty space. But when I changed the data buffer from int *buffer to void **buffer I've been wondering if this properly initializes every void pointer to NULL. I've seen NULL being cast to 0 if you do int a = NULL but does void *p = 0 the same as void *p = NULL? And is this what calloc actually does?

NULL is guaranteed not to point to anything. All calloc does is zero-fill memory after malloc.

"A null pointer is conceptually different from an uninitialized pointer. A null pointer is known not to point to any object or function; an uninitialized pointer might point anywhere. See also questions 1.30, 7.1, and 7.31."

"As mentioned above, there is a null pointer for each pointer type, and the internal values of null pointers for different types may be different. Although programmers need not know the internal values, the compiler must always be informed which type of null pointer is required, so that it can make the distinction if necessary (see questions 5.2, 5.5, and 5.6)."

http://c-faq.com/null/null1.html

First, a note: The standard doesn't actually specify that the NULL pointer is bitwise equal to zero, just that NULL doesn't point to anything. In most implementations, however, NULL is bitwise equal to 0.

void *p = 0 will set p to the pointer consisting on only 0's. While on your machine this might be the same as void *p = NULL, this is not guaranteed by the C standard.

void **buffer = calloc(...) will set each void *p in buffer to 0, which might corresponds to NULL on your machine.

let's look at calloc(3, 4), on a machine where integers and void pointers are both 4 bytes. (Note that integers and void pointers are not always 4 bytes; this is only for demonstrative purposes.) calloc would in this case allocate:

| 00 | 00 | 00 | 00 | 00 | 00 | 00 | 00 | 00 | 00 | 00 | 00 |

and return a pointer to the above memory (the numbers represent the value stored in the memory in hexadecimal).

if we do int *buffer = calloc(3, 4), each 4 bytes of buffer would be an integer with value 0.

if we do void **buffer = calloc(3, 4), each 4 bytes of buffer would instead be a void* pointing to address 0. On machines where NULL is bitwise 0, this would be the same as filling buffer with NULL pointers.