Phenquestions
Artikelinhalt
- Deklarativer Bereich und Geltungsbereich
- Globaler Geltungsbereich
- Blockbereich
- Funktionsumfang
- Aufzählungsbereich
- Klassenumfang
- Vorlagenparameterbereich
- Namensverstecken
- Möglichkeit zur Wiederholung der Erklärung im gleichen Umfang
- Namespace-Bereich
- Umfang in verschiedenen Portionen
- Fazit
Deklarativer Bereich und Geltungsbereich
Eine deklarative Region ist der größte Teil eines Programmtextes, in dem der Name einer Entität gültig ist. Es ist die Region, in der der unqualifizierte Name verwendet (gesehen) werden kann, um auf dieselbe Entität zu verweisen. Betrachten Sie das folgende kurze Programm:
#einschließenVerwenden von Namespace-Std;
Leere fn()
intvar = 3;
wenn (1==1)
cout<
int main()
fn();
0 zurückgeben;
Die Funktion fn() hat zwei Blöcke: einen inneren Block für die if-Bedingung und einen äußeren Block für den Funktionsrumpf. Der Bezeichner var wird eingeführt und im äußeren Block angezeigt. Es ist auch im inneren Block zu sehen, mit der cout-Anweisung. Der äußere und der innere Block sind beide der Geltungsbereich für den Namen, var.
Der Name var kann jedoch weiterhin verwendet werden, um eine andere Entität wie beispielsweise ein Float im inneren Block zu deklarieren. Der folgende Code veranschaulicht dies:
#einschließenVerwenden von Namespace-Std;
Leere fn()
intvar = 3;
wenn (1==1)
float var = 7.5;
cout<
int main()
fn();
0 zurückgeben;
Die Ausgabe ist 7.5. In diesem Fall kann der Name var im inneren Block nicht mehr verwendet werden, um auf die ganze Zahl mit dem Wert 3 zu verweisen, die im äußeren Block eingeführt (deklariert) wurde. Solche inneren Blöcke werden als potenzieller Geltungsbereich für Entitäten bezeichnet, die im äußeren Block deklariert sind.
Hinweis: Eine Entität des gleichen Typs, wie die des äußeren Blocks, kann weiterhin im inneren Block deklariert werden. In diesem Fall gilt jedoch im inneren Block die neue Deklaration und ihre Bedeutung, während die alte Deklaration und ihre Bedeutung außerhalb des inneren Blocks im äußeren Block weiterhin gültig bleibt.
Eine gleichnamige Deklaration in einem inneren Block überschreibt normalerweise die gleichnamige Deklaration außerhalb dieses inneren Blocks. Innere Blöcke können andere innere Blöcke verschachteln.
Globaler Geltungsbereich
Wenn ein Programmierer gerade mit der Eingabe einer Datei beginnt, ist dies der globale Geltungsbereich. Das folgende kurze Programm veranschaulicht dies:
#einschließenVerwenden von Namespace-Std;
float var = 9.4;
int main()
cout <
0 zurückgeben;
Die Ausgabe ist:
9.4
9.4
In diesem Fall beginnt der deklarative Bereich bzw. Geltungsbereich für var ab dem Deklarationspunkt für var, wird nach unten bis zum Ende der Datei (Übersetzungseinheit) fortgesetzt.
Der Block der Funktion main() ist ein anderer Geltungsbereich; es ist ein verschachtelter Bereich für den globalen Bereich. Um auf eine Entität des globalen Geltungsbereichs aus einem anderen Geltungsbereich zuzugreifen, wird der Bezeichner direkt verwendet oder dem Geltungsbereichsauflösungsoperator vorangestellt, :: .
Hinweis: Die Entität main() wird auch im globalen Gültigkeitsbereich deklariert.
Blockbereich
Die if-, while-, do-, for- oder switch-Anweisungen können jeweils einen Block definieren. Eine solche Aussage ist eine zusammengesetzte Aussage. Der Name einer in einem Block deklarierten Variablen hat den Gültigkeitsbereich eines Blocks. Sein Geltungsbereich beginnt am Deklarationspunkt und endet am Ende seines Blocks. Das folgende kurze Programm veranschaulicht dies für die Variable ident:
#einschließenVerwenden von Namespace-Std;
int main()
wenn (1==1)
/*einige Aussagen*/
int-Ident = 5;
cout<
0 zurückgeben;
Eine Variable wie ident, die im Blockbereich deklariert wird, ist eine lokale Variable.
Eine außerhalb des Blockbereichs und darüber deklarierte Variable ist im Header des Blocks zu sehen (e seen.G., Bedingung für if-Block) und auch innerhalb des Blocks. Das folgende kurze Programm veranschaulicht dies für die Variable identif:
#einschließenVerwenden von Namespace-Std;
int main()
int-Kennung = 8;
if (identif == 8)
cout<
0 zurückgeben;
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 Geltungsbereich des main()-Funktionsblocks.
Eine in einen Blockbereich eingefügte Deklaration kann außerhalb des Blocks nicht gesehen werden. Das folgende kurze Programm, das nicht kompiliert, veranschaulicht dies mit der Variablen variab:
#einschließenVerwenden von Namespace-Std;
int main()
wenn (1 == 1)
int variab = 15;
cout<
Der Compiler erzeugt eine Fehlermeldung für variab.
Eine eingeführte Entität, die im Header einer zusammengesetzten Funktion deklariert ist, kann außerhalb (unterhalb) der zusammengesetzten Anweisung nicht gesehen werden. Der folgende for-Schleifencode wird nicht kompiliert, was zu einer Fehlermeldung führt:
#einschließenVerwenden von Namespace-Std;
int main()
für (int i=0; i<4; ++i)
cout<
cout<
Die Iterationsvariable i wird innerhalb des for-Schleifenblocks gesehen, aber nicht außerhalb des for-Schleifenblocks.
Funktionsumfang
Ein Funktionsparameter wird im Funktionsblock angezeigt. Eine in einem Funktionsblock deklarierte Entität wird vom Deklarationspunkt bis zum Ende des Funktionsblocks betrachtet. Das folgende kurze Programm veranschaulicht dies:
#einschließen#einschließen
Verwenden von Namespace-Std;
string fn(string str)
char stri[] = "Bananen";
/*andere Aussagen*/
string totalStr = str + stri;
Rückgabe totalStr;
int main()
string totStr = fn("Essen");
cout<
Die Ausgabe ist:
Bananen essen
Hinweis: Eine außerhalb der Funktion (darüber) deklarierte Entität ist in der Funktionsparameterliste und auch im Funktionsblock zu sehen.
Etikette
Der Geltungsbereich eines Labels ist die Funktion, in der es erscheint. Der folgende Code veranschaulicht dies:
#einschließenVerwenden von Namespace-Std;
Leere fn()
goto labl;
/*andere Aussagen*/
labl: int inte = 2;
cout<
int main()
fn();
0 zurückgeben;
Die Ausgabe ist 2.
Aufzählungsbereich
Aufzählung ohne Gültigkeitsbereich
Betrachten Sie den folgenden if-Block:
Aufzählung 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 ihre Aufzählungen. Der Gültigkeitsbereich eines Enumerators beginnt vom Deklarationspunkt bis zum Ende des umschließenden Blocks der Enumeration.
Die folgende Anweisung wird nicht kompiliert, da der Deklarationspunkt von c nach dem von a liegt:
Aufzählung a=c+2, b, c;Das folgende Codesegment wird nicht kompiliert, da auf die Enumeratoren nach dem einschließenden Block der Enumeration zugegriffen wird:
wenn (1==1)Aufzählung a, b, c=b+2;
cout<
Bereichsbezogene Aufzählung
Die folgende Aussage ist in Ordnung:
Dies ist ein Beispiel für eine bereichsbezogene Enumeration. Der Name der Klasse ist nam. Hier beginnt der Gültigkeitsbereich des Enumerators vom Deklarationspunkt bis zum Ende der Aufzählungsdefinition und nicht bis zum Ende des umschließenden Blocks für die Aufzählung. Der folgende Code wird nicht kompiliert:
wenn (1==1)Aufzählungsklassenname a, b, c=b+2;
cout<
Klassenumfang
Beim normalen Scoping beginnt der deklarative Bereich an einem Punkt, wird dann fortgesetzt und an einem anderen Punkt beendet stops. Der Anwendungsbereich existiert in einer zusammenhängenden Region. Mit der Klasse kann der Geltungsbereich einer Entität in verschiedenen Regionen liegen, die nicht miteinander verbunden sind. Die Regeln für verschachtelte Blöcke gelten weiterhin. Das folgende Programm veranschaulicht dies:
#einschließenVerwenden von Namespace-Std;
//Basisklasse
Klasse Cla
Privatgelände:
int memP = 5;
geschützt:
int memPro = 9;
Öffentlichkeit:
Leere fn()
cout<
;
//Abgeleitete Klasse
Klasse DerCla: öffentlicher Cla
Öffentlichkeit:
int derMem = memPro;
;
int main()
Cla obj;
obj.fn();
DerCla derObj;
cout<
Die Ausgabe ist:
5
9
In der Klasse Cla wird die Variable memP an der Deklarationsstelle gesehen seen. Danach wird der kurze Teil von „protected“ übersprungen und dann wieder im Klassenmember-Funktionsblock angezeigt. Die abgeleitete Klasse wird übersprungen und dann wieder im main()-Funktionsbereich (Block) angezeigt.
In der Klasse Cla wird die Variable memPro an der Deklarationsstelle gesehen seen. Der Teil der öffentlichen Funktion fn() wird übersprungen und dann im abgeleiteten Klassenbeschreibungsblock angezeigt. Es wird wieder unten in der main()-Funktion angezeigt.
Scope Resolution Operator
Der Bereichsauflösungsoperator in C++ ist :: . Es wird verwendet, um auf ein statisches Mitglied der Klasse zuzugreifen. Das folgende Programm veranschaulicht dies:
Verwenden von Namespace-Std;
Klasse Cla
Öffentlichkeit:
static int const mem = 5;
Öffentlichkeit:
statische Leere fn()
cout<
;
int main()
cout<
0 zurückgeben;
Die Ausgabe ist:
5
5
Die statischen Member werden im main()-Funktionsblock angezeigt, auf den mit dem Bereichsauflösungsoperator zugegriffen wird.
Vorlagenparameterbereich
Der normale Gültigkeitsbereich eines Vorlagenparameternamens beginnt vom Deklarationspunkt bis zum Ende seines Blocks, wie im folgenden Code:
VorlageTJohn = 11;
U Peter = 12.3;
T Maria = 13;
U Freude = 14.6;
;
U und T sind innerhalb des Blocks zu sehen.
Bei einem Vorlagenfunktionsprototyp beginnt der Gültigkeitsbereich vom Deklarationspunkt bis zum Ende der Funktionsparameterliste, wie in der folgenden Anweisung:
VorlageBei der Klassenbeschreibung (Definition) kann der Geltungsbereich jedoch auch unterschiedliche Anteile haben, wie im folgenden Code:
#einschließenVerwenden von Namespace-Std;
Vorlage
Öffentlichkeit:
T-Zahl;
statische U ch;
void func (U cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
statischer Leerspaß (U ch)
if (ch == 'a')
cout << "Official static member function" << '\n';
;
int main()
TheCla
obj.Anzahl = 12;
obj.func('$', "500");
0 zurückgeben;
Namensverstecken
Ein Beispiel für das Verbergen von Namen tritt auf, wenn der Name desselben Objekttyps in einem verschachtelten Block erneut deklariert wird. Das folgende Programm veranschaulicht dies:
#einschließenVerwenden von Namespace-Std;
Leere fn()
intvar = 3;
wenn (1==1)
intvar = 4;
cout<
cout<
int main()
fn();
0 zurückgeben;
Die Ausgabe ist:
4
3
Das liegt daran, dass var im verschachtelten Block var im äußeren Block versteckt hat.
Möglichkeit zur Wiederholung der Erklärung im gleichen Umfang
Der Punkt der Deklaration ist, wo der Name (zum ersten Mal) in seinem Geltungsbereich eingeführt wird.
Funktionsprototyp
Unterschiedliche Entitäten, auch unterschiedlichen Typs, können normalerweise nicht im gleichen Geltungsbereich deklariert werden. Ein Funktionsprototyp kann jedoch im selben Geltungsbereich mehr als einmal deklariert werden. Das folgende Programm mit zwei Funktionsprototypen und entsprechender Funktionsdefinition veranschaulicht dies:
Verwenden von Namespace-Std;
void fn(int num);
void fn(int num);
void fn(int num)
cout<
int main()
fn(5);
0 zurückgeben;
Das Programm funktioniert.
Überladene Funktionen
Überladene Funktionen sind Funktionen mit demselben Namen, aber unterschiedlichen Funktionssignaturen. Als weitere Ausnahme können überladene Funktionen gleichen Namens im gleichen Geltungsbereich definiert werden. Das folgende Programm veranschaulicht dies:
Verwenden von Namespace-Std;
void fn(int num)
cout<
void fn(float nein)
cout<
int main()
fn(5);
Schwimmer flt = 8.7;
fn(flt);
0 zurückgeben;
Die Ausgabe ist:
5
8.7
Die überladenen Funktionen wurden im globalen Geltungsbereich definiert.
Namespace-Bereich
Namespace Scope verdient einen eigenen Artikel. Der besagte Artikel wurde für diese Website geschrieben, linuxhint.com. Geben Sie einfach die Suchbegriffe "Namespace Scope" in das Suchfeld dieser Site (Seite) ein und klicken Sie auf OK, und Sie erhalten den Artikel.
Umfang in verschiedenen Portionen
Die Klasse ist nicht das einzige Schema, bei dem der Geltungsbereich in verschiedenen Teilen liegen kann. Friend-Bezeichner, bestimmte Verwendungen des elaborierten-Typ-Bezeichners und using-Direktiven sind andere Schemata, bei denen der Geltungsbereich an anderen Stellen liegt - für Details siehe später.
Fazit
Ein Geltungsbereich 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 nach bestimmten Programmierschemata in mehr als einen Teil unterteilt werden, z. B. in verschachtelte Blöcke. Die Teile, die den Deklarationspunkt nicht haben, bilden den potentiellen Geltungsbereich. Der potenzielle Umfang kann die Erklärung haben oder nicht.
