imported>SchlurcherBot: Bot: http → https

2026-01-25T14:24:48Z

Bot: http → https

Neue Seite

In der [[Programmierung]] ist eine '''Variable''' ein abstrakter Behälter für einen Wert, der bei der Ausführung eines [[Computerprogramm]]s auftritt. Im Normalfall wird eine Variable im [[Quelltext]] durch einen Namen bezeichnet und hat eine [[Speicheradresse|Adresse]] im Speicher des Computers.

Der durch eine Variable repräsentierte Wert und gegebenenfalls auch die Größe kann – im Unterschied zu einer [[Konstante (Programmierung)|Konstante]] – zur [[Laufzeit (Informatik)|Laufzeit]] des Rechenprozesses verändert werden.

== Arten von Variablen ==
Grundsätzlich unterscheidet man zwischen ''Wertevariablen'' und ''referenziellen Variablen''. In einer Wertevariablen wird ein Wert direkt abgelegt, während eine referenzielle Variable als Wert die [[Speicheradresse]] des eigentlichen Wertes, einer [[Funktion (Programmierung)|Funktion]] oder eines [[Objekt (Programmierung)|Objektes]] enthält. Deshalb werden referenzielle Variablen auch als [[Zeiger (Informatik)|Zeiger]] bezeichnet.

'''Beispiele in der [[Programmiersprache]] [[C-Sharp|C#]]'''
<syntaxhighlight lang="csharp">
const int i = 3; // Konstante; keine Variable
int j = 3; // Wertevariable
object k = (object)3; // referenzielle Variable auf einen Wert
object o = new object(); // referenzielle Variable auf ein Objekt
object n = null; // referenzielle Variable auf das null-Objekt (Zeiger auf Speicheradresse 0)
Func<int> f = () => 3; // referenzielle Variable auf eine Funktion
</syntaxhighlight>

== Verwendung von Variablen ==
Es lassen sich verschiedene Arten der Verwendung von Variablen unterscheiden:
* ''Eingabevariablen'' erhalten Werte, die von außen ins [[Computerprogramm|Programm]], die [[Funktion (Programmierung)|Funktion]] oder [[Methode (Programmierung)|Methode]] eingegeben werden (siehe [[Parameter (Informatik)|Parameter]]).
* ''Ausgabevariablen'' enthalten später die Resultate der Rechnung.
* ''Referenzvariablen'' ([[Zeiger (Informatik)|Zeiger]]) dienen sowohl als Eingangs- als auch Ausgangsvariable. Der Wert kann während der Rechnung verändert werden.
* ''Hilfsvariablen'' nehmen Werte auf, die im Verlauf der Rechnung benötigt werden.
* ''[[Umgebungsvariable]]n'' repräsentieren die äußeren Randbedingungen eines Programms.
* ''[[Metasyntaktische Variable]]n'' dienen zur bloßen Benennung von Entitäten oder Teilabschnitten des [[Programmcode]]s.
* ''Laufzeitvariablen''<ref>[https://www.c-plusplus.net/forum/topic/217676/laufzeitvariable Festlegen und Löschen von Laufzeitvariablen] – ein Beitrag im ''C++-Community-Forum'' (die betreffende Seite wurde zuletzt geändert am 10. Juli 2008); mit einem [[Zitat]] vom ''[[Visual Studio]] Analyzer'', wo es heißt: {{"|Laufzeitvariablen sind Name/Wert-Paare, die von Ereignisabonnenten festgelegt und von Ereignisquellen gelesen werden.
Das Verwenden von Laufzeitvariablen hilft beim Sammeln genauer Einzelheiten über bestimmte Ereignisse.}}</ref>

