1

I know there are three types of static declerations in C:

1: Constant - constant static variable, ex: static const int i = 5;

2: Changable - just a normal static variable, ex: static int hi = 10;

Here is my question

There is another form of static which takes the form of "code". What does that mean and can you give me an example?

Thank you!

EDIT: Are static/const variables stored on the stack/heap?

James Carter
  • 387
  • 2
  • 6
  • 18
  • 1
    `static` in C just refers to the scope of the variable (or function) in that it is scoped to after its declaration in the translation unit – anthony sottile Apr 29 '13 at 17:19
  • 2
    What do you mean the form of 'code'? Do you mean functions that are marked static? – Firoso Apr 29 '13 at 17:19
  • I was reading online and it had three forms of static and one of them was 'code' which I was clueless on what they ment – James Carter Apr 29 '13 at 17:23
  • @AnthonySottile how does the `static` keyword in a declaration affects the scope of the identifier? It changes the storage duration and the linkage. Isn't the scope determined by the target and the place of the declaration? – effeffe Apr 29 '13 at 17:27
  • From my experience, static has be stored in the same space as globals - neither heap nor stack. – Michael Dorgan Apr 29 '13 at 18:07

5 Answers5

8

Maybe you are talking about a static function ?

This is a specific use of the word "static", which is entirely different from a static variable.

When you declare a function "static", that means it cannot be linked from another source file. It is typically used to keep some functions "private".

[Edit] Note that, in theory, the function code could still be accessed from another source file using pointers, but that's not quite the normal way (and certainly not the easiest) to access a function. Thanks to Eric Postpischil for pointing that out.

It's unfortunate that the same word "static" is used in the C standard to mean two different things, depending on being used for functions or variables.

[edit] : It's a different question, but anyway : in the case of static variables, they are neither allocated in the heap nor the stack. They are, well, static, which means they are allocated in a static space, directly allocated by the compiler at startup. Stack is for internal functions variables, and heap is for malloc()/free().

Cyan
  • 13,248
  • 8
  • 43
  • 78
  • 3
    `"internal linkage"` is the word ;-) – P.P Apr 29 '13 at 17:26
  • 2
    It is not correct that a static function cannot be accessed from outside the same source file (or translation unit). `static` affects the linkage of a function, not its accessibility. `static` causes the identifier (name) of the function not to have external linkage (refer to the same object as the same identifier in another translation unit), but the function can still be accessed by passing its address to routines defined in other translation units. Similarly, “limited in scope” is not better worded; `static` affects linkage, not scope. – Eric Postpischil Apr 29 '13 at 18:14
  • 1
    *"which is entirely different from a static variable"* well, the linkage semantic is the same whether the identifier refers to a "global variable" or to a function. – effeffe Apr 29 '13 at 19:42
4

This link should answer your question.

It is however worth noting that unless you have sufficient knowledge of the C compilation process this will be of questionable value.

A good reference for GCC can be found here.

I believable you're asking about static functions.. So..

Static functions

By default, functions in C are extern, meaning that the function can be used in any other file of the same project (and the same code of course).

If you don't like this situation and you want to limit the function to the file in which it's defined, you make it static.

Community
  • 1
  • 1
Maroun
  • 94,125
  • 30
  • 188
  • 241
  • 10
    Link Answers should be shunned! Shun. Shun! ---> – usumoio Apr 29 '13 at 17:20
  • @IamJohnGalt Man you totally changed my answer :D – Maroun Apr 29 '13 at 17:22
  • @MarounMaroun I believe I was the one who changed it :-P – Firoso Apr 29 '13 at 17:28
  • 3
    `extern` and `static` do not control whether the function can be used in any other file (more properly: translation unit) of the project. They affect whether the **identifier** refers to the same function or not when used in different translation units. They do not alter the **function**, which can still be used in other translation units, such as by passing its address. `extern` and `static` are properties of a function **name**, not of a **function**. – Eric Postpischil Apr 29 '13 at 18:22
1

