different types of Static in C

Question

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?

Answer 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 !

Answer 2

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().

Answer 3

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) 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?

Answer 4

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.)

Answer 5

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.