== Sichtweisen von Variablen ==
Das Konzept der Variablen wird von [[Programmiersprache]]n unterschiedlich interpretiert:
* in einer rein [[Funktionale Programmierung|funktionalen Programmiersprache]] sind Variablen einfach nur [[Bezeichner]], das heißt, sie werden wie im [[Lambda-Kalkül]] nur dazu verwendet, die Eingabeparameter für eine [[Funktion (Programmierung)|Funktion]] zu bezeichnen. Während der Berechnung eines Funktionswerts ändert sich der Wert der Variablen deshalb nicht. Ein [[Ausdruck (Programmierung)|Ausdruck]] mit Variablen hat stets den gleichen Wert, unabhängig davon, an welcher Stelle im [[Computerprogramm|Programm]] er auftritt. Diese Eigenschaft ist unter dem Begriff [[referentielle Transparenz]] bekannt.
* in einer [[Imperative Programmierung|imperativen Programmiersprache]] kann sich dagegen der Wert einer Variablen während des [[Programmablauf]]s ändern. Der gleiche Ausdruck mit Variablen kann deshalb an verschiedenen Stellen des Programms oder zu verschiedenen Zeiten in der Programmausführung ganz unterschiedliche Werte haben.
Dementsprechend definieren verschiedene Programmiersprachen den Begriff der Variablen ganz unterschiedlich. Im Fall von [[Java (Programmiersprache)|Java]] heißt es:
{{Zitat
|Text=Eine Variable ist ein Speicherplatz.
|ref=<ref>Tim Lindholm, Frank Yellin: ''The Java Virtual Machine Specification''. Addison-Wesley, 1996: “A variable is a storage location.”</ref>}}

In der Sprachdefinition von [[Scheme]] heißt es dagegen
{{Zitat
|Text=Scheme erlaubt es, dass Bezeichner für Speicherplätze stehen, die Werte enthalten.<br />
Solche Bezeichner heißen Variablen.
|ref=<ref>Michael Sperber, William Clinger, R. K. Dybvig, Matthew Flatt, Anton van Straaten: ''Report on the Algorithmic Language Scheme.'' Revised (5.97): “Scheme allows identifiers to stand for locations containing values. These identifiers are called variables.”</ref>}}

Allgemein müssen für eine Variable in einer [[Imperative Programmiersprache|imperativen Programmiersprache]] vier Aspekte unterschieden werden:
* der Speicherplatz selbst als Behältnis für Daten,
* die in dem Speicherplatz abgelegten Daten,
* die [[Speicheradresse|Adresse]] des Speicherplatzes und
* der Bezeichner, unter dem der Speicherplatz angesprochen werden kann.
Kompliziert wird die Situation außerdem dadurch, dass unter einem bestimmten Bezeichner an verschiedenen Stellen des Programms oder zu verschiedenen Zeiten in der Programmausführung unterschiedliche Speicherplätze angesprochen sein können und dass es auch anonyme, also namenlose Variablen gibt.

=== L-Wert und R-Wert von Variablen ===
Typisch für [[imperative Programmiersprache]]n ist, dass ein [[Bezeichner]] auf der linken Seite einer [[Wertzuweisung]] eine andere Bedeutung („L-Wert“) hat als auf ihrer rechten Seite („R-Wert“). Die Anweisung
<syntaxhighlight lang="text">
x := x + 1
</syntaxhighlight>
bedeutet: „Nimm den ''Wert'' der Variablen mit dem Namen <code>x</code>, erhöhe ihn um eins und speichere dies an die ''Adresse'' von <code>x</code>.“ Der L-Wert einer Variablen ist also ihre Adresse, der R-Wert ihr Inhalt.

=== Variablen als Parameter von Funktionen ===
Auch die [[Parameter (Informatik)|Parameter]] einer [[Funktion (Programmierung)|Funktion]] werden in deren [[Deklaration (Programmierung)|Deklaration]] durch Variablen repräsentiert, die dann ''formale Parameter'' heißen. Beim Aufruf der Funktion werden den formalen Parametern dann [[Ausdruck (Programmierung)|Ausdrücke]] als ''tatsächlicher Parameter'' zugeordnet. Für die Übergabe der tatsächlichen Parameter an die Funktion gibt es unterschiedliche Mechanismen. Verbreitet sind die [[Wertparameter|Übergabe durch Wert]] und die [[Referenzparameter|Übergabe durch Referenz]].

