Bundling Malloc Calls

Question

I was browsing SO and found some code that raised a question for me.

struct node* BuildOneTwoThree() {
struct node *list = malloc(3 * sizeof(struct node));

list[0].data = 1;
list[0].next = list+1;
list[1].data = 2;
list[1].next = list+2;
list[2].data = 3;
list[2].next = NULL;

return list;}

I'm trying to understand how this call to malloc works and what it returns. Did it return an array of pointers? How does that work out, I didn't expect malloc to work in this way?

This seems to guarantee that the memory indices of the individual structs are one after another which I imagine could be a powerful or useful tool.

Also after such a call to malloc would it be okay to initialise the array indices as

list[0] = (struct node) {1, list +1};

Note: struct node is defined as,

  struct node{
  int data;
  struct node *next;};

It returns a pointer to `3 * sizeof(struct node)` bytes of allocated memory. — tkausl, Feb 05 '19 at 04:22
Why is it that I can index those pointers using array indices? — M.A.A, Feb 05 '19 at 04:24
The space returned by `malloc()` in the first call is big enough to hold an array of 3 `struct node`, and the memory pointed at is sufficiently well aligned that it is safe to cast it to a `struct node *` and use it as an array of 3 `struct node` values. The C standard requires that guarantee of 'sufficiently well aligned'. — Jonathan Leffler, Feb 05 '19 at 06:21

score 1 · Answer 1 · answered Feb 05 '19 at 16:00

1

malloc returns a pointer to a memory region with the specified size.

The argument 3 * sizeof(struct node) says the region size is able to store 3 node structures.

Pointers and indices in arrays are interchangeable, as discussed in this answer.

answered Feb 05 '19 at 16:00

João Neto

1,732
17
28

score 1 · Accepted Answer · answered Feb 06 '19 at 16:13

struct node *list = malloc(3 * sizeof(struct node));

==> created a memory of three node structure size and list is pointed to the beginning of the memory storage. It means list=&list[0] or *list = list[0], list+1=&(list[1]) or *(list+1)=list[1], list+2=&(list[2]) or *(list+2)=list[2]

list[0] = (struct node) {1, list +1};

==> Yes, you can do that way. Here is my modification as that way, it worked fine:

struct node* BuildOneTwoThree() {
    struct node *list = (struct node *)malloc(3 * sizeof(struct node));

    list[0] = { 1, list + 1 };
    list[1] = { 2, list + 2 };
    list[2] = { 3, NULL };
    return list;
}

Bundling Malloc Calls

2 Answers2