Umfang in C ++

Eine Entität in C ++ hat einen Namen, der deklariert und/oder definiert werden kann. Eine Erklärung ist eine Definition, aber eine Definition ist nicht unbedingt eine Erklärung. Eine Definition verteilt Speicher für die benannte Entität, aber eine Erklärung kann für die benannte Entität Speicher zuweisen oder nicht. Eine deklarative Region ist der größte Teil eines Programms, in dem der Name einer Entität (Variable) gültig ist. Diese Region wird als Zielfernrohr oder potenzieller Umfang bezeichnet. Dieser Artikel erklärt Scoping in C++. Darüber hinaus ist Grundkenntnisse über C ++ erforderlich, um diesen Artikel zu verstehen.

Artikelinhalt

• Deklarative Region und Umfang
• Globaler Umfang
• Globale Variablen und globaler Umfang
• Blockbereich
• Funktionsumfang
• Klassenumfang
• Aufzählungsumfang
• Globale Variable
• Vorlage Parameterbereich
• Name Versteck
• Möglichkeit zur Wiederholung der Erklärung im gleichen Bereich
• Namespace Scope
• Umfang in verschiedenen Teilen
• Abschluss

Deklarative Region und Umfang

Eine deklarative Region ist der größte Teil eines Programmtextes, in dem der Name einer Entität gültig ist. Die Region, in der der nicht qualifizierte Name verwendet werden kann (gesehen), um sich auf dieselbe Entität zu beziehen. Betrachten Sie das folgende kurze Programm:

#enthalten
Verwenden von Namespace STD;
void fn ()

int var = 3;
if (1 == 1)

Cout<

int main ()

fn ();
Rückkehr 0;

Die Funktion fn () verfügt über zwei Blöcke: einen inneren Block für die If-Kondition und einen äußeren Block für die Funktionskörper. Der Bezeichner var wird im äußeren Block eingeführt und gesehen. Es ist auch im inneren Block mit der Cout -Anweisung zu sehen. Die äußeren und inneren Blöcke sind der Umfang für den Namen, var.

Der Name Var kann jedoch immer noch verwendet werden, um eine andere Entität wie einen Schwimmer im inneren Block zu deklarieren. Der folgende Code zeigt dies:

#enthalten
Verwenden von Namespace STD;
void fn ()

int var = 3;
if (1 == 1)

float var = 7.5;
Cout<

int main ()

fn ();
Rückkehr 0;

Die Ausgabe ist

7.5

In diesem Fall kann der Name Var im inneren Block nicht mehr verwendet werden. Solche inneren Blöcke werden als potenzieller Umfang für Unternehmen bezeichnet, die im äußeren Block deklariert sind.

Hinweis: Eine Entität des gleichen Typs wie der äußere Block kann immer noch im inneren Block deklariert werden. In diesem Fall sind die neue Erklärung und ihre Bedeutung im inneren Block jedoch gültig, während die alte Deklaration und Bedeutung außerhalb des inneren Blocks nur im äußeren Block gültig bleiben.

Eine gleichnamige Erklärung in einem inneren Block überschreibt normalerweise die gleichnamige Erklärung außerhalb dieses inneren Blocks. Innenblöcke können andere innere Blöcke nisten.

Globaler Umfang

Wenn ein Programmierer beginnt, eine Datei zu tippen, ist dies der globale Bereich. Das folgende kurze Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
float var = 9.4;
int main ()

Cout <Cout <<::var<<'\n';
Rückkehr 0;

Die Ausgabe ist:

9.4
9.4

In diesem Fall beginnt der deklarative Bereich oder der Umfang für VAR vom Punkt der Erklärung für VAR und dauert bis zum Ende der Datei nach unten (Übersetzungseinheit) nach unten, bis nach unten (Übersetzungseinheit) nach unten fortgesetzt.

Der Block der Main () -Funktion ist ein anderer Bereich; Es ist ein verschachtelter Rahmen für den globalen Umfang. Um auf eine Entität des globalen Umfangs aus einem anderen Bereich zuzugreifen, wird der Kennung direkt oder vom Aperator der Umfangsauflösung verwendet:: .

Hinweis: Die Entität Main () wird ebenfalls im globalen Bereich deklariert.

