8.3 Gültigkeit, Blöcke

Alle Vereinbarungen (außer Praeprozessoranweisungen) gelten ab ihrer Vereinbarung in dem kleinsten umgebenden Block. Ein Block ist ein Paar von geschweiften Klammern ({...}), in welchem Vereinbarungen (Deklarationen, Definitionen) und Anweisungen stehen dürfen. Eventuelle Vereinbarungen müssen vor den ausführbaren Anweisungen eines Blocks stehen.

Steht eine Vereinbarung außerhalb aller Blöcke, dann gilt sie bis zum Ende der Quelldatei.

Auch jede Variable hat einen Gültigkeitsbereich. Zum einen gilt eine Variable erst ab der Stelle im Quelltext, an der sie vereinbart ist. Zum anderen ist die Wirkung ihrer Vereinbarung auf den kleinsten umschließenden Block beschränkt. Variablen, die außerhalb einer Funktion vereinbart werden, gelten im gesamten weiteren Quelltext (globale Variable).

Wird eine Variable innerhalb einer Funktion vereinbart, dann gilt sie auch nur in dieser Funktion (lokale Variable).

Wird eine Variable innerhalb eines Blockes innerhalb einer Funktion vereinbart, dann gilt sie entsprechend nur in diesem Block.

Vereinbarungen in einem Block müssen vor den ausführbaren Anweisungen des Blocks stehen.

Innerhalb des gleichen Geltungsbereichs darf ein Name nur für eine Variable oder eine Funktion oder einen Datentyp verwendet werden. Jedoch darf in einem Block eine Variable mit einem Namen vereinbart werden, der schon außerhalb des Block vergeben ist. Dann bezieht sich der Name innerhalb des Blocks nur auf die lokale Variable des Blocks.

Die enum, struct- und union-Namen sowie ihre Elementnamen kollidieren nicht mit Variablen- und Funktionsnamen.

Beispiel: Nach den Vereinbarungen

enum ename
{
    rot,
    gruen,
    blau
}
farbe;

struct sname
{
    int     i;
    double  d;
}
a, b;

dürfen die Namen ename, sname, i und d für Variablen im gleichen Geltungsbereich verwendet werden. rot, gruen, blau (an Konstanten vergeben), farbe, a und b (bereits Variablen) dürfen nicht an weitere Variablen oder Konstanten vergeben werden.

Wie lokale Variablen sind die Formalparameter einer Funktion auf die zugehörige Funktion beschränkt, und können ansonsten wie Variablen behandelt werden.

Beispiel:

int summe( int a, int b )
{
  return a + b;
}

int differenz( int a, int b )
{
  int minusb;

  minusb = -b;
  return summe( a, minusb );
}

int wert;

rechne()
{
  wert = summe( 1, 2 );
}

main()
{
  int wert;
  rechne();
  wert = differenz( 1, 2 );
}

Hier haben die Funktionen summe() und differenz() je zwei Parameter mit den Namen a und b, die jedoch außer einer zufällig gleichen Vereinbarung nichts miteinander zu tun haben. Die Variablen a und b der Funktion summe() sind nicht die selben wie die der Funktion differenz()! Als Funktionsparameter sind sie lokal auf die zugehörige Funktion beschränkt.

minusb ist eine lokale Variable der Funktion differenz() und nur innerhalb des geschweiften Klammerpaares {...} von differenz() gültig.

wert ist zum einen eine globale Variable, die ab ihrer Vereinbarung für alle nachfolgenden Funktionen gelten kann. rechne() verwendet sie auch. main() dagegen übersteuert die globale Vereinbarung von wert mit einer lokalen Vereinbarung und kann damit nicht mehr auf die globale Variable wert zugreifen. Die Zuweisung an wert innerhalb von main() bezieht sich auf die lokale Variable.