Variable (Programmierung)

Grundbegriff und Arten

Eine Variable ist in der Programmierung ein abstrakter Behälter für einen Wert, der während der Ausführung eines Computerprogramms auftritt. Normalerweise besitzt sie einen Namen im Quelltext und eine Adresse im Speicher. Anders als bei einer Konstante können sich der repräsentierte Wert und gegebenenfalls auch seine Größe zur Laufzeit ändern.

Bei einer Wertevariablen wird der Wert direkt gespeichert. Eine referenzielle Variable enthält dagegen die Speicheradresse eines Wertes, einer Funktion oder eines Objekts und wird deshalb auch Zeiger genannt. In C# ist etwa int j = 3 eine Wertevariable, während object o = new object() auf ein Objekt und Func<int> f = () => 3 auf eine Funktion verweist. const int i = 3 ist eine Konstante und keine Variable; object n = null bezeichnet eine Referenz auf das null-Objekt.

Verwendung und Bedeutung

Variablen erfüllen unterschiedliche Aufgaben:

• Eingabevariablen nehmen Werte auf, die von außen in ein Programm, eine Funktion oder eine Methode gelangen.
• Ausgabevariablen enthalten die Ergebnisse einer Berechnung.
• Referenzvariablen können als Eingabe und Ausgabe dienen, weil sich der referenzierte Wert während der Berechnung verändern lässt.
• Hilfsvariablen speichern vorübergehend benötigte Werte.
• Umgebungsvariablen repräsentieren äußere Randbedingungen eines Programms.
• Metasyntaktische Variablen dienen zur Benennung von Entitäten oder Teilen des Programmcodes.
• Daneben nennt der Artikel Laufzeitvariablen.

Programmiersprachen deuten Variablen unterschiedlich. In rein funktionalen Sprachen sind sie Bezeichner für Eingabeparameter; während der Berechnung eines Funktionswertes ändert sich ihr Wert nicht. Ein Ausdruck mit Variablen besitzt unabhängig von seiner Stelle im Programm stets denselben Wert. Diese Eigenschaft heißt referentielle Transparenz. In imperativen Sprachen kann sich ein Variablenwert dagegen während des Programmablaufs ändern. Derselbe Ausdruck kann daher zu verschiedenen Zeitpunkten oder an verschiedenen Programmstellen unterschiedliche Werte liefern.

Bei einer imperativen Variable sind vier Aspekte zu unterscheiden: der Speicherplatz, die darin gespeicherten Daten, seine Adresse und der Bezeichner, über den er angesprochen wird. Derselbe Bezeichner kann je nach Ort oder Zeitpunkt verschiedene Speicherplätze meinen; außerdem gibt es anonyme, also namenlose Variablen.

Bei einer Wertzuweisung hat ein Variablenname links und rechts unterschiedliche Bedeutungen. In x := x + 1 ist der L-Wert die Adresse von x, während der R-Wert den gespeicherten Inhalt bezeichnet. Die Anweisung liest den Inhalt, erhöht ihn um eins und speichert das Ergebnis wieder an der Adresse von x.

Variablen in einer Funktionsdeklaration heißen formale Parameter. Beim Funktionsaufruf werden ihnen Ausdrücke als tatsächliche Parameter zugeordnet. Verbreitete Übergabemechanismen sind die Übergabe durch Wert und die Übergabe durch Referenz.

Datentypen und Initialisierung

Jede Variable ist mit einem Datentyp, kurz Typ, verbunden. Er bestimmt, welche Operationen sinnvoll und zulässig sind, und kann auch die benötigte Speichergröße festlegen. Häufig gibt der Programmierer den Typ in einer Deklaration ausdrücklich an; in vielen Sprachen ist dies verpflichtend.

Andere Sprachen unterstützen implizite Deklarationen. In Fortran galt beispielsweise, dass Variablen mit einem Anfangsbuchstaben zwischen I und N den Typ INTEGER und alle übrigen den Typ REAL besitzen, sofern nichts anderes festgelegt wurde. Bei latenten Typen erkennt die Maschine den Typ bei der ersten Verwendung am Inhalt und führt ihn anschließend stillschweigend weiter. Durch Typinferenz kann ein Compiler einen nicht ausdrücklich genannten Typ aus den Typen erschließen, mit denen die Variable zusammenhängt.

In dynamisch typisierten Sprachen kann sich der Variablentyp erst zur Laufzeit ergeben und während der Ausführung ändern. Das Beispiel des Artikels zeigt eine JavaScript-Funktion show(value): Ist value eine Zahl, wird die Zeichenfolge " ist eine Zahl" angefügt; anschließend wird der Wert ausgegeben. Die Funktion kann sowohl mit 'Hallo Welt!' als auch mit 42 aufgerufen werden.

Vor ihrer Benutzung sollten Variablen initialisiert, also mit einem definierten Wert versehen werden. Dies geschieht entweder automatisch durch Standardwerte des Laufzeitsystems oder durch eine ausdrückliche Zuweisung. Initialisiert eine Sprache Variablen nicht automatisch, kann eine uninitialisierte Variable einen zufälligen Inhalt besitzen. Das Programm liefert dann möglicherweise falsche Ergebnisse oder stürzt ab. Scheint der Speicher noch einen passenden Inhalt aus einem früheren Programmdurchlauf zu enthalten, wird dies Speicherinterferenz genannt.

Blöcke, Sichtbarkeit und Bindung

