17

Why do some people declare make their variables static, like so:

char baa(int x) {
    static char foo[] = " .. ";
    return foo[x ..];
}

instead of:

char baa(int x) {
    char foo[] = " .. ";
    return foo[x ..];
}

It seems to be very common on Linux source codes applications. Is there any performance difference? If yes, might someone explain why? Thanks in advance.

John Smith
  • 835
  • 1
  • 7
  • 19
Jack
  • 16,276
  • 55
  • 159
  • 284

5 Answers5

20

It's not for performance per se, but rather to decrease memory usage. There is a performance boost, but it's not (usually) the primary reason you'd see code like that.

Variables in a function are allocated on the stack, they'll be reserved and removed each time the function is called, and importantly, they will count towards the stack size limit which is a serious constraint on many embedded and resource-constrained platforms.

However, static variables are stored in either the .BSS or .DATA segment (non-explicitly-initialized static variables will go to .BSS, statically-initialized static variables will go to .DATA), off the stack. The compiler can also take advantage of this to perform certain optimizations.

Crashworks
  • 40,496
  • 12
  • 101
  • 170
Mahmoud Al-Qudsi
  • 28,357
  • 12
  • 85
  • 125
9

In typical implementations, the version with static will just put the string somewhere in memory at compile time, whereas the version without static will make the function (each time it's called) allocate some space on the stack and write the string into that space.

The version with static, therefore,

  • is likely to be quicker
  • may use less memory
  • will use less stack space (which on some systems is a scarce resource)
  • will play nicer with the cache (which isn't likely to be a big deal for a small string, but might be if foo is something bigger).
Gareth McCaughan
  • 19,888
  • 1
  • 41
  • 62
  • Why yes, so I did. Thanks. I've edited my answer to be (1) clearer and (2) correct. – Gareth McCaughan May 10 '12 at 08:31
  • why it will save memory? when loading the function does it still need to cost stack memory? – dragonxlwang Aug 04 '15 at 03:32
  • @dragonxlwang Take `char foo[] = "bar"` vs. `static char foo[] = "bar"`. When a program is loaded into memory, `"bar"` is part of the executable image. The difference is how it's treated. `static` points directly at `"bar"` in the loaded executable image (which also explains `static`'s side effects). Non-`static` must: (1) allocate stack space big enough to store `"bar"`, and (2) copy `"bar"` from the loaded program to that stack space on *each function call*. Each call makes a new copy of *all* stack variables in that function. This is also why deep recursion can exhaust the stack quickly. – Jody Bruchon Oct 23 '15 at 20:21
3

Yes, the performance is different: unlike variables in the automatic storage that are initialized every time, static variables are initialized only once, the first time you go through the function. If foo is not written to, there is no other differences. If it is written to, the changes to static variables survive between calls, while changes to automatic variables get lost the next time through the function.

Sergey Kalinichenko
  • 714,442
  • 84
  • 1,110
  • 1,523
2

Defining a variable static in a method only means that the variable is not "released", i.e. it will keep its value on subsequent calls. It could lead to performance improvement depending on the algorithm, but is certainly not not a performance improvement by itself.

tsug303
  • 59
  • 2
2

Yes it makes difference , if u have declared a variable as static :

  1. Firstly, the memory will be allocated in either bss or data segment instead of stack.

  2. Secondly, it will be initialized for once only , not every time unlike other variables of function, which will surely create difference.

  3. Thirdly, it retains it's value b/w function calls.So depending on the situations you should use it.

john
  • 1,323
  • 2
  • 19
  • 31