Lokale Variablen

Werden Variablen innerhalb einer Funktion oder eines Anweisungsblock deklariert, so sind diese lokale Variablen. Lokale Variablen gehören immer zu der Funktion bzw. Anweisungsblock innerhalb der sie deklariert werden. Darum kann es einen Variablenname mehrmals geben, wenn sie in unterschiedlichen Funktionen / Anweisungsblöcken deklariert wurden. Wird die Variable aufgerufen, so wird jeweils die Variable aufgerufen, die am lokalsten (nächsten) deklariert wurde.

1. Beispiel:

#include <stdio.h>

void main() 
{
  int zahl = 10;                       // Lokale Variable der Funktion main()

  if (zahl == 10)                      // Lokale Variable des if-Anweisungsblocks
  {           
    int zahl = 20;
    printf("1. printf(): %d\n", zahl); // Ausgabe der lokalen Variable von if
  }
  
  printf("2. printf(): %d\n",zahl);    // Ausgabe der lokalen Variable von main()
}

Bildschimausgabe:

In dem Beispiel wurde am Anfang der Funktion main() die Variable zahl deklariert und mit dem Wert 10 initialisiert. Die folgende if-Alternative überprüft den Inhalt der Variablen zahl. Da die Bedingung wahr ist, wird innerhalb des if-Anweisungsblocks eine zweite lokale Variable zahl deklariert. Die printf()-Funktion innerhalb der if-Alternativen gibt den Inhalt der zweiten Variablen zahl aus, da diese innerhalb von if steht. Die zweite printf()-Anweisung gibt den Wert der ersten lokalen Variablen zahl aus.

2. Beispiel:

#include <stdio.h> 

void main() 
{
  int zahl = 10;

  if(zahl == 10) 
  {
    zahl = 20;
    printf("1. printf(): %d\n", zahl);
  }

  printf("2. printf(): %d\n", zahl);
}

Bildschirmausgabe:

Hier ist im Gegensatz zum vorherigen Beispiel der Wert der Variable zahl im if-Anweisungsblock auf 20 verändert worden, aber hier ist keine neue lokale Variable zahl definiert worden.

Der Gültigkeitsbereich einer lokalen Variablen erstreckt sich nur über den Bereich (Funktion / Anweisungsblock), innerhalb der sie deklariert wurde. Damit "sterben" diese Variablen auch, wenn die Funktion / der Anweisungsbock, in der sie erzeugt wurde, beendet wird.

3. Beispiel:

#include <stdio.h>

void main()
{
  int zahl1 = 10;
   
  if(zahl1 == 10)
  {
    int zahl2 = 20;
    printf("1. printf(): %d\n",zahl2);
  }

  printf("2. printf(): %d\n",zahl2);
}

Dieses Programm wird nicht compiliert. In der Zeile printf("2. printf(): %d\n",zahl2); wird der Hinweis, das die Variable zahl2 unbekannt ist, ausgegeben. Das heißt, dass die Variable zahl2 zum Zeitpunkt der Ausführung des printf()-Befehls nicht mehr existiert.

Globale Variablen

Werden Variablen außerhalb jeder Funktion deklariert, so sind diese globale Variablen. Globale Variablen können von jeder Funktion innerhalb des Programms genutzt werden. Wird innerhalb der Funktion eine gleichnamige Variable (lokale Variable) deklariert, so greift diese Funktion beim Aufruf der Variablen natürlich auf die lokale Variable zu. Sinnvollerweise sollten globale Variablen am Anfang des Programmquellcodes erzeugt werden oder in eine zusätzliche Datei abgespeichert werden, die man mit Hilfe von #include <> einbindet.

1. Beispiel (siehe auch Funktionen):

#include <stdio.h>

int zahl=10;                             // Deklaration der globale Variable "zahl" 

void funktion1()                         // Funktionsdeklaration
{                              
  zahl = 20;                             // Änderung der globalen Variablen "zahl"
  printf("In der Funktion: %d\n",zahl);  // Ausgabe der globalen Variablen "zahl"
} 

void main()
{
  printf("Vor der Funktion: %d\n",zahl);  // Ausgabe der lokalen Variablen "zahl"
  funktion1();                            // Funktionsaufruf
  printf("Nach der Funktion: %d\n",zahl); // Ausgabe der lokalen Variablen "zahl"
} 