Unterprogramme wie Prozeduren, Funktionen und Methoden können als besondere Formen eines Blocks verstanden werden. Ein Block darf eigene lokale Variablen besitzen, die von Variablen anderer Blöcke unterschieden werden. Globale Variablen stehen dagegen im ganzen Programm für alle Blöcke zur Verfügung. PHP kennt darüber hinaus superglobale Variablen, die für alle Programme verfügbar sind, die gleichzeitig von einem PHP-Interpreter bearbeitet werden.

Globale Variablen müssen nicht bei jedem Funktionsaufruf als Parameter übergeben werden, können jedoch leicht Fehler verursachen. Wird eine globale Variable für verschiedene Zwecke benutzt oder versehentlich überschrieben, können schwer auffindbare Probleme entstehen. Ebenso kann eine lokale Variable eine gleichnamige globale Variable verdecken. Erfahrene Entwickler verwenden globale Variablen deshalb nur auf modularer Ebene und wenn sie sich nicht vermeiden lassen.

Der Sichtbarkeitsbereich oder Scope ist der Programmabschnitt, in dem eine Variable sichtbar und nutzbar ist. Sichtbarkeitsbereiche müssen nicht zusammenhängend sein: Eine lokale Variable kann eine gleichnamige globale Variable innerhalb eines Blocks verdecken. Bindung bezeichnet dabei die Zuordnung eines Namens zur zugehörigen Variablen.

Bei lexikalischer oder statischer Bindung bestimmt der umgebende Quelltext diese Zuordnung. Die Bindungen eines Blocks sind durch dessen Struktur festgelegt, sodass sich das Verhalten einer Funktion anhand ihres Quelltextes verstehen lässt. Dies unterstützt modulare Programmierung. Beispiele für Sprachen mit lexikalischer Bindung sind C++, C, ML, Haskell, Python und Pascal.

Bei dynamischer Bindung bestimmt dagegen die Ausführungsschicht zur Laufzeit die Zuordnung. Neue Bindungen gelten, bis sie aufgehoben oder durch eine weitere dynamische Bindung verdeckt werden. Das Verhalten einer Funktion hängt dadurch von den direkt und indirekt aufrufenden Funktionen ab und lässt sich nicht allein statisch aus ihrem Text verstehen. Emacs Lisp und Logo verwenden dynamische Bindung. Perl und Common Lisp lassen für einzelne lokale Variablen eine Wahl zwischen beiden Regeln zu.

Beispiel für lexikalische und dynamische Bindung

In einem C- oder C++-Beispiel besitzt die globale Variable x den Wert 0. Die Funktion f() gibt x zurück. Die Funktion g() legt zwar eine lokale Variable x mit dem Wert 1 an, ruft aber anschließend f() auf. Wegen des lexikalischen Gültigkeitsbereichs sieht f() nur das globale x; g() liefert daher immer 0.

Perl kann mit my eine lexikalische lokale Variable und mit dem irreführenden Schlüsselwort local eine dynamische lokale Variable deklarieren. Verwendet g() die Deklaration my $x = 1, kann das aufgerufene f() dieses lokale $x nicht sehen und das Ergebnis ist wie im C-Beispiel 0. Verwendet g() dagegen local $x = 1, gilt die Bindung dynamisch. f() greift dann auf den in g() geltenden Wert zu und g() liefert 1. In der Praxis sollte man für Variablen in Perl in der Regel my verwenden.

Lebensdauer, Speicher und Namen

Die Lebensdauer einer Variablen ist der Zeitraum, in dem für sie Speicher reserviert ist. Wird dieser Speicher freigegeben, „stirbt“ die Variable und kann nicht mehr benutzt werden. Lokale Variablen werden normalerweise bei jedem Funktionsaufruf neu erzeugt und beim Verlassen der Funktion freigegeben. Häufig liegen sie auf einem Stapelspeicher: Beim Betreten eines Blocks wird ein Aktivierungsblock auf dem Laufzeitstapel angelegt und beim Verlassen wieder entfernt. Solche Variablen heißen deshalb auch automatische Variablen.

In C begrenzt der Zusatz static bei einer lokalen Deklaration die Sichtbarkeit auf den Namensraum der Funktion, verlängert die Lebensdauer aber auf die einer globalen Variablen. Beim nächsten Eintritt in die Funktion besitzt eine solche Variable daher wieder den Wert, den sie am Ende des vorherigen Aufrufs hatte.

Viele Implementierungen speichern lokale Variablen eines Funktionsaufrufs auf dem Aufrufstapel und geben den Speicher bei der Rückkehr automatisch frei. Große oder beim Kompilieren noch unbekannt große Werte werden häufig über Referenzvariablen verwaltet. Der Zeiger enthält dabei die Position eines Wertes, der in einem Heap genannten Speicherbereich liegt.

Für jedes Datenobjekt muss Speicher reserviert und später wiederverwendbar gemacht werden. In Sprachen mit Garbage Collector, etwa C#, Java oder Python, gibt die Laufzeitumgebung Objekte automatisch frei, wenn vorhandene Variablen nicht mehr auf sie verweisen können. In C oder C++ müssen Programm und Programmierer Speicher ausdrücklich anfordern und wieder freigeben. Geschieht dies nicht, entstehen Speicherverluste, durch die der Heap während der Ausführung aufgebraucht werden kann. Bei dynamischen Datenstrukturen müssen Garbage Collectors außerdem berücksichtigen, dass eventuell nur ein Teil des über eine Variable erreichbaren Speichers freigegeben werden darf.

Variablennamen sollten möglichst selbsterklärend oder „sprechend“ sein, auch wenn sie dadurch länger werden. Einheitliche Namenskonventionen verbessern Lesbarkeit und Wartbarkeit; moderne Editoren verringern den Schreibaufwand. Nach dem Kompilieren ist der Programmcode weitgehend oder vollständig unabhängig von den gewählten Namen.