Thread: Declaring an array's size using a variable causes program to crash

Sorry, false alarm

But he has i-1 in the index of the array, so I think he or she is ok

The compiler only checks that the array declaration is syntactically correct. It is only when the program is run that the host system environment determines it cannot create the array.

Practically, if you want really large arrays, you are usually better off using dynamic memory allocation (eg malloc()) rather than just declaring an array of that size. There are all sorts of historical and practical reasons why this is so.


I do suggest you think carefully about whether such arrays are really needed. Sometimes they are, but most people who use such large arrays could get away with a smaller array and some clever logic to achieve the same intended effect.

There are three other problems in your code.

1) Array indices start at zero in C. If an array has 20 elements, it is invalid to access element number 20. Valid indices run from 0 to 19. Your loops have such an "off by one" error. That is a common cause of program crashes.

2) It is not guaranteed that an int variable can even store the value 1999000. That gives all sorts of potential problems if you attempt to iterate an int from 1 to 1999000.

3) malloc() can fail. It returns NULL if it does - and it is more likely to do so when allocating large arrays. Attempting to use memory that has not successfully been allocated usually gives a program crash.

The compiler is not required (in fact, there real-world circumstances where it simply can't) detect such problems. It is the programmers responsibility to avoid them, not for the compiler to detect them.

> I did try using malloc, and got the same error. I think my compiler allows variable-sized arrays. It works elsewhere...just not here...
Since there is nothing obviously wrong with your use of v1v2b, suspicion falls on to

Code:

    double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));
    outer_pos(x, y, nsamp, &v1v2[0]);

Now if you don't allocate enough memory for v1v2 (you have a complicated size, is it right?), then this could very easily trash memory and you would never know it.
The first real opportunity you get to discover whether v1v2 was trashed is on the next call to malloc/free.

> Also if too much memory on the stack is a problem, why is it that declaring an array using a number causes no problem - even though the the number is the same as the value stored in the variable?
The compiler is free to call malloc behind the scenes.

As an array, your 2M array of doubles would have taken 16MB of stack space.
The default allocation on most desktop systems is somewhere between 1MB and 8MB.
So yes, this was instant stack overflow.

Originally Posted by rcgldr

If you want a local array to be located in the heap instead of the stack, use static:

Code:

static double v1v2b[1999000];

Post #4 has suggested the use of a static variable. It's no good to have duplicate posts. Read the thread before you post next time

Originally Posted by Hè Xi

I did try using malloc, and got the same error.

That's cause you still have the large local array there as well.
If you use only malloc and remove the large local array, then I you will not get a stack overflow in this function.