Unit 18 – Lokale vs. globale Variablen

Ömer sagt:

Wo eine Variable lebt, bestimmt wo sie sichtbar ist. Lokale Variablen leben nur in ihrer Funktion. Globale Variablen sind überall sichtbar – aber das ist oft kein Vorteil! 🗺️

Lokale Variablen Globale Variablen Scope (Gültigkeitsbereich) Warum global vermeiden? Schatten-Variablen

🏠 Lokale Variablen – leben in ihrer Funktion

Lokale Variablen werden innerhalb einer Funktion deklariert. Sie existieren nur während der Funktionsausführung und sind danach weg:

🌍 Globaler Bereich

📦 Funktion: berechne()

int ergebnis = 0; ← nur hier sichtbar!

float zwischenwert; ← nur hier sichtbar!

📦 Funktion: main()

int x = 5; ← nur in main() sichtbar

int y = 3; ← nur in main() sichtbar

🌍 Globale Variablen – überall sichtbar

Globale Variablen werden außerhalb aller Funktionen deklariert. Alle Funktionen können sie lesen und verändern:

global_lokal.cC

#include <stdio.h>

int zaehler = 0;   // GLOBALE Variable – alle Funktionen sehen sie

void erhoehe() {
    zaehler++;        // globale Variable ändern
}

void zeige() {
    printf("Zähler: %d\n", zaehler); // globale Variable lesen
}

int main() {
    erhoehe();  erhoehe();  erhoehe();
    zeige();    // Ausgabe: Zähler: 3
    return 0;
}

⚖️ Lokal vs. Global – Vergleich

Eigenschaft	Lokal	Global
Wo deklariert?	Innerhalb einer Funktion	Außerhalb aller Funktionen
Wo sichtbar?	Nur in dieser Funktion	In allen Funktionen
Lebensdauer	Während Funktionsausführung	Gesamte Programmlaufzeit
Empfehlung	✅ Bevorzugen!	⚠️ Nur wenn nötig

⚠️ Warum globale Variablen vermeiden?

Jede Funktion kann sie verändern → schwer zu debuggen
Bei großen Programmen verliert man den Überblick
Funktionen werden von globalen Variablen abhängig → schwer zu testen
Zufällige Überschreibungen sind möglich

Faustregel: Verwende globale Variablen nur für echte Programmkonstanten (z.B. const int MAX = 100;).

🎭 Shadowing – Variablen gleichen Namens

shadowing.cC

int x = 100;    // globales x

void test() {
    int x = 42;  // lokales x – überschattet das globale!
    printf("%d\n", x); // gibt 42 aus, nicht 100!
}

int main() {
    printf("%d\n", x); // gibt 100 aus
    test();
    printf("%d\n", x); // gibt wieder 100 aus
    return 0;
}

▶ Ausgabe

100
42
100

✏️ Übungen

Übung 1

Lokal oder Global?

Klassifiziere jede Variable als lokal oder global und erkläre den Gültigkeitsbereich:

int punkte = 0;          // A
void ergebnis() {
    float schnitt = 2.5; // B
    punkte += 10;
}
int main() {
    int runde = 1;       // C
}

A (punkte):

B (schnitt):

C (runde):

Übung 2

Ausgabe nachverfolgen

Was gibt dieses Programm aus?

int wert = 10;
void verdoppele() { wert = wert * 2; }
void zeige()      { printf("%d\n", wert); }
int main() {
    zeige();
    verdoppele();
    zeige();
    verdoppele();
    zeige();
    return 0;
}

Ausgabe:

Übung 3 – Refaktorierung

Global → Lokal umschreiben

Schreibe diesen Code mit globaler Variable so um, dass die Variable lokal in main() ist und als Parameter übergeben wird:

int ergebnis = 0;
void addiere(int a, int b) { ergebnis = a + b; }
int main() { addiere(5, 3); printf("%d\n", ergebnis); }

/* Umgeschriebene Version – ohne globale Variable */ int addiere(int a, int b) { return ___; } int main() { int ergebnis = addiere(___, ___); printf("%d\n", ergebnis); return 0; }

Übung 4 – Bonus

Statischer Zähler

Eine static-Variable in einer Funktion behält ihren Wert zwischen Aufrufen. Schreibe eine Funktion zaehle_aufrufe() und beobachte das Verhalten:

#include <stdio.h> void zaehle_aufrufe() { static int zaehler = 0; /* wird nur EINMAL initialisiert! */ zaehler++; printf("Aufruf Nr. %d\n", zaehler); } int main() { zaehle_aufrufe(); /* Aufruf Nr. 1 */ zaehle_aufrufe(); /* Aufruf Nr. 2 */ zaehle_aufrufe(); /* Aufruf Nr. 3 */ return 0; }

static ist ein Mittelweg: die Variable lebt so lange wie ein globale, ist aber nur in der Funktion sichtbar. Ideal für Zähler, die Aufrufe merken sollen.