Bildschirmausgabe:

In dem Programm wird zuerst eine globale Variable zahl erzeugt und mit dem Wert 10 initialisiert. Nach dem Start des Programms wird als erstes die main()-Funktion aufgerufen. Diese greift mit der ersten printf()-Funktion auf die globale Variable zahl zu und gibt diesen aus. Als nächstes wird die Funktion funktion1() aufgerufen, die der globalen Variablen zahl einen neuen Wert zuweist und diesen ausgibt. Als letztes greift die main()-Funktion nochmal auf die globale Variable zahl zu und gibt deren veränderten Wert aus.

2. Beispiel:

#include <stdio.h>

int zahl = 30;                            // Deklaration der globale Variable "zahl"

void funktion1()                          // Funktionsdeklaration
{
   zahl = 20;                             // Änderung der globalen Variablen "zahl"
   printf("In der Funktion: %d\n",zahl);  // Ausgabe der globalen Variablen "zahl"
} 

void main() 
{   
  int zahl = 10;                          // Deklaration der lokalen Variablen "zahl"

  printf("Vor der Funktion: %d\n",zahl);  // Ausgabe der lokalen Variablen "zahl"
  funktion1();                            // Funktionsaufruf
  printf("Nach der Funktion: %d\n",zahl); // Ausgabe der lokalen Variablen "zahl"
}  

Bildschirmausgabe:

In dem Programm wird zuerst eine globale Variable zahl erzeugt und mit dem Wert 30 initialisiert. Nach dem Start des Programms wird als erstes die main()-Funktion aufgerufen. Innerhalb dieser wird eine lokale Variable zahl mit dem Variablenwert 10 erzeugt. Die ersten printf()-Funktion in der main()-Funktion greift auf die lokale Variable zahl zu, da diese in der main()-Funktion Vorrang gegenüber der gleichnamigen globalen Variablen zahl hat, und gibt diese aus. Als nächstes wird die Funktion funktion1() aufgerufen, die der globalen Variablen zahl einen neuen Wert zuweist und diesen ausgibt. Als letztes greift die main()-Funktion nochmal auf die lokale Variable zahl zu und gibt deren Wert aus.

Statische Variablen

Neben der globalen Variablen hat man noch eine weitere Möglichkeit Variablen über die Lebenszeit der erzeugenden Funktion am „leben“ zu halten und auf deren Wert mit anderen Funktionen zuzugreifen.
Dafür benötigt man das Schlüsselwort static. Dieses Schlüsselwort wird bei der Deklaration der Variablen innerhalb der Funktion vor dem Datentyp der Variablen geschrieben.
Bei der Deklaration der Variablen werden statische Variablen gleichzeitig auf 0 initialisiert.

1. Beispiel:

#include <stdio.h>

void funktion1()       // Funktion
{
  int zahl = 1;        // Deklaration der Variablen "zahl"

  printf("Wert von Zahl: %d\n",zahl); // Ausgabe der Variablen "zahl"
  zahl++;                             // Erhöhung des Variablenwerts um 1
}

void main()
{
  funktion1();         // Funktionsaufruf
  funktion1();         // Funktionsaufruf
  funktion1();         // Funktionsaufruf
}

Bildschirmausgabe:

Wenn Sie das Programm starten, wird dreimal der Wert 1 für die Variable zahl ausgegeben, obwohl man doch eigentlich davon ausgehen könnte, dass der Programmierer den Wert die Variable zahl mit jedem Funktionsaufruf Hochzählen wollte. Dies liegt wieder an der Labensdauer der Variablen, die mit der Lebenszeit der Funktion verknüpft ist.

2. Beispiel:

#include <stdio.h>

void funktion1()
{
  static int zahl = 1;

  printf("Wert von Zahl: %d\n",zahl);
  zahl++;
}

void main()
{
  funktion1();
  funktion1();
  funktion1();
}

Bildschirmausgabe:

Wenn man das Schlüsselwort static vor der Variablen-Deklaration schreibt, erreicht man das zu erwarten Verhalten des Programms, da jetzt die Variable über die Lebenszeit der erzeugenden Funktion weiter existiert.