# Need globals without name collisions? Static at file level!

In C programming, the `static` keyword can be used in different contexts. When `static` is used at the file level, also known as file scope or global scope, it gives the variable or function "internal linkage." This means that the variable or function is only visible within the file it is declared in, even though it retains its value or state across different function calls or throughout the program's execution.

Let's break this down with an example:

### Example Code

```c
// File: main.c

#include <stdio.h>

static int globalCounter = 0; // static variable at file scope

static void incrementCounter() { // static function
    globalCounter++;
}

int main() {
    printf("Counter: %d\n", globalCounter); // prints 0
    incrementCounter();
    printf("Counter: %d\n", globalCounter); // prints 1
    // The function and the variable are accessible here
    return 0;
}

// Another file, for instance, anotherFile.c, cannot access globalCounter or incrementCounter.
```

### Explanation

1. **Static Variable at File Scope (**`static int globalCounter = 0;`):
    
    * `globalCounter` is a global variable, but because it's declared as `static`, it can only be accessed within the file `main.c`.
        
    * It retains its value between different function calls within the same file.
        
    * It cannot be accessed or modified by other files, even if they are part of the same program.
        
2. **Static Function (**`static void incrementCounter()`):
    
    * This function is only visible within `main.c`. It cannot be called from other files.
        
    * Its purpose in this example is to increment the `globalCounter`.
        
3. **Access and Scope:**
    
    * Within `main.c`, both `globalCounter` and `incrementCounter` can be used freely.
        
    * If you try to use them in another file, such as `anotherFile.c`, the compiler will throw an error because these are not visible outside `main.c`.
        
4. **Benefits:**
    
    * This use of `static` helps in encapsulating the code. It restricts the scope of variables and functions, reducing potential conflicts, especially in large programs with multiple files.
        
    * It also aids in maintaining the state of variables across function calls without making them globally accessible.
        

This kind of scoping is particularly useful in larger projects where you want to avoid global namespace pollution and maintain a clean separation of components.