Declare large array on Stack

Question

I am using Dev C++ to write a simulation program. For it, I need to declare a single dimensional array with the data type double. It contains 4200000

Answer 1

No there is no(we'll say "reasonable") way to declare this array on the stack. You can however declare the pointer on the stack, and set aside a bit of memory on the heap.

double *n = new double[4200000];

accessing n[234] of this, should be no quicker than accessing n[234] of an array that you declared like this:

double n[500];

Or even better, you could use vectors

std::vector<int> someElements(4200000);
someElements[234];//Is equally fast as our n[234] from other examples, if you optimize (-O3) and the difference on small programs is negligible if you don't(+5%)

Which if you optimize with -O3, is just as fast as an array, and much safer. As with the

double *n = new double[4200000]; 

solution you will leak memory unless you do this:

delete[] n;

And with exceptions and various things, this is a very unsafe way of doing things.

Answer 2

You can increase your stack size. Try adding these options to your link flags:

-Wl,--stack,36000000

It might be too large though (I'm not sure if Windows places an upper limit on stack size.) In reality though, you shouldn't do that even if it works. Use dynamic memory allocation, as pointed out in the other answers.

(Weird, writing an answer and hoping it won't get accepted... :-P)

Answer 3

Are there any reasons you want this on the stack specifically?

I'm asking because the following will give you a construct that can be used in a similar way (especially accessing values using array[index]), but it is a lot less limited in size (total max size depending on 32bit/64bit memory model and available memory (RAM and swap memory)) because it is allocated from the heap.

int arraysize= 4200000;
int *heaparray= new int[arraysize];

... 

k= heaparray[456];

...

delete [] heaparray;

return;

Answer 4

Yes, you can declare this array on the stack (with a little extra work), but it is not wise.

There is no justifiable reason why the array has to live on the stack.

The overhead of dynamically allocating a single array once is neglegible (you could say "zero"), and a smart pointer will safely take care of not leaking memory, if that is your concern.
Stack allocated memory is not in any way different from heap allocated memory (apart from some caching effects for small objects, but these do not apply here).

Insofar, just don't do it.

If you insist that you must allocate the array on the stack, you will need to reserve 32 megabytes of stack space first (preferrably a bit more). For that, using Dev-C++ (which presumes Windows+MingW) you will either need to set the reserved stack size for your executable using compiler flags such as -Wl,--stack,34000000 (this reserves somewhat more than 32MiB), or create a thread (which lets you specify a reserved stack size for that thread).
But really, again, just don't do that. There's nothing wrong with allocating a huge array dynamically.