Gültigkeitsbereiche

Die Themen:

Arten von Gültigkeitsbereiche
Modul- oder Dateibereich
Funktionsbereich
Blockbereich
Zugriff auf globale Daten

Arten von Gültigkeitsbereiche

Nichts währt ewig und so hat auch eine Variable oder Konstante nur eine begrenzte Lebensdauer oder Gültigkeit. Im Nachfolgenden wird der Begriff Daten bzw. Datum verwendet, wenn damit sowohl Variablen wie auch Konstanten gemeint sind.

Der Gültigkeitsbereich eines Datums gibt den Bereich an, innerhalb dessen das Datum sichtbar ist und damit darauf zugegriffen werden kann. Bei Variablen gilt zusätzlich, dass sie nur innerhalb ihres Gültigkeitsbereichs auch tatsächlich Speicherplatz belegen. Durch geschickte Wahl des Gültigkeitsbereichs lässt sich somit unter Umständen erheblich Speicherplatz einsparen.

Im Prinzip gibt es 4 unterschiedliche Gültigkeitsbereiche:

1. Modul- oder Datei
2. Funktion
3. Block
4. Klasse

Nachfolgend werden die Gültigkeitsbereiche 1 bis 3 erklärt. Der Gültigkeitsbereich 4 (Klasse) wird später bei den Klassen behandelt.

Modul- oder Dateibereich

Daten die nicht innerhalb von Blöcken {...} definiert sind, werden als globale Daten bezeichnet. Sie sind ab der Stelle im Programm gültig, an der sie definiert sind. Ihre Gültigkeit endet am Modulende (Dateiende). Globale Variablen werden vor dem Eintritt in die Funktion main() mit 0 initialisiert.

short modul1;      // modul1 ab hier gültig int main () {    modul1 = 10;    ... } short modul2;     // modul1 und modul2 ab hier gültig void Function () {    modul2 = modul1;    ... }

Funktionsbereich

Daten die innerhalb von Funktionen (wie z.B. innerhalb von main()) definiert werden, werden als lokale Daten bezeichnet. Lokalen Daten sind nur in der Funktion gültig, in der sie definiert sind. Aus diesem Grund dürfen lokale Daten in verschiedenen Funktionen den gleichen Namen besitzen, ohne dass diese sich gegenseitig beeinflussen. Lokale Daten können an beliebiger Stelle innerhalb einer Funktion definiert werden.

Lokale Variablen werden nicht automatisch initialisiert und haben damit einen zufälligen Anfangswert. In der Regel werden lokale Daten auf dem Stack abgelegt (Stack = besonderer Bereich innerhalb eines Programms z.B. zur Ablage von temporären Daten) und belegen nur während der Zeit Speicher, während der die Funktion ausgeführt wird. Beim Verlassen der Funktion werden sie automatisch entfernt.

Besitzt ein lokales Datum den gleichen Namen wie ein globales Datum, so verdeckt das lokale Datum das globale (siehe auch nachfolgendes Beispiel).

short var; int main () {    var = 1;            // globales var    ... } void Func1 () {    short var;          // verdeckt globales var    var = 10;           // lokales var setzen    ... } void Func2 () {    short lVar = 3.14;   // lokale Variable    // Ausgabe lokales lVar und globales var    cout << var << lVar << endl;    ... }

Blockbereich

Daten die innerhalb eines Blocks {...} in einer Funktion definiert werden, verhalten sich wie lokale Daten, d.h. sie werden nicht automatisch initialisiert und verlieren beim Verlassen des Blocks ihre Gültigkeit und geben damit auch den belegten Speicher wieder frei. Und auch hier gilt wieder: wird innerhalb eines Blocks ein Datum mit dem gleichen Namen definiert wie ein lokales oder globales Datum, so verdeckt das Blockdatum diese.

Funktions- und blocklokale Daten verhalten sich im Prinzip gleich. Der Unterschied wurde an dieser Stelle nur aufgezeigt, damit Ihnen bewusst wird, dass Sie innerhalb eines beliebigen Blocks jederzeit neue Daten definieren können.

short var1;             // globales var1 int main () {    short var2;          // lokales var2    ...    {       short var1;       // Blockvariable verdeckt globales var1       ...       {          short var2;    // Blockvariable verdeckt lokales var2          ...       }    } }

Zugriff auf globale Daten (scope resolution operator, Gültigkeitsbereichsoperator)

Werden globale Daten durch funktions- oder blocklokale Daten verdeckt, so kann mithilfe des Gültigkeitsbereichsoperators  ::  (scope resolution operator, das sind zwei Doppelpunkte!) vor dem entsprechenden Variablennamen trotzdem auf die globalen Daten zugegriffen werden. Dieser Zugriff funktioniert aber nur auf globale Daten und nicht, wie im Beispiel rot dargestellt, auf 'übergeordnete' lokale Daten.

short var1;             // globales var1 int main () {    short var2;          // lokales var2    ...    {       short var1;       // Blockvariablen       short var2;       var1 = 10;        // Blockvariable setzen       ::var1 = 0;       // globale Variable setzen       ::var2 = 0;       // nicht erlaubt! Kein Zugriff auf lokales var2!    } }

War doch im Prinzip nicht schwer mit den Gültigkeitsbereichen, oder?