Difference between array type and array allocated with malloc

c arrays malloc variable-length-array
Jorge Leitao picture Jorge Leitao · May 13, 2012 · Viewed 38.3k times · Source

Today I was helping a friend of mine with some C code, and I've found some strange behavior that I couldn't explain him why it was happening. We had TSV file with a list of integers, with an int each line. The first line was the number of lines the list had.

We also had a c file with a very simple "readfile". The first line was read to n, the number of lines, then there was an initialization of:

int list[n]

and finally a for loop of n with a fscanf.

For small n's (till ~100.000), everything was fine. However, we've found that when n was big (10^6), a segfault would occur.

Finally, we changed the list initialization to

int *list = malloc(n*sizeof(int))

and everything when well, even with very large n.

Can someone explain why this occurred? what was causing the segfault with int list[n], that was stopped when we start using list = malloc(n*sizeof(int))?

Answer

templatetypedef picture templatetypedef · May 13, 2012

There are several different pieces at play here.

The first is the difference between declaring an array as

int array[n];

and

int* array = malloc(n * sizeof(int));

In the first version, you are declaring an object with automatic storage duration. This means that the array lives only as long as the function that calls it exists. In the second version, you are getting memory with dynamic storage duration, which means that it will exist until it is explicitly deallocated with free.

The reason that the second version works here is an implementation detail of how C is usually compiled. Typically, C memory is split into several regions, including the stack (for function calls and local variables) and the heap (for malloced objects). The stack typically has a much smaller size than the heap; usually it's something like 8MB. As a result, if you try to allocate a huge array with

int array[n];

Then you might exceed the stack's storage space, causing the segfault. On the other hand, the heap usually has a huge size (say, as much space as is free on the system), and so mallocing a large object won't cause an out-of-memory error.

In general, be careful with variable-length arrays in C. They can easily exceed stack size. Prefer malloc unless you know the size is small or that you really only do want the array for a short period of time.

Hope this helps!

Related questions

Using malloc for allocation of multi-dimensional arrays with different row lengths

I have the following C code : int *a; size_t size = 2000*sizeof(int); a = (int *) malloc(size); which works fine. But if I have the following : char **b = malloc(2000*sizeof *b); where every element of b has different length. How …

Read More
Dynamically create an array of strings with malloc

I am trying to create an array of strings in C using malloc. The number of strings that the array will hold can change at run time, but the length of the strings will always be consistent. I've attempted this (…

Read More
How to use realloc in a function in C

Building on what I learned here: Manipulating dynamic array through functions in C. void test(int data[]) { data[0] = 1; } int main(void) { int *data = malloc(4 * sizeof *data); test(data); return 0; } This works fine. However, I am also trying to using realloc …

Read More