🌱 C Basics

Scope & lifetime: who sees what, and for how long

⏱ 14 min · free interactive lesson · quizzes, visualizations & a real compiler

Every variable in C answers two independent questions. Scope: from where in the code can I refer to it? Lifetime: for how long does its memory exist? Most of the time the two travel together — but the interesting corners of C are exactly where they split apart. First up: what a pair of braces — a block — does to a variable's visibility, including the sneaky case where one variable hides another behind the same name.

Block scope & shadowing

A variable declared inside { … } exists from its declaration to the closing brace — that region is its scope. Blocks nest, and an inner declaration with the same name shadows the outer one: the outer variable still exists, but its name is temporarily eclipsed.

#include <stdio.h>

int main(void) {
    int x = 1;
    printf("outer x: %d\n", x);
    {
        int x = 2;               /* shadows the outer x      */
        printf("inner x: %d\n", x);
        x = 99;                  /* changes ONLY the inner x */
    }                            /* inner x dies here        */
    printf("outer x: %d  (untouched)\n", x);
    return 0;
}

$ gcc shadow.c -o shadow && ./shadow
outer x: 1
inner x: 2
outer x: 1  (untouched)

Two historic keywords: auto and register

Ordinary locals are automatic — created on block entry, destroyed on exit, stack-dwelling. The keyword auto says exactly that… and since locals are automatic by default, nobody has typed it in fifty years. (Plot twist: C23 recycled auto for type inference, like C++.) Its sibling register once begged the compiler to keep a variable in a CPU register; modern optimizers ignore the hint entirely. Its one surviving effect: you may not take a register variable's address. Both keywords are museum pieces you must recognize, not use.

static locals: scope of an ant, lifetime of an elephant

Mark a local variable static and its scope stays tiny — just that block — but its lifetime becomes the whole program. It lives in the data segment (Part 0!), not the stack, is initialized exactly once before main even starts, and remembers its value between calls:

#include <stdio.h>

int next_id(void) {
    static int id = 100;   /* initialized ONCE, lives forever */
    id++;
    return id;
}

int main(void) {
    printf("%d\n", next_id());
    printf("%d\n", next_id());
    printf("%d\n", next_id());
    return 0;
}

$ gcc counter.c -o counter && ./counter
101
102
103
# a plain 'int id = 100;' would print 101 three times

Watch the initialization happen only once — the trace makes it obvious:

▶ This spot has an interactive trace widget — open the interactive lesson to play with it.

extern: one variable, many files

A variable declared outside every function is global: file-wide scope, program-long lifetime. To use one global across several .c files, exactly one file defines it, and the others declare it with the keyword extern — "it exists, but elsewhere; linker, please connect us":

/* ---- config.c ---- */
int max_users = 64;          /* THE definition: memory lives here */

/* ---- server.c ---- */
#include <stdio.h>
extern int max_users;        /* declaration: defined elsewhere    */

void report(void) {
    printf("limit: %d users\n", max_users);   /* same variable  */
}

This is the declaration-vs-definition split from the functions lesson, replayed for variables. And that's linkage in a nutshell — the linker matching names across files. One more twist: static on a global (or a function) means the opposite of extern — "private to this file, invisible to the linker". Same keyword, second job; Part 3's storage-classes lesson dissects it fully.

▶ This spot has an interactive editor widget — open the interactive lesson to play with it.

🎉 That wraps Part 1 — you can now write real, structured C programs. Ahead lies the part that gives C its reputation and its power: pointers and memory. Deep breath; it's more logical than the legends claim.