C Global Variables, Scope, and static Keyword

Variable lifetime — when it's born and when it dies

Scope tells you where a variable is visible. Lifetime tells you when it's allocated in memory and when it gets freed.

Three kinds of lifetime

Kind	Where declared	Created when	Destroyed when
auto (local)	inside a function/block	when the block is entered	when the block is exited
global	outside any function	program start	program end
static	inside a function (with static)	program start	program end

void example(void) {
  int        a = 1;   // auto: created per call, gone on exit
  static int b = 1;   // static: created once, value persists
  a++; b++;
  printf("a=%d b=%d\n", a, b);
}
int main(void) {
  example();  // a=2 b=2
  example();  // a=2 b=3  ← a resets, b persists
  example();  // a=2 b=4
}

Visualize the lifetime

Click the button to watch how each variable changes as example() is called three times.

Step 0 / 9

Call state

Variables in memory

Output

Global variables — shared across every function

#include<stdio.h>

int counter = 0;        // global variable (outside main, etc.)

void increment(void) {
  counter++;            // usable without any argument
}

int main(void) {
  increment();
  increment();
  increment();
  printf("%d\n", counter); // → 3
}

Don't overuse them: globals are convenient, but it's hard to track down where they get modified, so they tend to invite bugs. Use them sparingly.

static variables — persist across calls

A regular local variable is destroyed as soon as the function returns, but adding static makes it live until the program ends.

void count(void) {
  static int n = 0;  // initialized to 0 only once
  n++;
  printf("Call count: %d\n", n);
}

int main(void) {
  count();  // → 1
  count();  // → 2
  count();  // → 3
}

When to use it: when you want to count how many times a function has been called, or remember a previous result — especially when you need state without the risks of a full global.

Memory layout — where do variables actually live?

Local, global, and static variables are stored in different memory regions. That's the real reason their lifetimes differ.

Memory map of a C program

When a C program runs, memory is divided into five regions:

High address ↑
📚 Stack
Local variables, function arguments, and return addresses.
Automatically allocated and freed with each function call.
↓ grows down ↓

        (free space)
      
↑ grows up ↑
🧱 Heap
Dynamically allocated via malloc / free.
Managed explicitly by the programmer.
🌐 BSS (Uninitialized Data)
Uninitialized global and static variables.
Automatically zeroed at program start.
💾 Data (Initialized)
Initialized global and static variables.
Live for the entire program.
📜 Text (Code)
Machine code and string literals.
Read-only.
Low address ↓

Code mapped to regions

#include <stdio.h>
#include <stdlib.h>

int g_init = 100;        // 💾 Data segment (initialized)
int g_uninit;            // 🌐 BSS (uninitialized → auto-zeroed)

void func(void) {
    int local = 5;        // 📚 Stack (new copy per call)
    static int s = 0;    // 💾 Data segment (created once)
    int *heap = malloc(sizeof(int)); // 🧱 Heap
    *heap = 42;
    free(heap);
}

int main(void) {
    func();
    return 0;
}

Variable types and their memory regions

Variable type	Declared in	Memory region	Created	Initial value
Local (auto)	Inside function	📚 Stack	On function call	Undefined (garbage)
Local (static)	Inside function + static	💾 Data / BSS	At program start	0 or specified value
Global (initialized)	Outside any function	💾 Data	At program start	Specified value
Global (uninitialized)	Outside any function	🌐 BSS	At program start	0 (automatic)
malloc'd	Dynamic inside function	🧱 Heap	On malloc call	Undefined (calloc: 0)
String literal	Source code "..."	📜 Text	At program start	Read-only

Function calls and the stack

Each function call pushes a stack frame. When the function returns, the frame is popped automatically.

void b(void) { int y = 20; }  // b's frame
void a(void) { int x = 10; b(); }  // a's frame
int main(void) { a(); return 0; }

Stack when main → a() → b() is in progress:

b() frame (y=20) ← top (pushed last)

a() frame (x=10)

main() frame

When b() returns, its frame is popped, then a() returns and its frame is popped too.

What is a stack overflow? Too much recursion or deeply nested calls can exhaust the stack region, triggering a segmentation fault.

Lifetimes, explained through memory regions

Short-lived = Stack

Local variables. Disappear the moment the function ends. Fast, but they can't persist across calls.

Long-lived = Data/BSS

Globals and statics. Live for the whole program. Always accessible, but overusing them hurts maintainability.

Flexible = Heap

Allocated with malloc and freed with free. You control both size and lifetime. Forget to free, and you get a memory leak.

Try it yourself — scope

scope.c

Output

Click Run...

💡 Try these ideas too

Modify a global variable from several different functions
Use a static local variable to track the number of calls
Shadow a global with a local variable of the same name
Define a const int global constant

Review Quiz

Check your understanding of this lesson.

Q1. What is the initial value of an int global variable?

Undefined

-1

Global variables are automatically initialized to 0. Local variables hold an indeterminate value unless you initialize them yourself.

Q2. What is the key property of a static variable?

Its value is retained after the function returns

It is accessible from other files

It runs faster

A static local variable keeps its value between calls, so the next invocation sees the value from the previous one.

Q3. Why is heavy use of global variables discouraged?

Because they use too much memory

Because they can be modified from anywhere, causing bugs

Because they slow the program down

Globals can be changed from anywhere in the program, which leads to unintended modifications and hard-to-find bugs.

Global Variables

Scope — where a variable is visible

Variable lifetime — when it's born and when it dies

Three kinds of lifetime

Visualize the lifetime

Global variables — shared across every function

static variables — persist across calls

Memory layout — where do variables actually live?

Memory map of a C program

Code mapped to regions

Variable types and their memory regions

Function calls and the stack

Lifetimes, explained through memory regions

Try it yourself — scope

Related lessons

Review Quiz

Q1. What is the initial value of an int global variable?

Q2. What is the key property of a static variable?

Q3. Why is heavy use of global variables discouraged?