Blockbereich

Die IF, während Anweisungen für, für oder für Schalter können jeweils einen Block definieren. Eine solche Aussage ist eine zusammengesetzte Aussage. Der Name einer in einem Block deklarierter Variable hat den Bereich eines Blocks. Sein Zielfernrohr beginnt an seiner Erklärung und endet am Ende seines Blocks. Das folgende kurze Programm zeigt dies für die Variable: Ident:

#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)

/*einige Aussagen*/
int ident = 5;
Cout</*einige Aussagen*/

Rückkehr 0;

Eine Variable wie die Identität, die im Blockbereich deklariert ist, ist eine lokale Variable.

Eine Variable, die außerhalb des Blockbereichs deklariert ist, und darüber ist sie im Header des Blocks zu sehen (e.G., Bedingung für If-Block) und innerhalb des Blocks. Das folgende kurze Programm veranschaulicht dies für die Variable, ID ID:

#enthalten
Verwenden von Namespace STD;
int main ()

int identif = 8;
if (identif == 8)

Cout<
Rückkehr 0;

Die Ausgabe ist,

8

Es gibt zwei Blockbereiche: den Block für die main () -Funktion und die verschachtelte If-Compound-Anweisung. Der verschachtelte Block ist der potenzielle Umfang des Haupt () -Funktionsblocks.

Eine in einem Blockbereich eingeführte Erklärung kann außerhalb des Blocks nicht gesehen werden. Das folgende kurze Programm, das nicht kompiliert wird, zeigt dies mit der Variablen Variab:

#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)

int variab = 15;

Cout<Rückkehr 0;

Der Compiler erstellt eine Fehlermeldung für Variab.

Eine eingeführte Entität, die im Kopf einer zusammengesetzten Funktion deklariert wurde, kann außerhalb (unten) der zusammengesetzten Aussage nicht zu sehen sein. Der folgende For-Loop-Code wird nicht kompiliert, was zu einer Fehlermeldung führt:

#enthalten
Verwenden von Namespace STD;
int main ()

für (int i = 0; i<4; ++i)

Cout<
Cout<Rückkehr 0;

Die Iterationsvariable i ist innerhalb des For-Loop-Blocks zu sehen, aber nicht außerhalb des For-Loop-Blocks.

Funktionsumfang

Im Funktionsblock wird ein Funktionsparameter angezeigt. Eine in einem Funktionsblock deklarierte Entität wird vom Punkt der Deklaration bis zum Ende des Funktionsblocks beobachtet. Das folgende kurze Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
String Fn (String Str)

char stri [] = "bananas";
/*Andere Aussagen*//
String sotalstr = str + stri;
Totalstr zurück;

int main ()

String totstr = fn ("Essen");
Cout<Rückkehr 0;

Die Ausgabe ist:

Bananen essen

HINWEIS: Eine außerhalb der Funktion deklarierte Entität (darüber) ist in der Liste der Funktionsparameter und im Funktionsblock zu sehen.

Etikett

Der Umfang einer Etikett ist die Funktion, in der sie erscheint. Der folgende Code zeigt dies:

#enthalten
Verwenden von Namespace STD;
void fn ()

goto labl;
/*Andere Aussagen*//
LABL: INT INte = 2;
Cout<
int main ()

fn ();
Rückkehr 0;

Die Ausgabe ist

2

Klassenumfang

Mit dem normalen Scoping beginnt die deklarative Region von einem Punkt im Programm, geht weiter und stoppt an einem anderen Punkt. Der Umfang existiert in einer kontinuierlichen Region. Mit der Klasse kann der Umfang einer Entität in verschiedenen Regionen sein, die nicht miteinander verbunden sind. Die Regeln für verschachtelte Blöcke gelten noch immer. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
// Basisklasse
Klasse Cla

Privatgelände:
int memp = 5;
geschützt:
int mempro = 9;
öffentlich:
void fn ()

Cout<
;
//Abgeleitete Klasse
Klasse dercla: öffentlicher Cla

öffentlich:
int Dermem = mempro;
;
int main ()

Cla obj;
obj.fn ();
Dercla Derobj;
Cout<Rückkehr 0;