The keyword static is used in several different ways in C. (There's a joke that any new version of the ISO C standard is required to invent a new meaning for static.)

Quick summary: The static keyword on a block scope definition gives the entity static storage duration; at file scope, where definitions already have static storage duration, it instead gives them internal linkage.

An object may have any of several storage durations. An object with "automatic" storage duration exists at run time only during the execution of the enclosing block. An object with "static" storage duration exists during the entire execution of the program. (There are also "allocated" and, new in C11, "temporary" storage durations, which I won't get into.)

Any definition of an identifier also has a "linkage", which can be external, internal, or none. Linkage controls whether an identifier is usable across translation units (basically source files, but #included files are not separate translation units). Linkage, as the name implies, has to do with the linker. You can use the same identifier with internal linkage in two different source files, and it will refer to two different entities. But if an identifier has external linkage, it should be defined only once, and can be declared (typically with extern) in multiple source files; all those declarations will refer to the same entity.

If you define an object (variable) at block scope, (i.e., inside a function body), it has automatic storage duration (and no linkage) by default. Adding the keyword static gives it static storage duration, so it exists and retains its value across calls to the function. (It doesn't affect the identifier's visibility).

If you define an object at file scope (i.e., outside any function body), it has static storage duration and external linkage by default. Adding the keyword static to the definition doesn't affect its storage duration, but it changes its linkage from external to internal, hiding the name from other translation units. Functions don't have storage duration (their code exists as long as the program is running), but static affects their linkage the same way, changing it from external to internal.

(C99 added another meaning for static, for function parameters of array type, which has nothing to do with the other uses.)

Keith Thompson
  • 254,901
  • 44
  • 429
  • 631
1

I think it's worth to clarify what we're talking about and try to use the correct wording.

The const qualifier has nothing to do with the static keyword.

Technically, the static keyword appears in declarations and it's usually a storage-class specifier, but from C99 it can also be in array declarators, though this is quite unusual.

When it's a storage-class specifier, just like in the declarations you've posted, it affects the linkage (visibility between files) of the identifier and the storage duration (lifetime) of the identified object, but not the scope of the identifier.

6.2.2 Linkages of identifiers

[...] Within one translation unit, each declaration of an identifier with internal linkage denotes the same object or function. [...]

If the declaration of a file scope identifier for an object or a function contains the storage-class specifier static, the identifier has internal linkage.30)

30) A function declaration can contain the storage-class specifier static only if it is at file scope; see 6.7.1.

Therefore, the identifier can only be seen in the translation unit (i.e., a source file after the preprocessing) where it's declared, whether it's an object or a function (maybe that's what you were looking for). So you can use to declare "private" functions to be used in just one file.

static void foo(void)
{
    // ...
}

The static keyword it's also used with the inline function specifier, which has a particular linkage semantics: https://stackoverflow.com/a/216546/1202636

Obviusly when we are not at file scope but in a more restricted one (static declarations inside functions) the linkage question becomes irrelevant since such an identifier has no linkage at all.

6.2.4 Storage durations of objects

An object whose identifier is declared [...] either with external or internal linkage or with the storage-class specifier static, has static storage duration. Its lifetime is the entire execution of the program and its stored value is initialized only once, prior to program startup.

This one only applies to object identifiers and it affects the lifetime of the object, for example letting a variable retains its value between calls, and its initialization.

(just to say it, such an object is also initialized with a default value)

As I said, there's a less common use of the static keyword: it can be use in array declarators inside function prototypes, to tell the compiler that an array given as parameter contains at least n elements. This is a (modified) example from the standard:

void f(double a[static 3][5]);

The declaration specifies that the argument corresponding to a in any call to f must be a non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.

.

Are static/const variables stored on the stack/heap?

Again, the constness has nothing to do with the place where an object is stored. The standard doesn't say anything about that place, there's usually a dedicated area but this is a different and already answered question: where are static buffers allocated?

Community
  • 1
  • 1
effeffe
  • 2,821
  • 3
  • 21
  • 44
1

Are static/const variables stored on the stack/heap?

Well, no, they are part of the "global" space. Stack and Heap are for "dynamic" memory allocation, not static !

Hughenot
  • 148
  • 1
  • 6