static-Variablen
Persistente lokale Variablen
static-Variablen ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Das Schlüsselwort static
Eine lokale static-Variable behält ihren Wert zwischen den Funktionsaufrufen. Ihre Lebensdauer umfasst das gesamte Programm.
#include <stdio.h>
void f(void) {
static int count = 0;
count++;
printf("count = %d\n", count);
}
int main(void) {
f();
f();
f();
return 0;
}Einmalige Initialisierung
Eine statische Variable wird nur beim ersten Aufruf der Funktion initialisiert. Bei späteren Aufrufen wird der Initialisierer übersprungen.
#include <stdio.h>
void f(void) {
static int x = 100;
printf("x = %d\n", x);
x += 10;
}
int main(void) {
f();
f();
return 0;
}Standardwert null
Im Gegensatz zu auto-Variablen beginnt eine static-Variable ohne Initialisierer mit dem Wert 0.
#include <stdio.h>
void f(void) {
static int n;
printf("n = %d\n", n);
n++;
}
int main(void) {
f();
f();
return 0;
}Aufrufe zählen
Eine klassische Anwendung besteht darin, zu zählen, wie oft eine Funktion aufgerufen wurde.
#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;
}Statische Lebensdauer, lokaler Gültigkeitsbereich
Eine lokale statische Variable hat weiterhin einen lokalen Gültigkeitsbereich. Nur die Funktion kann auf sie zugreifen, sie bleibt jedoch zwischen den Aufrufen erhalten.
#include <stdio.h>
void tick(void) {
static int t = 0;
t++;
printf("tick %d\n", t);
}
int main(void) {
tick();
tick();
return 0;
}static und auto im Vergleich
Zum Vergleich: Ein auto-Zähler wird bei jedem Aufruf zurückgesetzt, während ein static-Zähler weiterzählt.
#include <stdio.h>
void autoCounter(void) {
int c = 0;
c++;
printf("auto: %d\n", c);
}
int main(void) {
autoCounter();
autoCounter();
return 0;
}static auf Dateiebene
Auf Dateiebene bedeutet static interne Bindung: Die Variable ist auf ihre Quelldatei beschränkt.
#include <stdio.h>
static int secret = 7;
int main(void) {
printf("secret = %d\n", secret);
return 0;
}Caching mit static
Statische Variablen können einen berechneten Wert zwischenspeichern, sodass er nur einmal berechnet werden muss.
#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;
}Zustand akkumulieren
Mit lokalen statischen Variablen kann sich eine Funktion eine laufende Summe merken, ohne eine globale Variable zu benötigen.
#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;
}Ein Hinweis zur Vorsicht
Statischer Zustand macht eine Funktion von ihrer bisherigen Historie abhängig, wodurch sie schwieriger zu testen sein kann. Setzen Sie ihn bewusst ein.
#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;
}Kombination mit Schleifen
Eine lokale statische Variable innerhalb des Schleifenkörpers behält ihren Wert sowohl über die Iterationen als auch über die Funktionsaufrufe hinweg.
#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;
}Kurzer Test
Testen Sie Ihr Verständnis statischer Variablen.
Rückblick: statische Variablen
Sie haben lokale Variablen mit dauerhafter Speicherung kennengelernt.
- Lokale
static-Variablen leben während des gesamten Programms - Sie werden einmal initialisiert und standardmäßig auf 0 gesetzt
- Sie behalten ihren lokalen Gültigkeitsbereich, bewahren aber ihre Werte
- Auf Dateiebene erzeugt
staticeine interne Bindung - Sie eignen sich hervorragend für Zähler und Caches
Häufig gestellte Fragen
Ist die Lektion „static-Variablen“ kostenlos?
Ja — der vollständige Text von „static-Variablen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „static-Variablen“?
Persistente lokale Variablen Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C Academy zu starten?
Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „static-Variablen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?
Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.