Die Ausgabe ist:

5
9

In der Klasse CLA, dem variablen MEMP, wird am Punkt der Deklaration beobachtet. Danach wird der kurze Teil von „geschützt“ übersprungen und im Klassenmitglied -Funktionsblock wieder gesehen. Die abgeleitete Klasse wird übersprungen und im Funktionsbereich der Main () (Block) erneut gesehen.

In der Klasse CLA ist die Variable Mempro, am Punkt der Erklärung zu sehen. Der Teil der öffentlichen Funktion fn () wird übersprungen und dann im abgeleiteten Klassenbeschreibungsblock angezeigt. Es wird in der main () -Funktion erneut gesehen.

Aperator für den Umfang Auflösung

Der Operator der Umfangsauflösung in C ++ lautet :: :: . Es wird verwendet, um auf ein statisches Mitglied der Klasse zuzugreifen. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
Klasse Cla

öffentlich:
static int const mem = 5;
öffentlich:
statische Leere FN ()

Cout<
;
int main ()

Cout<Cla :: fn ();
Rückkehr 0;

Die Ausgabe ist:

5
5

Die statischen Mitglieder werden im Funktionsblock der Main () aufgenommen, auf das mit dem Operator der Bereichsauflösung zugegriffen wird.

Aufzählungsumfang

Unbekannte Aufzählung

Betrachten Sie die folgenden If-Blocks:

if (1 == 1)

enum a, b, c = b+2;
Cout<

Die Ausgabe ist:

0 1 3

Die erste Zeile im Block ist eine Aufzählung; A, B und C sind seine Aufzähler. Der Umfang eines Zählerators beginnt vom Punkt seiner Erklärung bis zum Ende des beillosen Blocks der Aufzählung.

Die folgende Aussage wird nicht kompilieren, da der Punkt der C -Deklaration von C nach der von A liegt:

enum a = c+2, b, c;

Das folgende Code -Segment wird nicht kompiliert, da auf die Aufzähler nach dem blockierten Block der Aufzählung zugegriffen werden:

if (1 == 1)

enum a, b, c = b+2;

Cout<

Die vorherige Aufzählung wird als ungeschichtete Aufzählung beschrieben, und ihre Aufzählern werden als nicht abgegebene Aufzähler definiert. Dies liegt daran, dass es nur mit dem reservierten Wort beginnt, enum. Aufzählungen, die mit Enum -Klasse oder Enum -Strukturen beginnen. Ihre Aufzähler werden als Scoped Enzahlern definiert.

Aufzählung abgeschrieben

Die folgende Aussage ist in Ordnung:

enum class nam a, b, c = b+2;

Dies ist ein Beispiel für eine zahlreiche Aufzählung. Der Name der Klasse ist NAM. Hier beginnt der Umfang des Aufzählers vom Punkt der Erklärung bis zum Ende der Aufzählungsdefinition und nicht vom Ende des eingehenden Blocks für die Aufzählung. Der folgende Code wird nicht kompilieren:

if (1 == 1)

enum class nam a, b, c = b+2;
Cout<

Einfache Verwendung der Aufzählungsumzählung

Der folgende Code zeigt eine einfache Methode zur Verwendung von Scoped Enumeration:

if (1 == 1)

enum nam a, b, c = b+2;
Cout << c << endl; //simple usage

Die Ausgabe ist 3, da B 1 ist ('A' ist 0).

Globale Variable

Eine globale Variable ist eine Variable, die im globalen Bereich deklariert ist. Wenn ein Programmierer beginnt, eine Datei zu tippen, ist dies der globale Bereich. Betrachten Sie das folgende Programm:

#enthalten
Verwenden von Namespace STD;
char va = 'a';
int main ()

Cout <Cout <<::va<<'\n';
Rückkehr 0;

Die Ausgabe ist:

A
A

In diesem Programm beginnt der Teil oder der Umfang für VA vom Punkt der VA -Erklärung und dauert bis zum Ende der Übersetzungseinheit (Datei) nach unten.

Der Körper der Main () -Funktion ist ein anderer Rechtsbereich für sich; Der globale Bereich nistet den Main () -Funktionsumfang.

