Lokale Variablen vs. Klassen-Member

Variablen werden im Code an unterschiedlichen Stellen angelegt, mal innerhalb, mal außerhalb von Funktionen. Worin liegt der Unterschied?

Der nachfolgende Artikel bezieht sich auf C#, in der Umgebung der Unity-GameEngine.

Variablen

Eine Variable ist ein Element der Programmierung bei der ein Speicherplatz festgelegt wird, um Daten über mehrere Befehle hinweg „festzuhalten“. Im Wesentlichen sind zwei Grundoperationen zu unterscheiden:

• Beim Deklarieren der Variable wird dem Programm mitgeteilt, dass der Speicherplatz überhaupt benötigt wird. Neben dem Namen wird zudem die Art der enthaltenen Daten angegeben.
  • Beispiel: int alter; legt einen Speicherplatz namens alter an, der sich eine Ganze Zahl (Integer) „merken“ kann.
  • Eine Variable kann und muss innerhalb ihres Gültigkeitsbereichs, nur einmal deklariert werden.
• Beim Zuweisen wird festgelegt, welche Daten in der Variablen enthalten sind.
  • Beispiel: alter=21; könnte z.B. das Alter einer Person von 21 Jahren festlegen.
  • Der Wert einer Variablen kann im Allgemeinen beliebig oft geändert und neu zugewiesen werden.

Member-Variablen

Umfangreichere Datenstrukturen wie z.B. die Eigenschaften einer Person werden in Klassen zusammengefasst:

class Person
{
    int alter;
    string name;
}

Die Klasse ist ein Datensatz, der eine Person beschreibt und zwar mit den Eigenschaften Alter und Name.

Um die „Startwerte“ festzulegen, die in diesen Variablen enthalten sind, können Zuweisungen direkt bei der Deklaration oder innerhalb einer Funktion wie z.B. BeiGeburtstag erfolgen:

class Person
{
    int alter=0;
    string name="Baby";
    
    ... BeiGeburtstag()
   {
        alter=alter+1;    // Das Alter erhöht sich um 1 Jahr
   }
}

Da die Variablen alter und name zur Struktur Person gehören, spricht man von Membervariablen, also „Mitgliedern“ der Klassenstruktur.

Sichtbarkeitsmodifikatoren public, private und protected

Membervariablen werden mit einem Sichtbarkeitsmodifikator dekoriert, der beeinflusst, welche Programmteile Zugriff auf die Variable haben:

class Person
{
    private int alter=0;
    public string name="Baby";  
    
    ... BeiGeburtstag()
   {
        alter=alter+1;    // Das Alter erhöht sich um 1 Jahr
   }
}

Neben gewissen Sicherheitsaspekten werden diese Sichtbarkeitsmodifikatoren dazu verwendet, um komplexen, modularen Code wartbarer zu halten. Sie helfen Abhängigkeiten nachzuvollziehen und zu erkennen welche Programmteile ’nur intern‘ verwendet werden.

• public erlaubt allen Code-Bereichen auf dieses Feld zuzugreifen.
• private erlaubt nur Zugriff von Funktionen, die innerhalb der selben Klassen deklariert sind. Auf alter kann z.B. nur die Funktion BeiGeburtstag zugreifen.
• protected sperrt (wie private) den Zugriff von anderen Klassen, erlaubt aber abgeleiteten Klassen (Einwohner als Erweiterung von Person) auf das Feld zuzugreifen.

Variablen die als Felder einer Klasse deklariert werden, bleiben im Speicher bestehen, so lange das Objekt (hier eine Person) auch im Speicher besteht. Es wäre folglich sehr ineffizient jeglichen Wert als Klassenfeld zu deklarieren.

Lokale Variablen

Variablen die innerhalb einer Funktion deklariert werden, sind auch nur dort präsent. Sie verfügen über keinen Sichtbarkeitsmodifikator, da sich die Sichtbarkeit aus dem Ort der Deklaration ergibt:

class Person
{
    private int alter=0;
    public string name="Baby";  
    
    ... Aktualisieren()
   {
        // Speicher für Jahre wird erst hier konsumiert
        int aktuellesJahr=2020;
        int geburtsJahr=1999;
        alter=aktuellesJahr-geburtsJahr;    // Das Alter errechnet sich
        // Speicher für Jahre wird hier wieder freigegeben
   } 
}

In diesem Beispiel errechnen wir das Alter in einer Aktualisierungsfunktion. Da wir die für die Berechnung nötigen Jahreszahlen nur kurzzeitig für das Ausrechnen benötigen, werden aktuellesJahr und geburtsJahr lokal innerhalb der Aktualisieren-Funktion angelegt. Dadurch wird der nötige Arbeitsspeicher erst bei Ausführung der jeweiligen Programmzeile angelegt und wieder freigegeben, wenn die Funktion zu Ende ist, also } erreicht wird.

Zusammenfassung

Lokale Variablen und Membervariablen unterscheiden sich vor allem durch die Dauer des Speicherverbrauchs im Codeverlauf und die Sichtbarkeit für andere Code-Teile.

Lokale Variablen werden innerhalb eines Code-Abschnitts angelegt und wieder freigegeben. Sie eignen sich für Kurzzeitspeicher, also wenn mal kurz was für eine Berechnung gespeichert werden muss, danach aber nicht mehr benötigt wird. Lokale Variablen sind nur für Code im selben Codeabschnitt/Block zugänglich.

Membervariablen sind ein Teil einer komplexeren Datenstruktur (Klasse), die im Speicher liegt, so lange das gesamte Objekt existiert. Sie eignen sich für Datenblöcke die längerfristig oder von mehreren verschiedenen Programmteilen benötigt werden. Welche Programmteile Zugriff auf die Membervariablen haben, wird durch die Sichtbarkeitsmodifikatoren public, private und protected gesteuert.

Dass die Sichtbarkeit von Membervariablen in Unity auch den Inspector beeinflusst ist übrigens eher ein zweitrangiger Nebeneffekt seitens Unity, nicht der allgemeinen C#-Sprache selbst.