Malloc a pointer to a pointer to a structure array by reference

Question

The code below compiles, but immediately crashes for reasons obvious to others, but not to me. I can't seem to get it right, can anyone tell me how to fix this.

*array_ref[2] = array[0];
*array_ref[3] = array[1];

It crashes on that part everytime.

typedef struct test {
    char *name;
    char *last_name;
} person;



int setName(person ** array, person ***array_ref) {

    *array = malloc (5 * sizeof(person));
    *array_ref= malloc(5 * sizeof(person*));

   array[0]->name = strdup("Bob");
   array[1]->name = strdup("Joseph");
   array[0]->last_name = strdup("Robert");
   array[1]->last_name = strdup("Clark");


*array_ref[2] = array[0];
*array_ref[3] = array[1];


    return 1;
}



int main()
{
    person *array;
    person **array_r;

   setName(&array,&array_r);

    printf("First name is %s %s\n", array[0].name, array[0].last_name);
    printf("Second name is %s %s\n", array_r[3]->name, array_r[3]->last_name);

     while(1) {}
    return 0;
}

What you should usually do in a case where your code has a bug, especially when the bug is an actual crash and happens every time, is to try and narrow it down to the least amount of code that still makes it happen. This will make it both easier for others to find the bug when looking at the code, and more importantly, much easier for you to understand what exactly is causing the crash. — Edan Maor
– Edan Maor, Commented Nov 30, 2009 at 0:30
@Edan, I wouldn't say that it's an issue in this case. There isn't much code here, and the problem is fairly clear. — Pavel Minaev
– Pavel Minaev, Commented Nov 30, 2009 at 0:33
+1 Edan. Narrowing this down to remove array_ref clarifies the problem and would surely help ZPS understand it. — Roger Pate
– Roger Pate, Commented Nov 30, 2009 at 0:39

Pavel Minaev · Accepted Answer · 2009-11-30 00:32:43Z

6

Operator [] has higher precedence than unary operator*. Hence, this:

*array_ref[2] = array[0];
*array_ref[3] = array[1];

actually means:

*(array_ref[2]) = array[0];
*(array_ref[3]) = array[1];

Types are correct here, which is why it compiles. But from your code it's clear that your intent actually was:

(*array_ref)[2] = array[0];
(*array_ref)[3] = array[1];

So just use parentheses.

answered Nov 30, 2009 at 0:32

Pavel Minaev

102k27 gold badges222 silver badges293 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Simon Buchan Over a year ago

Remember array[1] is not allocated :).

Richard Pennington · Accepted Answer · 2009-11-30 00:28:22Z

1

You allocated space for the array_ref pointers, but not for what they point to.

answered Nov 30, 2009 at 0:28

Richard Pennington

20.1k4 gold badges48 silver badges75 bronze badges

1 Comment

Roger Pate Over a year ago

He points them to objects which are allocated, this is not a problem.

Sean A.O. Harney · Accepted Answer · 2009-11-30 00:31:07Z

1

Try changing the following in setName()

 *array_ref[2] = array[0];
 *array_ref[3] = array[1];

to

*(*array_ref+2) = array[0];
*(*array_ref+3) = array[1];

This works.

answered Nov 30, 2009 at 0:31

Sean A.O. Harney

24.6k4 gold badges32 silver badges30 bronze badges

Comments

Roger Pate · Accepted Answer · 2009-11-30 00:31:41Z

1

array[1]->name is your problem. This should be (*array)[1].name. Notice how the two aren't equivalent. All the similar uses have the same problem, except for [0], which accidentally does the right thing.

Remember that array, the function parameter, isn't your array, it's a pointer to your array.

answered Nov 30, 2009 at 0:31

Roger Pate

Comments

Simon Buchan · Accepted Answer · 2009-11-30 04:02:39Z

In functions like this I prefer code like:

int setName(person ** out_array, person ***out_array_ref) {
    person* array = malloc(5 * sizeof(person));
    person** array_ref = malloc(5 * sizeof(person*));
    array[0].name = strdup("Bob");
    array[1].name = strdup("Joseph");
    array[0].last_name = strdup("Robert");
    array[1].last_name = strdup("Clark");
    // I'm guessing this was your intent for array_ref, here:
    array_ref[2] = &array[0];
    array_ref[3] = &array[1];

    *out_array = out_array;
    *out_array_ref = array_ref;
    return 1;
}

Note that this catches both array[1]->name as noted by Roger Pate, and *array_ref[2] = array[0] as (almost) noted by Pavel - whose solution (*array_ref)[2] = array[0] assigns from an unallocated person* array[1] - both of which are hard to notice with the extra dereference.

Of course, I mostly do this because I use C++, and this increases exception safety ;).

Collectives™ on Stack Overflow

Malloc a pointer to a pointer to a structure array by reference

5 Answers 5

1 Comment

1 Comment

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

1 Comment

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related