Die variable VA ist eine globale Umfangsvariable oder einfach eine globale Variable. Es ist im Main () -Funktionsbereich zu sehen.

Um auf eine globale Variable (Variable des globalen Umfangs) aus einem anderen Bereich zuzugreifen.

Die IF, während während der Anweisung oder der Schaltanweisung jeweils einen Block definieren kann. Eine solche Aussage ist eine zusammengesetzte Aussage. Der Name einer in einem Block deklarierter Variable hat den Bereich eines Blocks. Sein Zielfernrohr beginnt an seiner Erklärung und endet am Ende seines Blocks. Das folgende kurze Programm zeigt dies für die Variable: Ident:

#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)

/*einige Aussagen*/
int ident = 5;
Cout</*einige Aussagen*/

Rückkehr 0;

Eine Variable wie die Identität, die im Blockbereich deklariert ist, ist eine lokale Variable.

Eine Variable, die außerhalb des Blockbereichs deklariert ist, und darüber ist sie im Header des Blocks zu sehen (e.G., Bedingung für If-Block) und innerhalb des Blocks. Das folgende kurze Programm veranschaulicht dies für die Variable, ID ID:

#enthalten
Verwenden von Namespace STD;
int main ()

int identif = 8;
if (identif == 8)

Cout<
Rückkehr 0;

Die Ausgabe ist,

8

Hier gibt es zwei Blockbereiche: den Block für die main () -Funktion und die verschachtelte If-Compound-Anweisung. Der verschachtelte Block ist der potenzielle Umfang des Haupt () -Funktionsblocks.

Eine in einem Blockbereich eingeführte Erklärung kann außerhalb des Blocks nicht gesehen werden. Das folgende kurze Programm, das nicht kompiliert wird, zeigt dies mit der Variablen Variab:

#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)

int variab = 15;

Cout<Rückkehr 0;

Der Compiler erstellt eine Fehlermeldung für Variab.

Eine eingeführte Entität, die im Kopf einer zusammengesetzten Funktion deklariert wurde, kann außerhalb (unten) der zusammengesetzten Aussage nicht zu sehen sein. Der folgende For-Loop-Code wird nicht kompiliert, was zu einer Fehlermeldung führt:

#enthalten
Verwenden von Namespace STD;
int main ()

für (int i = 0; i<4; ++i)

Cout<
Cout<Rückkehr 0;

Die Iterationsvariable i ist innerhalb des For-Loop-Blocks zu sehen, aber nicht außerhalb des For-Loop-Blocks.

Eine im globalen Bereich deklarierte Variable ist eine globale Variable. Es ist in einem Blockbereich zu sehen. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
int glb = 5;
int main ()

Cout << glb << endl;
Rückkehr 0;

Der Ausgang ist 5.

Neuzuweisung, die im globalen Umfang nicht zulässig ist

Im vorherigen Programm die Erklärung:

int glb = 5;

Es handelt sich gleichzeitig um eine Deklaration mit Initialisierung (erste Wertzustimmung). Im folgenden Programm "Int GLB"; hat es standardmäßig zugewiesen. Die Linie nach (GLB = 5;) versucht die Neuzuweisung des Wertes 5 im globalen Bereich. Dies schafft einen Fehler, und das Programm kompiliert nicht. Das Programm ist:

#enthalten
Verwenden von Namespace STD;
Int GLB;
GLB = 5;
int main ()

Cout << glb << endl;
Rückkehr 0;

Die Neuzuweisung erfolgt jedoch in einem lokalen (Block-) Bereich, wie im folgenden Programm gezeigt:

#enthalten
Verwenden von Namespace STD;
Int GLB;
int main ()

if (1 == 1)
GLB = 5;
Cout << glb << endl;

Rückkehr 0;

Der Ausgang ist 5.

Globaler Zeiger

Wenn ein Zeiger im globalen Bereich deklariert wird, ist er in einem verschachtelten Bereich zu sehen. Ein in einem verschachtelter Bereich erklärtes Zeiger kann nicht außerhalb des verschachtelten Bereichs gesehen werden. Es gibt zwei Möglichkeiten, einen Zeiger zu erklären. Ein Zeiger kann mit einer praktischen Aufgabe (einer Adresse) deklariert werden. Ein Zeiger kann ohne praktische Aufgabe deklariert werden. Wenn der Zeiger im globalen Bereich ohne praktische Zuordnung deklariert wird, kann er im globalen Bereich nicht neu zugewiesen werden. In diesem Fall kann es jedoch in einem verschachtelten Bereich neu zugeordnet werden.

