What is this line of code really doing?

Question

Assuming "structName" is a defined struct:

structName ** sarray = (structName **) malloc(0 * sizeof(structName *));

I know its creating a pointer to a struct pointer called sarray, but why is there (structName **) placed at the start of the expression? Also, why is the struct size multiplied by 0 in the malloc call?

The source of the code is here

My guess is that the `0` is a hard-coded magic number and that your predecessor once had it as a non-zero value. The `(structName **)` is a type-cast. EDIT: It looks like the array is supposed to grow using `realloc`, but starts as `0` sized. The `sizeof(structName *)` is probably just included because its good practice. — aebabis, Oct 06 '14 at 23:32
The code is starting off allocating a zero-sized block (or attempting to allocate one) for an array that will expand as needed. This is valid, but anyone doing something like this needs to take some care - `malloc()` is specified in such a way that it can return `NULL` or an address to a zero-sized block of memory. In the case of the example code, that's OK because `realloc()` will behave fine when expanding a zero-sized block or a NULL pointer. — Michael Burr, Oct 06 '14 at 23:34
Q: What is this line of code really doing? Short Answer: Nothing useful. Longer answer: 1) I'd defer `malloc()` until I had a nonzero value to allocate, and 2) I'd general prefer the form `malloc (sizeof structName);`, rather than pointer-to-pointer (**). — FoggyDay, Oct 06 '14 at 23:42

score 2 · Accepted Answer · answered Oct 06 '14 at 23:34

malloc returns void *. The pointer sarray is of type structName **. The (structName **) is a type cast, converting void * to structName **. Pointers are very malleable in C; malloc will always return something that can safely be cast to any kind of pointer. In this case you have a pointer to structName *.

Multiplying sizeof(structName *) by 0 does what you think, asking malloc for a zero-length chunk of memory. I suspect the sizeof is in there because the author considers it the standard pattern. You could remove it without consequence and just supply 0. Given that realloc works with a NULL argument you could also just initialise sarray to NULL.

For the record, for malloc:

If the size of the space requested is zero, the behavior is implementation- defined: either a null pointer is returned, or the behavior is as if the size were some nonzero value, except that the returned pointer shall not be used to access an object.

So that initial call may or may not return NULL, with essentially identical results: accessing anything via the pointer shall have undefined results.

score 1 · Answer 2 · answered Oct 06 '14 at 23:41

The reason for the (structName **) is to convert the return value of malloc() from void * to (structName **), so the assignment to sarray doesn't produce an incompatible type error.

The reason for the multiplication by zero is compatibility with the statement that follows:

long sarray_len = 0;

If the example had chosen to start with

long sarray_len = initialCount;

instead, then the malloc would have to be

structName ** sarray = (structName **) malloc(initialCount * sizeof(structName *));

.

score 0 · Answer 3 · answered Oct 06 '14 at 23:35

The malloc function returns a pointer of type (void *). The (structName **) casts that pointer into type (structName **). This cast is not required in C. He multiplies by 0 because he don't want to allocate any struct yet, and waits for reallocation later.

score 0 · Answer 4 · edited May 23 '17 at 11:49

0

Why is there (structName **) placed at the start of the expression?

It's called type casting. malloc returns a void * which is cast to structName ** so that it can be assigned to sarray.

Also, why is the struct size multiplied by 0 in the malloc call?

The code pattern malloc(size * sizeof(datatype)) is generally followed everywhere, hence the multiplication was used there, IMO.

edited May 23 '17 at 11:49

Community

1
1

answered Oct 06 '14 at 23:36

John Bupit

10,406
8
39
75

score 0 · Answer 5 · answered Oct 06 '14 at 23:36

0

structName ** sarray = (structName **) malloc(0 * sizeof(structName *));

is equivalent to :

structName ** sarray = NULL;

answered Oct 06 '14 at 23:36

Farouq Jouti

1,657
9
15

score 0 · Answer 6 · edited May 23 '17 at 12:20

The (structName **) before malloc is a mistake. It was required in the 1970s, but has been a mistake since 1989. Many people didn't update their learning materials since 1989 ;-)

At best it is redundant text (and redundant text should usually be avoided as it makes the important text harder to read), and at worst it can hide an error. For further reading on that topic see this thread.

Regarding the second part, 0 * sizeof(structName *) . This is of course 0 and you may well ask why the person didn't just write 0.

The reason is that the person is conforming to a particular style for use of malloc. Conforming to a pattern is a way of minimizing errors. If you read this site regularly you'll know that incorrect use of malloc is one of the most common sources of bugs that people have trouble tracking down. The pattern being used is:

T *ptr = (T *) malloc( number_of_elements * sizeof(T) );

which allocates an array of a certain number of elements of type T. This is legal even if the number is 0 (but not legal for negative numbers); in which case it may either return a null pointer, or a non-null pointer. In either case, you can't try and access any array elements , of course.

This pattern is common, but as mentioned in the linked thread, has problems and since 1989 there has been a better option.

NB. Consider using calloc to allocate memory. It's slightly clearer in that the two numbers are separated by a comma instead of by a multiplication operator, and on some operating systems (e.g. Linux) it can perform faster than malloc.

What is this line of code really doing?

6 Answers6