> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C Static Function
A static function in C is a function declared with the `static` storage class specifier, which restricts its identifier to internal linkage. By default, functions in C possess external linkage, allowing the linker to resolve their symbols across multiple translation units. Applying the `static` keyword ensures the function's identifier is not exported to the global symbol table, confining its name visibility strictly to the translation unit (typically a `.c` source file and its included headers) in which it is defined. However, the function's executable code is not strictly bound to the unit; it can still be invoked from other translation units if a function pointer to it is explicitly passed outside the defining unit.
## Syntax
```c theme={"dark"}
static int calculate_value(int parameter1, int parameter2) {
return parameter1 + parameter2;
}
```
## Linkage and Symbol Resolution
When the C compiler processes a translation unit, it generates an object file containing a symbol table.
* **External Linkage (Default):** The compiler exports the function's symbol globally. The linker can bind references from other object files to this symbol.
* **Internal Linkage (`static`):** The compiler marks the symbol as local to the object file. The linker will not expose this symbol to other object files or attempt to match it against unresolved references in other translation units.
Because the symbol is not exported to the global symbol table, multiple static functions with the exact same identifier can be defined in different translation units without triggering a multiple definition error (`ld: duplicate symbol`) during the linking phase.
## Compilation Mechanics
```c theme={"dark"}
// translation_unit_A.c
static int calculate_offset(int base) {
return base + 10;
}
void process_data(void) {
(void)calculate_offset(5); // Valid: Invoked within the same translation unit
}
```
```c theme={"dark"}
// translation_unit_B.c
extern int calculate_offset(int base);
void execute(void) {
(void)calculate_offset(5); // Linker Error: Undefined reference to 'calculate_offset'
}
```
In the example above, `translation_unit_B.c` attempts to declare and call `calculate_offset`. Because the definition in `translation_unit_A.c` is declared `static`, the linker cannot resolve the reference, resulting in an `undefined reference` error.
## Compiler Optimization
Because the identifier of a static function cannot be referenced by name from outside its defining translation unit, the compiler generally has complete visibility of all potential direct call sites. This absolute knowledge allows the compiler to perform aggressive optimizations without requiring Link-Time Optimization (LTO).
* **Inlining:** The compiler can bypass standard calling conventions and inline the function directly into the caller's assembly code.
* **Dead Code Elimination:** If a static function is defined but never called directly within its translation unit, the compiler will typically strip it entirely from the resulting object file, reducing the final binary footprint.
* **Address-Taken Exception:** If the function's address is taken (e.g., assigned to a function pointer to be used as a callback), the compiler must assume the function can be invoked from anywhere. This forces the compiler to emit the function's body into the object file and disables aggressive optimizations like dead code elimination for that specific function, even if no direct calls exist within the translation unit.
Tired of Poor C Skills? Fix That With Deep Grasping!
Learn More
