C++ Kurs

Gültigkeitsbereiche

Die Themen:

Arten von Gültigkeitsbereiche

Ene Variable oder Konstante hat innerhalb eines Programms nur eine begrenzte Lebensdauer oder Gültigkeit. Dieser Gültigkeitsbereich eines Datums gibt den Bereich an, innerhalb dessen das Datum sichtbar ist und somit darauf zugegriffen werden kann. Bei Variablen gilt außerdem, dass sie prinzipiell 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 ersten drei Gültigkeitsbereiche erklärt. Der letzte Gültigkeitsbereich (Klasse) wird später bei den Klassen behandelt.

Modul- oder Dateibereich

Daten, welche 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.

PgmHeader
short modul1;      // modul1 ab hier gültig

int main ()
{
   modul1 = 10;
   ...
}
short modul2;     // modul1 und modul2 ab hier gültig
void Function ()
{
   modul2 = modul1;
   ...
}
HinweisObwohl C++ es zulässt, dass globale Daten an beliebiger Stelle im Modul definiert werden können, sollten Sie jedoch aufgrund der besseren Lesbarkeit und Wartbarkeit alle globalen Daten am Modulanfang definieren. D.h. die Position der Definition der Variable modul2 im obigen Beispiel fördert nicht gerade die Lesbarkeit eines Programms.

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 Datum (siehe auch nachfolgendes Beispiel).

PgmHeadershort 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 in der Regel 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.

PgmHeader
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 mit Hilfe 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.

PgmHeader
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!
   }
}
HinweisNoch ein Hinweis (im Vorgriff) zum Schluss: wenn Sie später im Kurs lernen, Objekte richtig einzusetzen, ist die Verwendung von globalen Daten (aber nicht die von globalen Objekten!) fast ein Vergehen. Da wir aber zum jetzigen Zeitpunkt noch keine Objekte erstellen können, soll dieser 'Ausrutscher' bis zur Einführung von Objekten toleriert werden.