realloc有什么问题？

Question

Started to learn malloc.h in C. The idea was to create dynamic array. Here is the code:

#include <stdio.h>
#include <conio.h>
#include <malloc.h>

int main() {
    int *array = (int*)malloc(sizeof(int));
    int i, j, val;
    for (i = 0;; i++) {
        array = (int*)realloc(array, sizeof(int) + sizeof(*array));
        printf("Enter array[%d]=", i);
        scanf("%d", (array + i));
        if (*(array + i) == 0) break;
    }
    for (j = 0; j < i; j++) {
        printf("[%d] = %d\n", j, *(array + j));
    }
    getch();
    return 0;
}

The result is

Enter array[0]=1
Enter array[1]=2
Enter array[2]=3
Enter array[3]=4
Enter array[4]=5
Enter array[5]=6
Enter array[6]=7
Enter array[7]=8
Enter array[8]=9
Enter array[9]=10
Enter array[10]=0
[0] = 1
[1] = 2
[2] = 3
[3] = 4
[4] = 5
[5] = 6
[6] = 7
[7] = 8
[8] = 542979931
[9] = 875896893

Each time, >=8 values are random. I have just no idea why it happens so what's wrong?

Answer 1

You undefined behavior in your code. I suppose, doing this:

array=(int*)realloc(array,sizeof(int)+sizeof(*array));

you expect, that sizeof(*array) will return you the size of the whole array, right? But that's not true. sizeof is computed at compile time and doing sizeof(*array) is actually the same as sizeof(int) .

So, to make this array extensible, you need to have additional variable, holding the current number of elements and do something like:

array=(int*)realloc(array, sizeof(int) + current_size_of_array * sizeof( int ) );

where current_size_of_array will be incremented on each loop of the for , when you actually add one more element.

Answer 2

sizeof(*array) does not tell you how large the array is. It tells you how many bytes an int occupies. So each call to realloc is only allocating memory for two int values. Change the realloc call to allocate sizeof(int) times the number of ints that you want.

Answer 3

sizeof(int)+sizeof(*array)

You think that sizeof(*array) is the number of bytes already allocated. You're wrong, sizeof(*array) is the size of one int . So you're overrunning your buffer, and eventually that causes you a problem.

Before you ask, there is no standard way to get the size already allocated. Normally you need to store it for yourself (or in C++ use something with a more user-friendly interface than malloc , such as vector ). In this case, you don't need the existing size, you can work out the new size required from i .

Answer 4

The size of a block of memory allocated by malloc is known to the library ( free only needs the pointer) but there is no portable way to get that number back. You must store in some other variable what is the current size so that you can allocate more space.

In sizeof(*array) the sizeof operator only considers the type of the expression and in your case is (*(int *)) in other words is the same as sizeof(int) .

In C++ this work of remembering the number of elements inside a dynamic array allowing increasing the size is done by the standard class std::vector .

As a side note please remember that x = realloc(x, ...); is a bad idiom because in case of allocation failure your pointer x would be overwritten by NULL leaking that memory.