== Typen von Variablen ==
Mit jeder Variablen in einem [[Computerprogramm|Programm]] ist notwendigerweise ein bestimmter [[Datentyp]] (kurz: ''Typ'') verbunden. Dies ist schon allein deshalb notwendig, weil nur der Datentyp festlegt, welche [[Operation (Informatik)|Operationen]] auf und mit der Variablen sinnvoll und zulässig sind. Der Datentyp einer Variablen kann auch die Speichergröße der Variablen festlegen. In der Regel hat der [[Programmierer]] die Möglichkeit, in einer [[Deklaration (Programmierung)|Deklaration]] diesen Typ festzulegen. In vielen [[Programmiersprache]]n ist eine solche explizite Deklaration sogar verpflichtend. Andere Programmiersprachen bieten ''implizite Deklarationen'', die dann verwendet werden, wenn keine expliziten Deklarationen vorhanden sind. So kannte [[Fortran]] die Konvention, dass Variablen, deren Namen mit Buchstaben zwischen <code>I</code> und <code>N</code> beginnen, vom Typ <code>INTEGER</code> sind und alle anderen vom Typ <code>REAL</code>, sofern nichts anderes festgelegt wird. Andere Programmiersprachen kennen sogenannte ''latente'' Typen. Hier sind Deklarationen nicht nötig, sondern die Maschine erkennt den Typ einer Variablen bei ihrer ersten Verwendung an ihrem Inhalt und führt diesen Typ dann stillschweigend weiter mit. In manchen Programmiersprachen kann der nicht explizit angegebene Typ einer Variablen unter gewissen Voraussetzungen auch vom [[Compiler]] mittels [[Typinferenz]] anhand anderer Typen, mit denen die Variable in einem Zusammenhang steht, erschlossen werden.

In [[Dynamische Typisierung|dynamisch typisierten Programmiersprachen]] kann sich der Typ einer Variablen erst zur [[Laufzeit (Informatik)|Laufzeit]] eines Programmes ergeben und auch während der Programmausführung ändern. Folgendes Beispiel in [[JavaScript]] illustriert dies:
<syntaxhighlight lang="javascript">
function show(value) {
if (typeof value === 'number')
value += " ist eine Zahl";

console.log(value);
}

show('Hallo Welt!');
show(42);
</syntaxhighlight>

