Getting a stack overflow exception when declaring a large array

Question

The following code is generating a stack overflow error for me

int main(int argc, char* argv[])
{
    int sieve[2000000];
    return 0;
}

How do I get around this? I am using Turbo C++ but would like to keep my code in C

EDIT:

Thanks for the advice. The code above was only for example, I actually declare the array in a function and not in sub main. Also, I needed the array to be initialized to zeros, so when I googled malloc, I discovered that calloc was perfect for my purposes.

Malloc/calloc also has the advantage over allocating on the stack of allowing me to declare the size using a variable.

I read "stack overflow exception" and thought to myself "...? is something wrong with the site?" Clearly I spend way too much time here :-/ — David Z
– David Z, Commented Feb 21, 2009 at 2:27
I'm pretty sure this type of question must have come up previously on this site, but searching for "stack overflow" is no use whatsoever — Patrick McDonald
– Patrick McDonald, Commented Feb 21, 2009 at 2:33
i think every single C programmer ends up wasting a lot of their time figuring out this problem for the first time.. — MahlerFive
– MahlerFive, Commented Feb 21, 2009 at 3:20
Turbo C++ is a 16-bit application which means that it uses memory segmentation, each segment is 64KB in size so no structure can be larger than this number, and the total memory usage is maxed at 640KB (1MB or more with some extended memory manager). Why do you need to use such a more-than-20-year-old compiler? — phuclv
– phuclv, Commented Oct 28, 2013 at 3:33
By now hopefully you have discovered GCC. Among other places It comes bundled with the Code::Blocks IDE. — ryyker
– ryyker, Commented Aug 21, 2019 at 12:11

Patrick McDonald · Accepted Answer · 2015-04-29 12:43:28Z

67

Your array is way too big to fit into the stack, consider using the heap:

int *sieve = malloc(2000000 * sizeof(*sieve));

If you really want to change the stack size, take a look at this document.

Tip: - Don't forget to free your dynamically allocated memory when it's no-longer needed.

edited Apr 29, 2015 at 12:43

Patrick McDonald

65.7k14 gold badges114 silver badges128 bronze badges

answered Feb 21, 2009 at 2:16

arul

14.1k1 gold badge60 silver badges78 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

aib Over a year ago

As this is C, you need not (and in fact, should not) cast the return value of malloc.

user47589 Over a year ago

Why wouldn't you cast the result of malloc? Wouldn't you have to cast it from void* in order to do much of anything with it?

jweyrich Over a year ago

@yodaj007: You don't need to cast it explicitly. Since the assigned variable is also of a pointer type, the assignment performs an implicit conversion.

WhozCraig Over a year ago

@Amy Read this: "Do I cast the result of malloc?". It explains several reasons why not to cast malloc (or any of the other memory allocation functions) in C.

Peter Cordes Over a year ago

Related: C++ canonical Q&A answer that suggests new/delete or std::vector for the same problem: Segmentation fault on large array sizes

qrdl · Accepted Answer · 2009-02-21 08:42:47Z

15

There are 3 ways:

Allocate array on heap - use malloc(), as other posters suggested. Do not forget to free() it (although for main() it is not that important - OS will clean up memory for you on program termination).
Declare the array on unit level - it will be allocated in data segment and visible for everybody (adding static to declaration will limit the visibility to unit).
Declare your array as static - in this case it will be allocated in data segment, but visible only in main().

answered Feb 21, 2009 at 8:42

qrdl

35.2k14 gold badges59 silver badges92 bronze badges

1 Comment

Christoph Over a year ago

I'd just make it static: main() should only be called once, so there are no pitfalls; no need for malloc() here...

RandomNickName42 · Accepted Answer · 2009-02-21 03:04:06Z

That's about 7MB of stack space. In visual studio you would use /STACK:###,### to reflect the size you want. If you truely want a huge stack (could be a good reason, using LISP or something :), even the heap is limited to small'sh allocations before forcing you to use VirtualAlloc), you may also want to set your PE to build with /LARGEADDRESSAAWARE (Visual Studio's linker again), but this configure's your PE header to allow your compiled binary to address the full 4GB of 32'bit address space (if running in a WOW64). If building truely massive binaries, you would also typically need to configure /bigobj as an additional linker paramerter.

And if you still need more space, you can radically violate convention by using something simular to (again MSVC's link) /merge:, which will allow you to pack one section into another, so you can use every single byte for a single shared code/data section. Naturally you would also need to configure the SECTIONS permissions in a def file or with #pgrama.

asdf · Accepted Answer · 2009-02-22 06:59:56Z

1

Use malloc. All check the return type is not null, if it is null then your system simply doesn't have enought memory to fit that many values.

answered Feb 22, 2009 at 6:59

asdf

Comments

Cogsy · Accepted Answer · 2009-02-21 02:17:02Z

0

You would be better off allocating it on the heap, not the stack. something like

int main(int argc, char* argv[])
{
    int * sieve;
    sieve = malloc(20000);
    return 0;
}

answered Feb 21, 2009 at 2:17

Cogsy

5,6524 gold badges37 silver badges47 bronze badges

3 Comments

paulm Over a year ago

And check sieve for NULL

DragonLord Over a year ago

"I am only sieve for you"--The Zohan

Toby Speight Over a year ago

I think you meant sieve = malloc(20000 * sizeof *sieve) - unless your platform has int of size 1 (and even then, I wouldn't embed that assumption in the code).

Ivan Rubinson · Accepted Answer · 2016-07-04 06:01:51Z

Your array is huge.

It's possible that your machine or OS don't have or want to allocate so much memory.

If you absolutely need an enormous array, you can try to allocate it dynamically (using malloc(...)), but then you're at risk of leaking memory. Don't forget to free the memory.

The advantage of malloc is that it tries to allocate memory on the heap instead of the stack (therefore you won't get a stack overflow).

You can check the value that malloc returns to see if the allocation succeeded or failed. If it fails, just try to malloc a smaller array.

Another option would be to use a different data structure that can be resized on the fly (like a linked list). Wether this option is good depends on what you are going to do with the data.

Yet another option would be to store things in a file, streaming data on the fly. This approach is the slowest.

If you go for storage on the hard drive, you might as well use an existing library (for databases)

Arun Chettoor · Accepted Answer · 2017-07-14 03:44:36Z

0

As Turbo C/C++ is 16 bit compiler int datatype consumes about 2 bytes. 2bytes*2000000=40,00,000 bytes=3.8147MB space.

The auto variables of a function is stored in stack and it caused the overflow of the stack memory. Instead use the data memory [using static or global variable] or the dynamic heap memory [using the malloc/calloc] for creating the required memory as per the availability of the processor memory mapping.

edited Jul 14, 2017 at 3:44

answered Jul 13, 2017 at 20:02

Arun Chettoor

1,1611 gold badge12 silver badges19 bronze badges

Collectives™ on Stack Overflow

Getting a stack overflow exception when declaring a large array

7 Answers 7

5 Comments

1 Comment

Comments

Comments

3 Comments

Comments

Comments

Linked

Hot Network Questions