Memory Allocation and Pointers in C

Question

I'm studying for a test and I came across something I'm finding hard to understand. We're working with pointers and memory allocation, and I was just fooling around with things, trying to see what changed what. I have this bit of code:

int * arr[10];
for(i=0; i<5;i++) 
{
    int index = i;
    arr[index] = malloc(sizeof(int*));
    int i = 2 * index;
    *arr[index] = i;
    printf("arr [%d] = %d\n", index, *arr[index]);  /* should be 0, 2, 4, 6, 8 */
}

But what I've found is that if instead of using *arr[index] = i, I use arr[index] = &i I don't need the malloc . I've always assumed that these two things were essentially the same thing, but there must be some key difference I don't understand to warrant the use of malloc with the one.

I'm actually confused why I need malloc at all here really. I'm fairly new with memory allocation and I don't really understand when it's supposed to be used (obviously) and was wondering if anyone could clear this up for me.

Answer 1

Try this code instead:

int * arr[10];
for(i=0; i<5;i++) 
{
    int index = i;
    int value = 2*i;
    arr[index] = malloc(sizeof(int*));
    *arr[index] = value;
}

for (i=0; i<5; i++)
{
    int index = i;
    printf("arr [%d] = %d\n", index, *arr[index]);  /* should be 0, 2, 4, 6, 8 */
}

If you make the change you suggest, you would now have undefined behavior. Whereas this code still is valid.

You'd have undefined behavior because *arr[0] now points to a piece of stack memory that has left scope.

---

Your malloc should actually be malloc(sizeof(int)) . You're allocating space for an int , not for a int * .

Answer 2

Yeah I think it is hard to understand, because i gets redefined in the middle of the for. I'll rewrite the code right now. I wrote i instead of index and 2*i instead of the redefined i.

int * arr[10];
for(i=0; i<5;i++) 
{
    arr[i] = malloc(sizeof(int));
    *arr[i] = 2*i;
    printf("arr [%d] = %d\n", i, *arr[i]);  /* should be 0, 2, 4, 6, 8 */
}

You don't acutally need dynamic memory here, you know that array 0-4 will be used. You need dynamic memory, when you don't know how mutch data will you need. This code is written, so that the rest of your code will still work, but there is no malloc.

int array[5];
int **arr=array;

The following code means, that array[index] should point to the memory adress i is stored in. It does not copy the value that is in i, so when you change i, or i gets deleted, this will cause this pointer to be faulty, and cause problems later. You should't do this.

arr[index] = &i

Answer 3

Written this way:

*arr[index] = i;

Means: Copy the value of i to the memory location pointed to by arr[index] (that was allocated earlier in your code).

arr[index] = &i;

Means: Copy the address of i to arr[index] .

In your code i is automatically created inside the for loop and only exists inside that loop. Once you leave the loop (scope) the memory used to store i is then free to part of any newly created variables.

As sharth suggests, try looking at the values outside the original for loop to see some interesting results.

Answer 4

一个关键的区别是&i将不复存在一旦i超出范围（或者，更确切地说，是一块内存可以为别的东西......这可能不会包含你以为它所包含的内容可以重复使用）。

Answer 5

Edit: I say below you didn't show how i was declared. Actually, you redeclare it, hiding the original value if i used in the loop. Regardless, i is going to go out of scope at the end of the loop or, likely, when the routine ends.

You don't show how i is declared here. However, in most cases, it'd be a local variable or perhaps a parameter passed to a method. In either case, the space for that variable is declared on the stack. You can take the address of that variable with &i , but that variable is going to go away after the method ends and the code pops those values off the stack. You might get lucky and have that value remain untouched for as long as you need it. But the moment another method is called, that value is likely to be overwritten and boom, your program is at best going to behave incorrectly.

You could get away with this if i is declared globally.

Further, you're pointing to the same address even after changing the value of i . If, at the end of your routine, you printed out all of the values of your array, you'd see they were all the same value - the last value you put into the array. That's because each entry in the array points to the same location.