error while declaring double array of size 150000?

Question

I am developing a code in which there is need for declaring array of double of size 150000 and when one array is declared code is running successfully.if we declare two arrays then while execution it terminates throwing exception.

Code is :

double a[150000];
double b[150000];

if we declare a only then it executes perfectly.if declare both a and b then it terminates. Can anyone suggest how to resolve this?

Stackoverflow, right? Give the arrays static storage or use a `std::vector`. — jrok, Apr 25 '13 at 11:20
If you declare these arrays locally in a function, they are over 2MB of stack space. On Windows the default stack size is only 1MB. — Some programmer dude, Apr 25 '13 at 11:21
Assuming these indeed are local variables, the space needed is 2 * 8 * 150000 (on x86), which is around 2.2 MB. Many operating systems limit the maximum stack of a process to less than that. — unwind, Apr 25 '13 at 11:21

hmjd · Accepted Answer · 2013-04-25T11:28:51.320

6

The two arrays are overflowing the stack (assuming they are local variables). Dynamically allocate memory for the arrays instead, using a std::vector to manage the memory for you:

std::vector<double> a(150000);
std::vector<double> b(150000);

Even though the std::vector instances are on the stack, the std::vector dynamically allocates memory internally for the data which is on the heap, avoiding the stack overflow.

edited Apr 25 '13 at 11:28

answered Apr 25 '13 at 11:20

hmjd

120,187
20
207
252

This is good, but worth mentioning that in C++03 it's unavoidably slower initially as all elements are written to when the vector is created. – Tony Delroy Apr 25 '13 at 11:25
1

@TonyD: That is just 2M of data, the cost of initialization is most probably negligible. If that is an issue, there are alternatives, but most probably the arrays are meant to be used, in which case most of the cost of initialization (actually touching the memory addresses) have to be paid anyways... – David Rodríguez - dribeas Apr 25 '13 at 11:29

score 4 · Answer 2 · edited May 23 '17 at 12:28

4

Okay! You have Stack Overflow in your app! enter image description here

Fixing examples:

don't use stack - use dynamic memory allocation (heap):

double* a = new double[150000];
use STL container, for example, vector - internally it allocates things on heap

std::vector<double> a(150000);
increase stack size (bad idea, but if you really need it read you compiler docs, and look here)
redesign you code somehow

edited May 23 '17 at 12:28

Community

1
1

answered Apr 25 '13 at 11:40

Ivan Aksamentov - Drop

12,860
3
34
61

Don't use dynamic memory allocation like that. Use `` or at least `make_shared` or `make_unique`. – Bartek Banachewicz Apr 25 '13 at 11:53
@Bartek Banachewicz Well, `` is ok, but `` and `` is completly wrong here: they will leak, because of using `delete` operator instead of `delete []` – Ivan Aksamentov - Drop Apr 25 '13 at 12:05
You can safely use `unique_ptr`, and it will call `delete[]`. You might want to update your knowledge about smart pointers. – Bartek Banachewicz Apr 25 '13 at 12:33
@Bartek Banachewicz Whoops! Looks like my ancient brain is a little out of date. So have template specialization for arrays. And what about ? – Ivan Aksamentov - Drop Apr 25 '13 at 12:37
for `shared_ptr` you need your own deleter. Still no leak. – Bartek Banachewicz Apr 25 '13 at 12:38
@Bartek Banachewicz "Starting with Boost release 1.53, shared_ptr can be used to hold a pointer to a dynamically allocated array." http://www.boost.org/doc/libs/1_54_0/libs/smart_ptr/shared_ptr.htm – Igor R. Jul 03 '13 at 12:47
@IgorR. Let's hope it appears in C++14/17 then. – Bartek Banachewicz Jul 03 '13 at 12:49

Mats Petersson · Answer 3 · 2013-04-25T12:07:38.883

2

There is one solution to this problem, but it leads to (at least) three different follow-on solutions. The solution is "don't use large arrays as local variables, because it blows up the stack".

The solution clearly means changing the code in some way. There are a few different ways to do that.

The obvious and straight-forwards solution is to use std::vector<double> instead.

Another solution is to use `

unique_ptr<double[]> a = std::unique_ptr<double[]>(new double[150000]);

The third, and SOMETIMES a good solutions, is to make a and b global variables.

There are several other variants, but they are generally variations on the same theme, just with slight variations. What is best in your case really depends on what the rest of your code is doing. I'd start with std::vector<double>, but other alternatives do exist, should that be an unsuitable solution for some reason.

edited Apr 25 '13 at 12:07

answered Apr 25 '13 at 11:38

Mats Petersson

126,704
14
140
227

`` will leak, because of using `delete` operator instead of `delete []` – Ivan Aksamentov - Drop Apr 25 '13 at 12:07
I've just edited in the missing space, which shows the extra `[]` that I believe will solve that problem, no? – Mats Petersson Apr 25 '13 at 12:08
Forget it =) 5 min ago I find out that `` has template specialization for arrays, with right deleter. Nice, huh? – Ivan Aksamentov - Drop Apr 25 '13 at 12:53

error while declaring double array of size 150000?

3 Answers3

Linked