Globales Array

Wenn ein Array im globalen Bereich deklariert wird, ist es in einem verschachtelten Bereich zu sehen. Ein in einem verschachtelter Bereich erklärtes Array kann nicht außerhalb des verschachtelten Bereichs gesehen werden. Es gibt zwei Möglichkeiten, ein Array zu erklären. Ein Array kann mit einer praktischen Aufgabe (einer Adresse) deklariert werden. Ein Array kann ohne praktische Aufgabe deklariert werden. Wenn das Array im globalen Bereich ohne praktische Zuordnung deklariert wird, kann es im globalen Bereich nicht neu zugewiesen werden. Es kann jedoch in einem verschachtelten Bereich neu zugewiesen werden (Element nach Element).

Vorlage Parameterbereich

Der normale Umfang eines Vorlagenparameternamens beginnt vom Punkt der Deklaration bis zum Ende seines Blocks, wie im folgenden Beispiel:

Vorlage Strukturalter

T John = 11;
U Peter = 12.3;
T Mary = 13;
U Joy = 14.6;
;

U und t sind im Block zu sehen.

Für einen Template -Funktionsprototyp beginnt der Umfang vom Punkt der Deklaration bis zum Ende der Funktionsparameterliste wie in der folgenden Anweisung:

Vorlage void func (t no, u cha, const char *str);

Wenn es jedoch um die Klassenbeschreibung (Definition) geht, kann der Umfang auch unterschiedliche Teile haben, wie im folgenden Beispielprogramm:

#enthalten
Verwenden von Namespace STD;
Vorlage Klasse Thecla

öffentlich:
T num;
statisch u ch;
void func (u cha, const char *str)

Cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statischer Leere Spaß (U CH)

if (ch == 'a')
Cout << "Official static member function" << '\n';

;
int main ()

Thecla obj;
obj.Num = 12;
obj.func ('$', "500");
Rückkehr 0;

Name Versteck

Ein Beispiel für den Namen des Namens tritt auf, wenn der Name desselben Objekttyps in einem verschachtelten Block neu deklariert wird. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
void fn ()

int var = 3;
if (1 == 1)

int var = 4;
Cout<
Cout<
int main ()

fn ();
Rückkehr 0;

Die Ausgabe ist:

4
3

Es liegt daran.

Möglichkeit zur Wiederholung der Erklärung im gleichen Bereich

Der Punkt der Deklaration ist, wo der Name (zum ersten Mal) in seinem Bereich eingeführt wird.

Funktionsprototyp

Verschiedene Entitäten, sogar von verschiedenen Typen, können normalerweise nicht im gleichen Bereich deklariert werden. Ein Funktionsprototyp kann jedoch mehr als einmal im gleichen Bereich deklariert werden. Das folgende Programm mit zwei Funktionsprototypen und der entsprechenden Funktionsdefinition zeigt Folgendes:

#enthalten
Verwenden von Namespace STD;
void fn (int num);
void fn (int num);
void fn (int num)

Cout<
int main ()

fn (5);
Rückkehr 0;

Das Programm funktioniert.

Überlastete Funktionen

Überladene Funktionen sind Funktionen mit demselben Namen, jedoch mit unterschiedlichen Funktionssignaturen. Als weitere Ausnahme können überlastete Funktionen mit demselben Namen im selben Bereich definiert werden. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
void fn (int num)

Cout<
void fn (float no)

Cout<
int main ()

fn (5);
float flt = 8.7;
fn (flt);
Rückkehr 0;

Die Ausgabe ist:

5
8.7

Die überlasteten Funktionen wurden im globalen Bereich definiert.

Namespace Scope

Da zwei verschiedene Variablen denselben Namen haben und sie unterscheiden können, müssen die Variablen in zwei verschiedenen Namespaces deklariert werden. Ein Namespace ist ein Block mit einem Namen, der seine eigenen benannten Entitäten hat. Der Name eines Namespace ist der Name des Blocks. Zwei verschiedene Namespaces können Entitäten mit den gleichen Namen haben. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
Namespace NA

