Programmieren
 
 
 
 
 
C-Grundkurs
 
 
 
 
 
.. Gültigkeitsbereich,Sichtbarkeit, Dauer
 
 
 
 
 
 
 
In diesem Kapitel geht es darum, in welchem Bereich eines C-Programms auf einen C-Bezeichner zugegriffen werden kann und in welchem Speicherraum des Hauptspeichers, das von ihm bezeichnete Objekt abgelegt wird. Dabei können Bezeichner z.B. Variablennamen, Label, oder Funktionsnamen sein und die Objekte Werte von Variablen oder der Maschinencode von Funktionen.
Um einen Überblick zu erhalten soll hier zunächst nur von Variablennamen und deren Werten gesprochen werden.
 
 
 
 
 
Gültigkeitsbereich
Der Gültigkeitsbereich eines Variablennamens ist der Programmteil, in dem über ihn auf den zugeordneten Wert zugegriffen werden kann. Dies ist ...
 
 
                                        Gültigkeitsbereich Block (lokal)
 
 
.. normalerweise ein Block, also der Bereich zwischen den zwei geschweiften Klammern { .. } einer Funktion() { .. }oder eines Schleifenkonstrukts wie while(){ .. } oder for(){ .. }. Man spricht hier vom Gültigkeitsbereich Block oder von einem lokalen Gültigkeitsbereich.
 
 
Es gibt weitere Gültigkeitsbereiche von denen für Variable nur noch der Bereich Datei von besonderem Interesse ist.
 
 
                                        Gültigkeitsbereich Datei (global)
 
 
.. hier werden die Variablen außerhalb eines jeden Blockes deklariert, worauf sich ihr Gültigkeitsbereich über die gesamte Quelldatei und in jede Funktion, Schleife usw. hinein erstreckt.
 
 
 
 
 
Beispiel:
Im Beispiel wurde eine globale Variable deklariert, definiert und initialisiert, sowie mehrere lokale Variable, die über zwei Blöcke verteilt sind. Dabei ist zu bemerken, dass die Variablen des Funktionskopfes auch zu den lokalen Variablen zählen.
Die globale Variable lässt sich aus jedem der Funktionsblöcke lesen und beschreiben. Die lokalen Variablen dagegen nur in dem Bereich, in dem sie erklärt wurden.
 
 
 
 
void funktion(int zahl);        // Deklaratin einer Funktion

int globvar = 50;               // globale Variable


// ---------------------------------------------------------------
void main (void)
{
  int lokalvar1 = 20;           // 1.lokale Variable
  int lokalvar2 = 30;           // 2.lokale Variable

  globalvar = lokalvar1+10;     // ändert die globale Variable
  funktion();
}


// ---------------------------------------------------------------
void funktion(int lokalvar3)    // 3.lokale Variable 
{
  int lokalvar1 =40;            // 4.lokale Variable keine Ver- 
                                // bindung zu lokalvar1 in main()
                                // trotz des gleichen Namens

  lokalvar2 = globvar+10;       // Fehler, geht nicht, da lokalvar2
                                // nur in main() gültig ist.

  lokalvar1= globvar+lokalvar3; // ändert nur lokalvar1 der
                                // funktion(). Keine Änderung von
                                // lokalvar1 in main() 

  globalvar = lokalvar1+10;     // ändert die globale Variable
}
 
 
 
 
 
 
Sichtbarkeit
In den meisten Fällen stimmen der Gültigkeitsbereich und die Sichtbarkeit von Variablen überein. Überlagern sich jedoch die Gültigkeitsbereiche zweier gleich lautender Variablennamen muss eine von ihnen den Vorrrang erhalten. Besitzen beispielsweise eine globale und eine lokale Variable die gleichen Namen, so wird die Sichtbarkeit der globalen Variablen eingeschränkt. Progammanweisungen im Gültigkeitsbereich der lokalen Variable beziehen sich jetzt nur noch auf die lokale Variable. Bei geschachtelten Blöcken wird ebenfalls die Variable des umfassenden Blockes ausgeblendet.
 
 
 
 
 
Beispiel:
 
 
 
 
 
void funktion(int zahl);       // Deklaratin einer Funktion

int zahl = 50;                 // globale Variable            zahl


// ---------------------------------------------------------------
void main (void)
{
  int zahl = 20;               // lokale Variable             zahl

  zahl = zahl +10;             // ändert die lokale Variable zahl
                               // die globale Variable zahl ist in
                               // diesem Block nicht sichtbar,
                               // obwohl sie auch hier gültig ist.
  funktion(zahl);
}


// ---------------------------------------------------------------
void funktion(int wert)        // lokale Variable    wert
{
  zahl = wert;                 // ändert die globale Variable zahl
                               // diese ist hier gültig und
                               // sichtbar
}
 
 
 
 
 
 
 
Dauer
Mit der Dauer ist die Frage verbunden, in welchem Zeitraum der Laufzeit eines Programms auf die Objekte eines Bezeichners zugegriffen werden kann. Bei den Variablen also auf deren Werte. Hier wird zwischen statischer, lokaler und dynamischer Dauer unterschieden und diese hängen letztendlich davon ab, in welchem Speicherbereich des Hauptspeichers die Speicherzellen für die Werte der Variablen eingerichtet wurden.

.. Lokale Dauer
.. war der Ort des Hauptspeichers in dem die Variable angelegt wurde der Stack (Rücksprungstapel der CPU), was bei lokalen Variablen normalerweise der Fall ist, so werden die Variablen mit dem Verlassen des Blockes, (der Funktion, der Schleife) nicht mehr erreichbar sein und folgend überschrieben werden.

.. Statische Dauer
.. war der Ort des Hauptspeichers in dem die Variable angelegt wurde, der beim Start des Programms belegte Datenblock, so sind die Werte der Variablen über die gesamte Dauer des Programmlaufs verfügbar. Ihr Gültigkeitsbereich und ihre Sichtbarkeit werden hiervon nicht betroffen.
Sollen Variable eines Blockes, die normalerweise eine lokale Dauer besitzen, dauerhaft verfügbar bleiben so kann der Programmierer dies durch den Speicherklassen-Spezifizierer static bewirken. z.B. static int zahl = 55; Diese Variable wird über die gesamte Laufzeit verfügbar bleiben, da ihr Wert nicht auf dem Stack abgelegt wird.

.. Dynamische Dauer
.. Hier wird zur Laufzeit des Programms Speicherraum vom Betriebssystem abgefordert und kann auch wieder an das Betriebssystem zurückgegeben werden.
 
 
 
 
 
Beispiel:
 
 

 
 
 
void funktion(void)             // Deklaratin einer Funktion

// ---------------------------------------------------------------
void main (void)
{
  for(int n=10; n>0; n--){      // lokale Variable n im for-Block
    funktion();
  }
}


// ---------------------------------------------------------------
void funktion(void)        
{
  static unsigned zahl = 0;   // lokale Variable zahl mit dem
                              // Startwert 0. Wegen static
                              // behält sie ihren Wert, auch wenn
                              // die funktion() verlassen wird.

  zahl++;                     // zahl = zahl+1

  printf ("Wert von zahl= %d", zahl);
                              // Nach jedem Aufruf von funktion()
                              // wird der um 1 erhöhte Wert von
                              // zahl angezeigt. (1,2,3,4 ..)
}

 
 
 
 
www..de