C Academy · Lekcja

Zmienne static

Trwałe zmienne lokalne

Zmienne static to bezpłatna lekcja C Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C Academy zawiera 4 lekcji w sumie.

Słowo kluczowe static

Lokalna zmienna static zachowuje swoją wartość pomiędzy wywołaniami funkcji. Jej czas życia obejmuje cały program.

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

Inicjalizacja tylko raz

Zmienna statyczna jest inicjalizowana tylko przy pierwszym wykonaniu funkcji. Przy kolejnych wywołaniach inicjalizator jest pomijany.

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

Domyślne zero

W przeciwieństwie do zmiennych auto, zmienna static bez inicjalizatora zaczyna od wartości 0.

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

Zliczanie wywołań

Klasycznym zastosowaniem jest zliczanie liczby wywołań funkcji.

#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;
}

Czas życia static, zakres lokalny

Lokalna zmienna statyczna nadal ma zakres lokalny. Widzi ją tylko funkcja, ale wartość zmiennej jest zachowywana między wywołaniami.

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

static a auto

Porównajmy: licznik auto jest zerowany przy każdym wywołaniu, natomiast licznik static gromadzi wartość.

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

static w zakresie pliku

W zakresie pliku static oznacza powiązanie wewnętrzne: zmienna jest prywatna dla swojego pliku źródłowego.

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

Buforowanie za pomocą static

Zmienne statyczne mogą buforować obliczoną wartość, aby była obliczana tylko raz.

#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;
}

Gromadzenie stanu

Lokalne zmienne statyczne pozwalają funkcji pamiętać bieżącą sumę bez używania zmiennej globalnej.

#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;
}

Przestroga

Stan statyczny sprawia, że funkcja zależy od swojej historii, przez co może być trudniejsza do testowania. Należy używać go świadomie.

#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;
}

Łączenie z pętlami

Lokalna zmienna statyczna wewnątrz ciała pętli zachowuje wartość zarówno między iteracjami, jak i między wywołaniami.

#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;
}

Szybkie sprawdzenie

Proszę sprawdzić swoją wiedzę na temat zmiennych static.

Podsumowanie: zmienne static

Dowiedzieli się Państwo o trwałych zmiennych lokalnych.

Lokalne zmienne static istnieją przez cały czas działania programu
Są inicjalizowane raz, a ich domyślną wartością jest 0
Zachowują zakres lokalny, ale przechowują wartości między wywołaniami
W zakresie pliku static zapewnia powiązanie wewnętrzne
Doskonale nadają się do liczników i buforów

Często zadawane pytania

Czy lekcja „Zmienne static” jest bezpłatna?

Tak — pełny tekst „Zmienne static” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C Academy, przejdź na CoddyKit PRO. Kurs C Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zmienne static”?

Trwałe zmienne lokalne Ćwiczysz C Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C Academy?

Nie wymagamy żadnego doświadczenia. C Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Zmienne static”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C Academy?

Tak. Każda lekcja C Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C Academy