C Academy · Lezione

Variabili static

Variabili locali persistenti

Variabili static è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

La parola chiave static

Una variabile locale static conserva il proprio valore tra le chiamate alla funzione. La sua durata coincide con quella dell’intero programma.

#include <stdio.h>
void f(void) {
    static int count = 0;
    count++;
    printf("count = %d\n", count);
}
int main(void) {
    f();
    f();
    f();
    return 0;
}

Inizializzata una sola volta

Una variabile static viene inizializzata solo la prima volta che la funzione viene eseguita. Le chiamate successive ignorano l’inizializzatore.

#include <stdio.h>
void f(void) {
    static int x = 100;
    printf("x = %d\n", x);
    x += 10;
}
int main(void) {
    f();
    f();
    return 0;
}

Zero per impostazione predefinita

A differenza delle variabili auto, una variabile static senza inizializzatore inizia con il valore 0.

#include <stdio.h>
void f(void) {
    static int n;
    printf("n = %d\n", n);
    n++;
}
int main(void) {
    f();
    f();
    return 0;
}

Conteggio delle chiamate

Un impiego classico consiste nel contare quante volte è stata invocata una funzione.

#include <stdio.h>
int nextId(void) {
    static int id = 0;
    return ++id;
}
int main(void) {
    printf("%d %d %d\n", nextId(), nextId(), nextId());
    return 0;
}

Durata statica, ambito locale

Una variabile locale static ha comunque un ambito locale. Solo la funzione può accedervi, ma il suo valore persiste tra le chiamate.

#include <stdio.h>
void tick(void) {
    static int t = 0;
    t++;
    printf("tick %d\n", t);
}
int main(void) {
    tick();
    tick();
    return 0;
}

static e auto a confronto

Confronti: un contatore auto si reimposta a ogni chiamata, mentre uno static accumula il valore.

#include <stdio.h>
void autoCounter(void) {
    int c = 0;
    c++;
    printf("auto: %d\n", c);
}
int main(void) {
    autoCounter();
    autoCounter();
    return 0;
}

static nell’ambito del file

Nell’ambito del file, static indica il collegamento interno: la variabile è privata del proprio file sorgente.

#include <stdio.h>
static int secret = 7;
int main(void) {
    printf("secret = %d\n", secret);
    return 0;
}

Memorizzazione nella cache con static

Le variabili static possono memorizzare nella cache un valore calcolato, in modo che venga calcolato una sola volta.

#include <stdio.h>
int getBase(void) {
    static int base = 0;
    if (base == 0) {
        base = 50;
        printf("computed once\n");
    }
    return base;
}
int main(void) {
    printf("%d\n", getBase());
    printf("%d\n", getBase());
    return 0;
}

Accumulo dello stato

Le variabili locali static consentono a una funzione di ricordare un totale progressivo senza usare una variabile globale.

#include <stdio.h>
int addToTotal(int v) {
    static int total = 0;
    total += v;
    return total;
}
int main(void) {
    printf("%d\n", addToTotal(10));
    printf("%d\n", addToTotal(5));
    return 0;
}

Una precauzione

Lo stato statico rende una funzione dipendente dalla propria cronologia, il che può rendere più difficili i test. Lo utilizzi consapevolmente.

#include <stdio.h>
int stepNumber(void) {
    static int s = 0;
    return ++s;
}
int main(void) {
    printf("step %d\n", stepNumber());
    printf("step %d\n", stepNumber());
    return 0;
}

Combinazione con i cicli

Una variabile locale static all’interno del corpo di un ciclo conserva il proprio valore sia tra le iterazioni sia tra le chiamate.

#include <stdio.h>
void run(void) {
    static int seen = 0;
    for (int i = 0; i < 2; i++)
        seen++;
    printf("seen = %d\n", seen);
}
int main(void) {
    run();
    run();
    return 0;
}

Verifica rapida

Verifichi la Sua comprensione delle variabili static.

Riepilogo: variabili static

Ha imparato a conoscere le variabili locali persistenti.

Le variabili locali static restano in memoria per l’intero programma
Vengono inizializzate una volta sola e hanno valore predefinito 0
Mantengono l’ambito locale, ma conservano i propri valori
Nell’ambito del file, static fornisce un collegamento interno
Sono ideali per contatori e cache

Domande Frequenti

La lezione «Variabili static» è gratuita?

Sì — il testo completo di «Variabili static» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Variabili static»?

Variabili locali persistenti Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Variabili static»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C Academy