C++-Programmierung/ Weitere Grundelemente/ Lebensdauer und Sichtbarkeit von Variablen
Aus Wikibooks
In diesem Kapitel werden Sie zuerst lernen, wie lange eine Variable im Speicher unseres Programmes existiert (Lebensdauer). Danach wird behandelt, an welchen Stellen wir auf eine bestimmte Variable zugreifen können (Sichtbarkeit).
Inhaltsverzeichnis |
[Bearbeiten] Lebensdauer
[Bearbeiten] Globale Variablen
Variablen, die auf der äußersten Ebene deklariert werden, nennt man global, weil an jeder Stelle des Programmes auf sie zugegriffen werden kann. Dabei darf die Variable nicht innerhalb einer Funktion ( main() eingeschlossen) oder einer Klasse deklariert werden.
Diese Variablen werden meist beim Starten initialisiert und beim Beenden wieder zerstört. Damit ist klar, dass der Speicher, den sie benötigen, für die gesamte Laufzeit des Programmes belegt ist und nicht anders verwendet werden kann.
int main() {
// ...
}
[Bearbeiten] Lokale Variablen
Im Gegensatz zu globalen, werden lokale Variablen in einem bestimmten Anweisungsblock (z.B. Schleifen, if-Abfragen oder Funktionen) deklariert. Ihre Existenz endet wenn dieser Block wieder verlassen wird.
int lok1 = 0; // lok1 ist eine Variable im Anweisungsblock von void foo(int a)
if (a < 0) {
int lok2 = 1; // lok2 ist eine Variable im if-Block
} // hier wird lok2 aus dem Speicher gelöscht...
} // ...und hier lok1
int var = 0;
std::cout << var << std::endl; // die Ausgabe ist hier immer 0
++var;
}
[Bearbeiten] Statische Variablen
Statische Variablen (auch statische Klassenmember) werden wie globale zu Beginn des Programmes im Speicher angelegt und bei seinem Ende wieder daraus entfernt. Der Unterschied zu einer globalen Variable wird weiter unten auf dieser Seite im Teil über Sichtbarkeit geklärt.
[Bearbeiten] Dynamisch erzeugte Variablen
Eine Variable, die mittels dem new Operator angefordert wird, heißt dynamisch. Sie existiert so lange bis sie durch einen Aufruf von delete wieder gelöscht wird.
[Bearbeiten] Objekte und Membervariablen
Objekte werden wie normale Variablen gehandhabt, d. h. sie können global, lokal, statisch oder dynamisch erzeugt sein. Ihre Member haben die gleiche Lebensdauer wie sie selbst. Eine Ausnahme bilden statische Klassenvariablen, die von Anfang bis Ende des Programmablaufes im Speicher vorhanden sind.
[Bearbeiten] Sichtbarkeit
[Bearbeiten] Allgemein
Um Überhaupt die Chance zu haben mit einer Variablen zu arbeiten, muss diese im Quelltext bereits deklariert worden sein. Folgendes Codestück ist also falsch und würde zu einem Fehler führen.
var = 34; // Fehler z.B. "symbol var not found"
int var;
// ...
[Bearbeiten] Gültigkeitsbereiche und deren Schachtelung
Jede Variable gehört zu einem bestimmten Gültigkeitsbereich (engl. scope). Diese legen fest wann eine Variable von uns „gesehen“ und damit benutzt werden kann. Vereinfacht gesagt bildet jedes Paar aus geschweiften Klammern ( {}) einen eigenen Definitionsbereich.Dazu gehören beispielsweise if, else, Schleifen und Funktionen. Diese unterschiedlichen Bereiche sind nun ineinander geschachtelt ähnlich wie die berühmten Matrjoschka-Puppen mit dem Unterschied, dass die Definitionsbereiche nicht „kleiner“ werden und dass es mehrere „nebeneinander“ geben kann.
int func() { // hier beginnt der Bereich der Funktion func...
return 0;
// ... und ist hier auch schon wieder beendet
}
int bar(int val) { // val gehört zum Definitionsbereich "bar"
if (val == 7) { // diese if-Anweisung hat auch ihren eigenen Gültigkeitsbereich...
int ich_gehoer_zum_if;
} //... der hier zu Ende ist
} // bar ende
[Bearbeiten] Welche Variablen sind sichtbar?
Jetzt ist es leicht zu bestimmen mit welchen Variablen wir an einer bestimmten Stelle im Programmcode arbeiten können: Es sind diejenigen, die entweder dem derzeitigen oder einem Gültigkeitsbereich auf einer höheren Ebene angehören. Wenn wir uns erneut das Beispiel der Puppen vor Augen halten, so wird klar was hiermit gemeint ist.
Beispiel:
{
int inner_1;
}
{
int inner_2;
//an dieser Stelle könnten wir sowohl auf out als auch auf inner_2 zugreifen, nicht jedoch auf inner_1;
}
Zusätzlich gilt noch, dass von zwei Variablen gleichen Namens nur auf die weiter inner liegende zugegriffen werden kann.
{
int var=3;
std::cout << var << std::endl;//die Ausgabe ist 3
}