char ch1;
char ch2 = 'q';

Namespace NB

char ch1;
char ch2 = 'y';

int main ()

Na :: Ch1 ​​= 'P';
Cout << NA::ch1 << endl;
Nb :: ch1 = 'x';
Cout << NB::ch1 << endl;
Rückkehr 0;

Die Ausgabe ist:

P
X

Es gibt zwei Namespaces: Na und NB. Der vordefinierte Raum für NA ist sein Block. Der vordefinierte Raum für NB ist auch sein Block. Beachten Sie, dass die Entitäten in den beiden verschiedenen Blöcken die gleichen Namen haben. Beginnen Sie mit dem reservierten Wort, Namespace, um einen Namespace zu deklarieren. Es folgt ein Raum, dann der Block mit seinen Entitäten.

Beginnen Sie mit dem Namen des Namespace, um auf ein Entität außerhalb des Namespace -Blocks zuzugreifen. Darauf folgt der Operator der Bereichsauflösung und dann der Name der Entität.

Der Umfang der Variablen, Na :: Ch1, beginnt vom Punkt der Erklärung von CH1 im NA -Block. Es endet am Ende des NA -Blocks und erscheint dann in einer beliebigen Zeile außerhalb (und unten) im Block, in dem „Na ::“ verwendet wird. Der Umfang der Variablen, NB :: CH1, beginnt vom Punkt der Erklärung von CH1 im NB -Block. Es endet am Ende des NB -Blocks und erscheint in einer beliebigen Zeile außerhalb (und unten) im Block, wobei „NB ::“ verwendet wird.

Ein Namespace -Bereich bezieht sich auf ein im Namespace -Block deklarierter Unternehmen. Der Umfang der Namespace -Entität ist der Namespace -Block und eine beliebige Zeile außerhalb des Blocks, der den Namespace -Namen verwendet.

Umfang in verschiedenen Teilen

Die vorherigen Klassen- und Namespace -Scopes haben veranschaulicht, wie sich ein Umfang in verschiedenen Teilen des Programmtextes befinden kann. Ein weiteres gutes Beispiel ist der Freund des Freundes.

Freundspezifizierer

Wenn die Klasse C in der Definition der Klasse A als Freund der Klasse A deklariert wird, können alle Funktionen der öffentlichen Mitglieder der Klasse C auf die privaten Datenmitglieder (und private Mitgliedsfunktionen) der Klasse A zugreifen. Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
Klasse a
privat: int d = 5;
Freund Klasse C;
;
Klasse b
/*
public: int fb ()
A a;
Rückkehr a.D;

*/
;
Klasse C
public: int fc ()
A a;
Rückkehr a.D;

;
int main ()

A a;
B b;
C c;
// int ret1 = b.fb ();
int ret2 = c.fc ();
Cout << ret2 << endl;
Rückkehr 0;

Der Ausgang ist 5. In der Definition von Klasse A wird die Klasse C als Freund der Klasse A deklariert. FC () der Definition der Klasse C kann also d der Definition der Klasse A sehen. Das Programm kompiliert. Wenn die Kommentarsymbole entfernt werden, wird das Programm nicht kompiliert, da die Klasse B kein Freund in Klasse A erklärt wurde.

Der Umfang der privaten Variablen B beginnt von seinem Erklärungspunkt und endet am Ende des Blocks der Klasse A. Es erscheint auch in der FC () -Funktion in Klasse C, die ein Freund von Klasse A ist. Die beiden Teile für den Bereich sind der Block der Klasse A und der FC () -Funktionsblock.

Abschluss

Ein Umfang ist eine deklarative Region. Eine deklarative Region ist der größte Teil eines Programmtextes, in dem der Name einer Entität gültig ist. Es kann in mehr als einen Teil mit bestimmten Programmierschemata unterteilt werden, wie z. B. verschachtelte Blöcke. Die Teile, die nicht den Deklarationspunkt haben, bilden den potenziellen Umfang. Der potenzielle Bereich kann die Erklärung haben oder nicht.