Kapitel 4: Variablen & Konstanten

Variablen sind das Gedächtnis deiner Objekte. In diesem Kapitel lernst du nicht nur, wie man Variablen anlegt, sondern vor allem wo, wie lange und wer darauf zugreifen darf. Wir erklären typische Anfängerfallen, zeigen viele Beispiele und bauen ein solides mentales Modell auf.

Weiter zu Kapitel 5

Als Nächstes: Funktionen richtig schreiben und benutzen.

4.1 Was ist eine Variable? (wirklich grundlegend)

Eine Variable ist ein benannter Speicherplatz für einen Wert. Stell dir eine Variable wie eine beschriftete Kiste vor: Der Name ist das Etikett, der Inhalt ist der Wert.

Wichtig ist: Der Datentyp bestimmt, was in die Kiste darf. Eine int-Kiste darf nur Zahlen enthalten, eine string-Kiste nur Text.


int hp;        // Kiste für eine Zahl
string name;  // Kiste für Text

Solange du nichts hineinlegst, ist die Kiste leer – aber sie existiert bereits.

4.2 Deklarieren vs. Initialisieren

Deklarieren heißt: der Variable einen Namen und Typ geben. Initialisieren heißt: ihr sofort einen Startwert geben.


// nur deklarieren
int hp;

// deklarieren + initialisieren
int hp = 100;

Beides ist erlaubt. Für Anfänger ist Initialisieren oft besser, weil du immer weißt, welchen Wert die Variable hat.

4.3 Globale Variablen (Objekt-Variablen)

Globale Variablen stehen außerhalb von Funktionen. Sie gehören dem Objekt selbst und existieren so lange, wie das Objekt im Speicher existiert.


int hp;
string name;

void create()
{
  hp = 100;
  name = "Ein alter Baum";
}

Diese Variablen kannst du in allen Funktionen des Objekts benutzen. Sie sind ideal für Zustände wie Lebenspunkte, Namen, Flags usw.

4.4 Lokale Variablen (Funktions-Variablen)

Lokale Variablen werden innerhalb einer Funktion definiert. Sie existieren nur während der Ausführung dieser Funktion.


void heal()
{
  int amount = 10;
  hp = hp + amount;
}

Sobald die Funktion endet, verschwindet amount. Sie ist außerhalb der Funktion unbekannt.

Merksatz: Lokale Variablen sind kurzlebig, globale Variablen langlebig.

4.5 Der häufigste Anfängerfehler: Versteckte Variablen

Dieser Fehler passiert extrem oft:


int hp = 100;

void damage()
{
  int hp = 10;
}

Hier gibt es zwei verschiedene Variablen mit dem Namen hp. Die lokale Variable in damage() verdeckt die globale.

Ergebnis: Die globalen Lebenspunkte ändern sich nicht – sehr verwirrend für Anfänger.

Regel: Verwende unterschiedliche Namen oder ändere bewusst die globale Variable.

4.6 Sichtbarkeit: public, protected, private (warum das wichtig ist)

Sichtbarkeit regelt, wer auf Variablen und Funktionen zugreifen darf. Das schützt dein Objekt vor falscher Benutzung.


public string name;
protected int hp;
private int secret;

public – jeder darf zugreifen (Standard)
protected – nur dieses Objekt und erbende Objekte
private – nur dieses Objekt selbst

Anfänger-Tipp: Mach Variablen lieber protected oder private und greife über Funktionen darauf zu.

4.7 Getter und Setter – sicherer Zugriff

Statt Variablen direkt zugänglich zu machen, nutzt man oft sogenannte Getter- und Setter-Funktionen.


protected int hp;

int query_hp()
{
  return hp;
}

void set_hp(int new_hp)
{
  hp = new_hp;
}

Vorteil: Du kannst später Regeln einbauen (z.B. kein negativer Wert, Maximalgrenze).

4.8 Lebensdauer von Variablen (Speicher verstehen)

Variablen leben nicht ewig – ihre Lebensdauer hängt davon ab, wo sie definiert sind.

Lokale Variablen → nur während der Funktion
Globale Variablen → solange das Objekt existiert

Wird ein Objekt zerstört (destruct()), verschwinden alle seine Variablen.

4.9 Initialisierung in `create()` (Best Practice)

Im Midgard MUD ist create() der Standard-Ort, um Objekt-Variablen zu initialisieren.


void create()
{
  hp = 100;
  name = "Ein Übungsobjekt";
}

So ist garantiert, dass jede neue Instanz (Master oder Clone) sauber startet.

4.10 Konstanten mit `#define`

Konstanten sind feste Werte, die sich nie ändern sollen. Sie machen Code lesbarer und wartbarer.


#define MAX_HP 100

void create()
{
  hp = MAX_HP;
}

Vorteil: Änderst du MAX_HP, passt sich der ganze Code an.

4.11 Typische Anfängerfehler (Checkliste)

Lokale und globale Variablen verwechseln
Variablen ohne Initialwert benutzen
Alles public machen
Unklare oder kurze Namen (x, tmp)

Wenn etwas „komisch“ wirkt: Prüfe zuerst die Variablen. In 50% der Fälle liegt der Fehler genau hier.

4.12 Zusammenfassung

Variablen sind Speicher für Werte
Ort der Definition ist entscheidend
Lokale Variablen sind kurzlebig
Globale Variablen gehören zum Objekt
Sichtbarkeit schützt vor Chaos

Wenn du dieses Kapitel wirklich verstanden hast, wirst du viele spätere Probleme automatisch vermeiden.

Ausblick

In Kapitel 5 lernst du Funktionen im Detail: Parameter, Rückgabewerte, Aufrufe, typische Muster und wie Funktionen im Midgard MUD sauber eingesetzt werden.