static (what? not electricity)

[Sgqvur]

----I was "thinking" about the word static and it's usage and meaning in
the programming languages. I am not sure if the C language was the one
to introduce it but it's usage is strange for me at least. I know a
little C but I think I know what static does. Prepended to a global var-
iable or function make it only visible and usable to the file/compilation
unit it is declared/defined. Prepending it to a local varaible makes the
variable sort of anonymous global so to speak making it only visible and
usable to the function. So it seams static is a visibilty modifier for
the variable/function that follows it. So how logical is static for you?
For me more logical names for a visibilty modifier are hidden (I think
you can agree that hidden is describles presisly what is meant by static.
In the global case it hides the variable/function from the rest of the
compilation units. In the local case it hides the variable from the rest
of the code in the unit and of course it's value is saved not lost like
the rest of the local variables.), my (as in you can't have my global int
=) and this is my var/function there are many like it but this one's mine)
visibleonlyhere is rather verbose and private of course makes sense as
well. I was "thinking" about something starting with un... but only came up
with unavailable =), I would pick static too if only unavailable was
available. But anyway... enough about it's meaning and usage in C. The
reassion it was picked up by the creators of the language is I guess
borrowed from the Science of Physics in which static has the meaning of
"unable to change", "fixed", "Something that is not part of any perceived
universe phenomena; having no motion; no particle; no wavelength". Hm
I think I am starting "to getting it", so static var/function means
unchangeable for the rest of the code but not here? So change[able]hereonly
is another logical name?
----Moving to the OOP langguages from the C family C++, Java, C#, D etc.
But it seams in general that in Computer Science that the word static
has a lot of meanings (not just double, triple, quadriple meaning but
also sextuple and more... In those languages the meaning of static is
even more foggy. Prepended to a variable it makes only one copy of it
for every instance of the class to access (sound like shared to me) and
prepended to a method it stands for litteraly a function which name
when used outside of the class begings with the class's name follow by a
dot and the name which the user picked (I think there are some additinal
rules like only able to access other static data and what not). So the
meaning of static (something unchangeable, fixed) that was hard to find
in the usage of C is lost entirely here. So why did the smart people
behind those languages rather carelessly copied it over? So in my opinion
shared (intead of static) and simple function (instead of static method)
is simpler and easier to grasp.

 

[The Helper]

Static and Global are about scope. It is true that visibility is a factor there but they were created more inline with memory allocation. It takes less memory to declare a variable static than global. Also, if you have something declared global and it conflicts with another variable name it can cause memory leaks because the space cannot be de-allocated. This is is especially troublesome in loops where you try and create and destroy a variable that is local (static) that conflicts with a global. This is not a problem with all languages though.

It is all about memory allocation. When you have 4 gigs of memory on a windows box, not a big deal and sloppy coding is not noticeable but on mobile apps or limited memory situations you want to be able to control your memory usage down to the smallest level. That is why that is there.

 

[s3rius]

Different languages often use the same terminology for different things.
For example, a class in Haskell is very different from the C++ class, but instead is more like an interface from Java. While the Java interface is implemented using abstract classes in C++.

From MSDN:

When modifying a variable, the static keyword specifies that the variable has static duration (it is allocated when the program begins and deallocated when the program ends) and initializes it to 0 unless another value is specified. When modifying a variable or function at file scope, the static keyword specifies that the variable or function has internal linkage (its name is not visible from outside the file in which it is declared).

A variable declared static in a function retains its state between calls to that function.

When modifying a data member in a class declaration, the static keyword specifies that one copy of the member is shared by all instances of the class. When modifying a member function in a class declaration, the static keyword specifies that the function accesses only static members.

 

[Lyerae]

It takes less memory to declare a variable static than global.

Any chance you can explain why this is, or have a link that does?

 

[Slapshot136]

Any chance you can explain why this is, or have a link that does?

I think it something like for things like string, where they don't always use the full amount of memory allocated, it can be optimized to use only how much is needed for statics, but not for dynamic variables, as they might end up using all of their allocated space later, while a static wouldn't - im not sure about this, as I think this would cause problems when you tried to copy a static into a non-static/etc. - I would also like a better explanation

 

[JerseyFoo]

It's the opposite of dynamic. Not reading your post as it's too hipster.

 

[s3rius]

I think it something like for things like string, where they don't always use the full amount of memory allocated, it can be optimized to use only how much is needed for statics, but not for dynamic variables, as they might end up using all of their allocated space later, while a static wouldn't - im not sure about this, as I think this would cause problems when you tried to copy a static into a non-static/etc. - I would also like a better explanation

There are three types of memory storage:

static int s = 5; //Static
int i = 5; //Stack
int *c = new int[i]; //Dynamic - we're making an i-sized array here! i is not constant!

Variables that are stack or static have a known size during compilation. You know exactly that an int is X bytes on your system:

<allocate 4 bytes of memory for i>
set i = 5
<later deallocate the 4 bytes of memory that i uses>

Dynamic memory, however, can be an arbitrary size. (In the above example we're declaring an array with i elements. Since i is a number unknown to the compiler it doesn't know how large that array actually is). Since the compiler doesn't know how large the memory chunk is it can't automatically clean it up:

<allocate some user-defined number of bytes of memory for c>
set c[3] = 5
<later deallocate the ??? bytes of memory that c uses>

So, when dynamically allocating, the system will always store a number in the memory to remember how large the particular allocated chunk is.

Look at my (awesomely-drawn) picture.
The first one is how the memory looks like for stack/static variables. The system stores a pointer to the memory-portion, and because it knows exactly what type the data is of, it knows that the next 4 bytes (starting from that memory pointer) are the variable we want.
No extra memory is used.

The second one is how dynamic memory looks like. The compiler can't be sure how large the allocated memory block is. That's why it uses a small piece of memory in-front of the pointer to remember how large it was.
Thus we need an extra few bytes. Usually it's 4 bytes, I think.

Soo... dynamic memory requires some management-overhead.
However, static memory is static! That means it gets allocated when the program starts and deallocated when it ends. It basically stays in your memory as long as your program is active. While dynamic memory can be deallocated when you don't need it anymore.

The difference is memory usage is also minimal. Those few bytes really aren't important. Even on mobile devices it's not that important. (On mobile devices you try not to allocate so much because it takes relatively much time to allocate/deallocate.)

 

[camelCase]

I don't get it =/

It takes less memory to declare a variable static than global.

Don't both static and global variables have the same life-span?
The only difference being their scope.

And, unless your global variable uses dynamic storage, I don't see how a static uses less memory =/

 

[Slapshot136]

Don't both static and global variables have the same life-span?
The only difference being their scope.

I think you can delete static variables once they are (or will be) out of scope, while globals you can't (since they will never be out of scope)

 

[camelCase]

statics last till the end of the program ._.
Their scope is within w/e class or function they are declared in.

 

[GetTriggerUnit-]

I think what they're trying to say is that when a scope finishes its execution, the garbage collection will remove all the memory it used. static variables will be cleaned too.

 

[s3rius]

I think what they're trying to say is that when a scope finishes its execution, the garbage collection will remove all the memory it used. static variables will be cleaned too.

No, that's exactly what does not happen. Static variables stay, even if the program leaves it's scope.

 

[camelCase]

Which still leaves this question unanswered:

It takes less memory to declare a variable static than global.

Why?

 

[s3rius]

I don't know of any reason why a static variable would require less juice than a global.
I've explained why dynamically allocated variables require more above, but the difference between a normal global and a static, in my eyes, is only scope visibility.

 

[Jedi]

I don't know of any reason why a static variable would require less juice than a global.
I've explained why dynamically allocated variables require more above, but the difference between a normal global and a static, in my eyes, is only scope visibility.

I don't even understand the part you explained.

char p* =(char *) malloc(5); //allocated 5 bytes
here
code
comes
...
free(p) //deallocated 5 bytes

^Isn't there 5 bytes allocated and deallocated?

 

[camelCase]

I reckon he means that for dynamically allocated memory, an extra byte or a few is needed to 'remember' how much memory was allocated.

 

[Lyerae]

<snip'd>
^Isn't there 5 bytes allocated and deallocated?

If I understand correctly, yes (though I believe C++ just uses new and delete). I'm not too familiar with the finer details of memory allocation yet (but I do this that should technically be something like "char p = (char *) malloc(sizeof(char));").

 

[s3rius]

I don't even understand the part you explained.

void blah(){

    int i = GetUserInput();

   char* array =malloc( i*( sizeof(char) ) );

   //blah blah


   free(array);
}

So, how many bytes does the system have to deallocate when it reaches free()?
You can't know beforehand, so the system needs to store a copy of the size you passed to malloc() to remember how large the allocation was.
And it stores this number next to the actual allocated memory block.

When I'm at it - malloc isn't guaranteed to give you X bytes of memory, even if you requested X bytes. It will give you at least X bytes, instead.
Some operating systems like to give away memory in 4-byte or 8-byte chunks. So if you request 14 bytes you might very well get 16.

 

[Dan]

It's the opposite of dynamic. Not reading your post as it's too hipster.

lol. I'm surprised it took this long for someone to mention this. I'm actually half sure that this post is a troll post. (the good kind)

"Static" means "unchanging" , "fixed", or "lacking movement." Static functions are never put on the stack, thus are immobile. static variables exist in one instance, and thus do not change.