0

What memory usage runs faster... storing an array on the stack or on the heap and accessing it later: ?

  • array of integers
  • array of NSString

My hunch would be the heap for an array. Don't you have to pop everything off the stack to get to the last item. Where as the heap you can go there directly.

jdl
  • 6,151
  • 19
  • 83
  • 132

4 Answers4

2

They're not actually data structures - they're really just shorthand names for the regions of your program's memory where data can be stored. Once the data's stored, you can get to any piece just as quickly as getting to any other piece. Basically:

  • Local variables get stored on the stack, and go away as soon as the function they were created in returns.
  • Anything you create with malloc and friends (C, and Objective-C as well) or new (C++) gets stored on the heap. It sticks around until it's disposed of by free (C) or its destructor (C++).

There's a little bit of OS overhead when adding or removing things from the heap, but unless you're creating and destroying things with an upsetting frequency, you won't notice a difference in performance. Rule of thumb: Only use the heap (malloc / new) for things you want to keep around for a while, and let the compiler take care of the rest.

Hope this helps!

PS: For way more detail than I went into, see this question.

Community
  • 1
  • 1
Xavier Holt
  • 14,471
  • 4
  • 43
  • 56
1

Allocating on the stack is faster since allocating stack space amounts to subtracting a value from the stack pointer. Allocating from the heap totally depends on the algorithms used, but they certainly won't be faster than a single instruction subtracting from a stack pointer.

Jim Buck
  • 20,482
  • 11
  • 57
  • 74
1

The stack and heap are just logical constructs, there is no actual difference between the two as far as the memory subsystem hardware is concerned. Similarly, pointers do not care if the things they point to reside on the stack or on the heap, nor does the CPU when it dereferences the pointer. Behind the scenes, memory is memory, and there is no difference between stack and heap.

So there should be no difference between the two. If you put your array on the stack and keep a pointer to it, then you don't need to pop everything off the stack to get to it.

One thing you do have to be careful of, however, is that when the currently executing method returns to its caller it will automatically pop the stack and remove anything that it put there. So if you want your data to persist across method invocations you pretty much have to use the heap.

aroth
  • 54,026
  • 20
  • 135
  • 176
  • "pointers do not care..no difference between stack and heap". Could you provide a link to verify this declaration? I have some doubt about it. – Philip007 Sep 27 '12 at 20:05
  • @Philip007 - Take a look at Xavier's answer. He basically says the same thing I do. And the other question that he links to gives a lot of info. In particular, it's worth noting that memory *allocation* can be faster on the stack than on the heap. But once the allocation has completed, there's no difference in terms of using the variables/data structures/etc. that reside on the stack or the heap. They're just different regions of memory. – aroth Sep 27 '12 at 23:30
0

Access time, using the array is the same for both, but allocating and reallocating heap takes much longer than on stack.

progrmr
  • 75,956
  • 16
  • 112
  • 147