=={{Anker|Lokale Variable}} Variablen in einer Blockstruktur ==
Ein wichtiges Konzept von [[Programmiersprache]]n ist das [[Unterprogramm]], ob es nun [[Prozedur (Programmierung)|Prozedur]], [[Funktion (Programmierung)|Funktion]], [[Objektorientierte Programmierung#Methoden|Methode]] oder noch anders heißt. Die allgemeinste Form dieses Konzepts ist der in der Programmiersprache [[Algol 60]] erstmals eingeführte ''Block''. Praktisch alle Programmiersprachen, die dieses Konzept in irgendeiner Form anbieten, erlauben es, dass Blöcke ihre eigenen Variablen besitzen, die sich von den Variablen anderer Blöcke eindeutig unterscheiden lassen. Solch eine Variable heißt '''''lokale'' Variable'''. Eine Variable, die im ganzen [[Computerprogramm|Programm]] für alle Blöcke zur Verfügung steht, heißt '''''globale'' Variable'''. Die Programmiersprache [[PHP]] kennt sogar den Begriff der ''superglobalen'' Variablen, die für alle Programme verfügbar ist, die zur selben Zeit von einem PHP-[[Interpreter]] bearbeitet werden.

Globale Variablen sind scheinbar bequem, weil sie im ganzen Programm [[Sichtbarkeit (Programmierung)|sichtbar]] sind. Es ist nicht notwendig, sie beim Aufruf einer Funktion als [[Parameter (Informatik)|Parameter]] zu übergeben. Sie werden aber auch leicht zur Fehlerquelle, wenn man zum Beispiel eine globale Variable versehentlich oder sogar bewusst für verschiedene Zwecke benutzt.

Auch kann es passieren, dass man eine lokale Variable mit dem Namen der globalen Variablen verwendet, von dem man annimmt, dass er im Programm bisher noch nicht benutzt wurde. Wenn es diesen Namen aber schon als Variable mit passendem [[Datentyp|Typ]] gibt, sofern dieser überhaupt vom [[Compiler]] oder vom [[Laufzeitsystem]] geprüft wird, dann wird deren Wert unkontrolliert überschrieben und umgekehrt. Ein schwer zu findender Fehler ist oft die Folge.

Erfahrene [[Softwareentwickler|Entwickler]] verwenden globale Variablen nur auf [[Modul (Software)|modularer]] Ebene und nur dann, wenn es sich nicht vermeiden lässt.

=== Sichtbarkeitsbereich von Variablen (Scope) ===
Unter dem [[Sichtbarkeit (Programmierung)|Sichtbarkeitsbereich]] (englisch ''scope'') einer Variablen versteht man den Programmabschnitt, in dem die Variable nutzbar und sichtbar ist. Da eine lokale Variable in den meisten [[Programmiersprache]]n den gleichen Namen tragen darf wie eine globale Variable, sind Sichtbarkeitsbereiche nicht notwendig zusammenhängend: Durch die [[Deklaration (Programmierung)|Deklaration]] einer lokalen Variable wird die gleichnamige globale Variable für einen bestimmten Block „verdeckt“, das heißt, sie ist in diesem Block nicht sichtbar.

Die ''Sichtbarkeitsregeln'' können auf zwei unterschiedliche sich gegenseitig ausschließende Arten festgelegt werden. Dabei ist das Konzept der ''Bindung'' wichtig. Bindung bedeutet hier die Zuordnung eines bestimmten Namens zu der damit verbundenen Variablen.

* ''lexikalisch'' (oder ''statisch''), das heißt, der umgebende [[Quelltext]] bestimmt die Bindung
* ''dynamisch'', das heißt, die Ausführungsschicht zur [[Laufzeit (Informatik)|Laufzeit]] des Programms bestimmt die Bindung.

Im Fall einer lexikalischen Bindung sind die Bindungen für einen ganzen Block immer die gleichen, weil sie allein durch die [[Blockstruktur]] vorgegeben sind. Man kann daher allein durch Analyse des Quelltextes einer [[Funktion (Programmierung)|Funktion]] verstehen, wie sich die Funktion verhält. Dieses Konzept unterstützt daher [[modulare Programmierung]].

Bei dynamischen Bindungsregeln können zur Laufzeit immer neue Bindungen eingeführt werden. Diese gelten dann so lange, bis sie explizit aufgehoben werden oder durch eine neue [[dynamische Bindung]] verdeckt werden. Man kann daher durch Analyse des Programmtextes einer Funktion nicht notwendigerweise verstehen, wie sich diese verhält. Selbst die Analyse des gesamten Programmtextes eines Programms hilft nicht. Es lässt sich statisch nicht verstehen, wie sich die Funktion verhält. Ihr Verhalten hängt von den jeweiligen (direkt und indirekt) aufrufenden Funktionen ab. Dies widerspricht dem Konzept des modularen Programmierens.

Die meisten modernen Programmiersprachen unterstützen nur lexikalische Bindung, zum Beispiel [[C++]], [[C (Programmiersprache)|C]], [[ML (Programmiersprache)|ML]], [[Haskell (Programmiersprache)|Haskell]], [[Python (Programmiersprache)|Python]], [[Pascal (Programmiersprache)|Pascal]]. Einige wenige unterstützen nur dynamische Bindung, zum Beispiel [[Emacs Lisp]], [[Logo (Programmiersprache)|Logo]], und einige, zum Beispiel [[Perl (Programmiersprache)|Perl]] und [[Common Lisp]], erlauben dem [[Programmierer]], für jede lokale Variable festzulegen, ob sie nach lexikalischen (statischen) oder dynamischen Regeln gebunden sein soll.

[[Datei:Range of Variables.png|Verschiedene Gültigkeitsbereiche von Variablen]]

===={{Anker|Gültigkeitsbereich}} Beispiel lexikalisch im Gegensatz zu dynamisch ====
[[C++]] und [[C (Programmiersprache)|C]] verwenden lexikalische (statische) '''Gültigkeitsbereiche''':
<syntaxhighlight lang="c">
int x = 0;
int f() { return x; }
int g() { int x = 1; return f(); } /* g() => 0 */
</syntaxhighlight>

Im obigen Programmfragment ergibt <code>g()</code> immer 0 (den Wert der globalen Variablen <code>x</code>, nicht den Wert der lokalen Variablen <code>x</code> in <code>g()</code>). Dies ist so, weil in <code>f()</code> immer nur das globale <code>x</code> sichtbar ist.

In [[Perl (Programmiersprache)|Perl]] können lokale Variablen lexikalisch (statisch) mit dem Schlüsselwort <code>my</code> oder dynamisch mit dem irreführenden [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>local</code> deklariert werden.<ref>[https://www.perl.com/doc/FAQs/FAQ/oldfaq-html/Q4.3.html ''What’s the difference between dynamic and static (lexical) scoping?''] Perl FAQ 4.3</ref> Das folgende Beispiel entspricht dem obigen in C:

<syntaxhighlight lang="perl">
$x = 0;
sub f { return $x; }
sub g { my $x = 1; return f(); }
print g()."\n";
</syntaxhighlight>

Dieses Beispiel benutzt <code>my</code>, um <code>$x</code> in <code>g()</code> einen lexikalischen (statischen) [[Sichtbarkeit (Programmierung)|Sichtbarkeitsbereich]] zu geben. Daher wird <code>g()</code> immer 0 ergeben. <code>f()</code> kann <code>g()</code>’s <code>$x</code> nicht sehen, obwohl dies zum Zeitpunkt, zu dem <code>f()</code> aufgerufen wird, noch existiert.

<syntaxhighlight lang="perl">
$x = 0;
sub f { return $x; }
sub g { local $x = 1; return f(); }
print g()."\n";
</syntaxhighlight>

Dieses Beispiel benutzt <code>local</code>, um <code>$x</code> in <code>g()</code> einen dynamischen Sichtbarkeitsbereich zu geben. Somit kann <code>f()</code> den lokal, in <code>g()</code>, geltenden Wert von <code>$x</code> verwenden und <code>g()</code> liefert den Wert 1.

In der Praxis sollte man in der Regel für Variablen in Perl "<code>my</code>" verwenden.

==={{Anker|Automatische Variable}} Lebensdauer von Variablen ===
Unter der Lebensdauer einer Variablen versteht man den Zeitraum, in dem die Variable [[Speicherplatz]] reserviert hat. Wird der Speicherplatz für andere Zwecke wieder freigegeben, so „stirbt“ die Variable und ist nicht mehr nutzbar. Lokale Variablen werden bei jedem Aufruf der [[Funktion (Programmierung)|Funktion]] erstellt. In der Regel wird der Speicherplatz beim Verlassen der Funktion wieder freigegeben. [[Sichtbarkeit (Programmierung)|Sichtbarkeitsbereich]] und Lebensdauer von Variablen sind in klassischen blockstrukturierten [[Programmiersprache]]n so aufeinander abgestimmt, dass Speicherplatz für eine Variable nur so lange zugeordnet sein muss, wie Code aus dem Sichtbarkeitsbereich ausgeführt wird. Als Konsequenz davon lässt sich eine besonders einfache Art der Speicherverwaltung verwenden: Lokale Variablen werden automatisch zur [[Laufzeit (Informatik)|Laufzeit]] auf einem [[Stapelspeicher]] angelegt, sobald ein Block betreten wird. Bisweilen werden diese Variablen daher '''''automatische Variablen''''' genannt. Technisch gesprochen wird ein ''Aktivierungsblock'' auf einem ''Laufzeitstapel'' angelegt, der beim Verlassen des Blocks wieder entfernt wird.

In manchen Programmiersprachen, zum Beispiel [[C (Programmiersprache)|C]], gibt es einen Zusatz <code>static</code> bei der [[Deklaration (Programmierung)|Deklaration]], der nur die Sichtbarkeit einer Variablen auf den [[Namensraum]] der Funktion einschränkt, nicht aber ihre Lebensdauer. Die Sichtbarkeit einer solchen Variablen verhält sich also wie die einer lokalen Variablen, die Lebensdauer dagegen wie die einer globalen, das heißt, beim Eintritt in die sie umschließende Funktion hat sie exakt den gleichen Wert wie am Ende des letzten Aufrufs der Funktion. Auf der Implementierungsseite sind dafür keine besonderen Vorrichtungen notwendig: Die Variable wird einfach im Aktivierungsblock des Hauptprogramms angelegt.

=== Speicherzuweisung ===
Die Besonderheiten der Variablenzuweisung und die Darstellung ihrer Werte variieren stark, sowohl zwischen [[Programmiersprache]]n als auch zwischen [[Implementierung]]en einer bestimmten Sprache. Viele Sprachimplementierungen weisen Platz für lokale Variablen zu, deren Umfang für einen einzelnen Funktionsaufruf auf dem [[Aufrufstapel]] gilt und deren Speicher bei der Rückkehr der Funktion automatisch zurückgefordert wird. Im Allgemeinen wird bei der Namensbindung der Name einer Variablen an die Adresse eines bestimmten Blocks im Speicher gebunden, und [[Operation (Informatik)|Operationen]] an der Variablen manipulieren diesen Block. Das Referenzieren ist häufiger bei Variablen, deren Werte beim [[Kompilieren]] des Codes große oder unbekannte Größen haben. Solche Referenzvariablen ([[Zeiger (Informatik)|Zeiger]]) verweisen auf die Position des Werts, anstatt den Wert selbst zu speichern, der aus einem Speicherbereich zugewiesen wird, der als [[Heap (Datenstruktur)|Heap]] bezeichnet wird.

Gebundene Variablen haben Werte. Ein Wert ist jedoch eine Abstraktion. In der Implementierung wird ein Wert durch ein Datenobjekt dargestellt, das irgendwo gespeichert ist. Das [[Computerprogramm|Programm]] oder die [[Laufzeitumgebung]] muss Speicher für jedes Datenobjekt reservieren und, da der Speicher endlich ist, sicherstellen, dass dieser Speicher zur Wiederverwendung bereitgestellt wird, wenn das [[Objekt (Programmierung)|Objekt]] nicht mehr zur Darstellung des Werts einer Variablen benötigt wird.

Vom Heap zugewiesene Objekte müssen zurückgefordert werden, insbesondere wenn die Objekte nicht mehr benötigt werden. In einer Programmiersprache mit [[Garbage Collection|Garbage Collector]], zum Beispiel [[C-Sharp|C#]], [[Java (Programmiersprache)|Java]] oder [[Python (Programmiersprache)|Python]], fordert die Laufzeitumgebung Objekte automatisch zurück, wenn vorhandene Variablen nicht mehr auf sie verweisen können. In Programmiersprachen ohne Garbage Collector, zum Beispiel [[C (Programmiersprache)|C]] oder [[C++]], muss das Programm und der [[Programmierer]] explizit Speicher zuweisen und ihn später freigeben, um seinen Speicher zurückzugewinnen. Andernfalls kommt es zu Speicherverlusten, bei denen der Heap während der Programmausführung aufgebraucht wird.

Wenn sich eine Variable auf eine dynamisch erstellte [[Datenstruktur]] bezieht, kann auf einige ihrer Komponenten nur indirekt über die Variable zugegriffen werden. Unter solchen Umständen müssen Garbage Collectors einen Fall behandeln, in dem nur ein Teil des von der Variablen erreichbaren Speichers zurückgefordert werden muss.

== Namenswahl ==
Die Wahl von Variablennamen bleibt meist dem [[Programmierer]] überlassen. Zur Vereinfachung der Nachvollziehbarkeit der [[Quelltext]]e empfiehlt es sich, möglichst ''selbsterklärende Variablennamen'' oder auch sogenannte ''[[Sprechender Name#Sprechende Namen in der Programmierung|sprechende Variablennamen]]'' zu verwenden, selbst wenn dies zu recht langen [[Bezeichner]]n führt.<ref>{{Literatur |Autor=N. Gorla, A. C. Benander, B. A. Benander |Hrsg=IEEE |Titel=Debugging Effort Estimation Using Software Metrics |Sammelwerk=IEEE Transactions on Software Engineering |Band=16 |Nummer=2 |Datum=1990-02 |Seiten=223–231 |Sprache=en |DOI=10.1109/32.44385}}</ref> [[Namenskonvention (Datenverarbeitung)|Namenskonventionen]] für Variablen verbessern die Lesbarkeit und [[Programmierung#Wartbarkeit|Wartbarkeit]] der Quelltexte. Moderne [[Editor (Software)|Editoren]] haben Vorrichtungen, um den Schreibaufwand auch bei langen Variablennamen zu reduzieren. Nach der [[Compiler|Kompilierung]] ist der [[Maschinensprache|Programmcode]] weitgehend oder sogar vollständig unabhängig von den verwendeten Variablennamen.

== Initialisierung ==
Variablen sollten vor ihrer Benutzung initialisiert werden, das heißt, einen definierten Wert zugewiesen bekommen. Dies kann durch die Vergabe von Standardwerten durch das [[Laufzeitsystem]] der verwendeten [[Programmiersprache]] geschehen oder durch explizite Zuweisung eines Wertes an die Variable.

Bei Programmiersprachen, die nicht automatisch alle verwendeten Variablen initialisieren, sind uninitialisierte Variablen eine Quelle für schwer zu findende Fehler: Da die Variable ohne Initialisierung einen zufälligen Wert enthält, wird auch das Verhalten des [[Computerprogramm|Programms]] unvorhersagbar, so dass es manchmal falsche Ergebnisse liefert oder gar abstürzt. Enthält der für die Variable reservierte Speicherbereich einen scheinbar erwarteten Inhalt aus einem vorhergehenden Programmdurchlauf, so spricht man auch von einer '''Speicherinterferenz'''.

== Siehe auch ==
* [[Attribut (Programmierung)]]

== Weblinks ==
{{Wiktionary|Variable}}

== Einzelnachweise ==
<references />

[[Kategorie:Programmiersprachelement]]

Variable (Programmierung) - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https