Phenquestions
Betrachten Sie die folgenden zwei skalaren Anweisungen in einem globalen Gültigkeitsbereich im folgenden Programm:
#einschließenVerwenden von Namespace-Std;
int varId = 5;
float varId = 2.3;
int main()
0 zurückgeben;
Ein Versuch, dieses Programm zu kompilieren, führt zu einem Kompilierungsfehler. Es gibt zwei Variablen mit demselben Namen, varId. Obwohl es sich um zwei verschiedene Variablen von zwei verschiedenen Typen handelt, int und schweben, der Compiler lehnt die beiden Deklarationen ab, da sie den gleichen Namen haben. Das folgende Programm löst dieses Problem, indem es die gleichnamigen Variablen in zwei verschiedenen generalisierten Geltungsbereichen deklariert:
#einschließenVerwenden von Namespace-Std;
Namensraum NA
int varId = 5;
Namensraum NB
float varId = 2.3;
int main()
cout << NA::varId << '\n';
cout << NB::varId << '\n';
0 zurückgeben;
Die Ausgabe ist wie folgt:
52.3
Im obigen Programm gibt es zwei Namensräume: N / A, die die Definition einer ganzen Zahl hat, und NB, die die Definition eines Floats hat, aber den gleichen Namen wie die ganze Zahl für NA. Schließlich wurde beim Ausführen des Programms derselbe Name für zwei verschiedene Variablen verwendet. Beachten Sie, dass für den Zugriff auf denselben Namen von zwei verschiedenen Variablen der jeweilige Name für den Namensraum verwendet werden muss, gefolgt vom gemeinsamen Bezeichner. Der Namespace-Name und der allgemeine Bezeichner werden durch den Bereichsauflösungsoperator getrennt, „::.” Der Name der Namensräume wird die Objekte unterscheiden.
Dieser Artikel behandelt das grundlegende Konzept eines Namespace und seine Verwendung in der Programmiersprache C++. Um diesem Artikel folgen zu können, sollten Sie über Grundkenntnisse der Sprache C++ verfügen. Sie sollten auch über Kenntnisse des C++-Bereichs verfügen, obwohl er in diesem Artikel kurz erklärt wird. Um mehr über den Geltungsbereich von C++ zu erfahren, suchen Sie im Suchfeld eines beliebigen Linux-Hinweises nach dem Ausdruck „Geltungsbereich in C++“ (ohne Anführungszeichen).com-Webseite und drücken Sie die Eingabetaste. Dies führt Sie zu dem Artikel, den dieser Autor geschrieben hat.
Artikelinhalt
- Was ist ein Namensraum??
- Die Nutzungsrichtlinie
- Verschachtelte Namespaces
- Standard-Namensraum
- Fazit
Was ist ein Namensraum??
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 Scope bezeichnet. Ein Namespace in C++ ist ein verallgemeinerter Geltungsbereich, dessen Hauptzweck darin besteht, Namenskonflikte zu lösen. Ein Namespace hat grundlegende Deklarationen und/oder Definitionen von Entitäten.
Globaler Namensraum und sein Problem
Der globale Namespace ist der globale Geltungsbereich. Betrachten Sie das folgende kurze Programm:
#einschließenVerwenden von Namespace-Std;
int ident = 55;
Schwimmerkennung = 12.17;
int main()
0 zurückgeben;
Im obigen Programm gibt es zwei Variablen, die beide genannt werden ident. Diese Variablen befinden sich im globalen Gültigkeitsbereich; das heißt, sie befinden sich im globalen Namensraum. Ein Versuch, dieses Programm zu kompilieren, schlägt mit einer Fehlermeldung fehl. Der globale Gültigkeitsbereich akzeptiert nicht mehr als eine Variable mit demselben Namen, daher ist ein benutzerdefinierter Namespace erforderlich.
Benutzerdefinierter Namensraum
Ein Namespace hat nicht nur einen Namen. Stattdessen hat ein Namespace eine Reihe von Namen, um Konflikte mit anderen Namenssätzen zu vermeiden. Um Konflikte weiter unten im Code zu vermeiden, stellen Sie vor jedem Namen den Namen des Namensraums und :: . Das folgende Programm veranschaulicht dies anhand von zwei benutzerdefinierten Namespaces:
#einschließenVerwenden von Namespace-Std;
Namensraum NA
int varInt = 6;
Schwimmer flt;
Namensraum NB
int varInt = 7;
Schwimmer flt;
int main()
cout << NA::varInt << '\n';
cout << NB::varInt << '\n';
NA::flt = 2.5;
Hinweis::flt = 4.8;
cout << NA::flt << '\n';
cout << NB::flt << '\n';
0 zurückgeben;
Die Ausgabe ist:
67
2.5
4.8
Beachten Sie, dass die Namen NA::flt und Hinweis::flt wurden schließlich in der Main() Funktion. C++ lässt eine solche Definition im globalen Geltungsbereich nicht zu.
Beachten Sie, dass der benutzerdefinierte Namespace ein verschachtelter Namespace für den globalen Namespace ist.
Die Nutzungsrichtlinie
Um zu vermeiden, dass Sie nach der Deklaration des Namensraums nicht ständig „namespace::name“ statt nur „name“ eingeben, können Sie den mit Direktive. Die Syntax zur Verwendung der mit Richtlinie lautet wie folgt:
Namespace verwenden Namespace_name;Das mit Direktive ist keine Präprozessordirektive, daher endet sie mit einem Semikolon (;).
Das folgende Programm veranschaulicht die Verwendung der mit Richtlinie und mehr:
#einschließenVerwenden von Namespace-Std;
Namensraum NB
int varInt = 7;
int-Funktion ()
Rückgabevariable;
int fn()
Namensraum verwenden NB;
int myVar2 = func();
//weitere Objekte und Funktionen von NB folgen.
Rückgabe myVar2;
int myVar3 = NB::func();
int main()
cout << fn() << " << myVar3 << '\n';
0 zurückgeben;
Die Ausgabe dieses Programms ist 7 7. Der Begriff "Namensraum verwenden NB;” steht am Anfang des fn() Definition. Das func() aus dem NB-Namensraum wird direkt darunter aufgerufen, ohne mit „Hinweis::.”
Eine im globalen Geltungsbereich (globaler Namensraum) deklarierte Variable wird vom Deklarationspunkt bis zum Ende der Datei gesehen. Es wird auch in den verschachtelten Namespaces (nested Scopes) angezeigt, wie z fn() Funktionsumfang oben. Das mit Direktive verbindet ihren Namensraum von der Position, an der sie platziert wird, bis zum Ende des Gültigkeitsbereichs, in dem sie platziert ist.
Der Name func() aus dem NB-Namensraum nicht unter dem fn() Definition, weil „unter Verwendung des Namensraums NB;“ wurde in den Funktionsumfang (Block) gelegt. Verwenden Sie unter dieser Bedingung „func()” außerhalb des NB-Namespace-Blocks (Scope) muss ihm ein „Hinweis::,“ wie in der folgenden Aussage:
int myVar3 = NB::func();Das mit Direktive verbindet ihren Namensraum mit dem äußeren Verschachtelungs-Namensraum von der Position, an der sie platziert wurde, bis zum Ende des äußeren Verschachtelungs-Namensraums. Im folgenden Programm wird der NA-Namensraum mit dem globalen Namensraum verknüpft. Beide Namensräume erstrecken sich dann in die fn() Funktionsdefinitions-Namensraum, in dem sie mit dem NB-Namensraum verbunden sind. Der NB-Namensraum endet am Ende des fn() Funktionsdefinition, und die beiden vorherigen Namensräume werden bis zum Ende der Datei fortgesetzt (Code durchlesen).
#einschließenVerwenden von Namespace-Std;
Namensraum NA
int varInt = 6;
int-Funktion ()
Rückgabevariable;
Namensraum NB
int varInt = 7;
int-Funktion ()
Rückgabevariable;
Verwenden des Namensraums NA;
int myVar0 = varInt;
//weitere Objekte und Funktionen von :: und NB folgen.
int fn()
int myVar1 = varInt;
Namensraum verwenden NB;
int myVar2 = NB::func();
//weitere Objekte und Funktionen von NB folgen, bis zum Ende dieses Geltungsbereichs.
Rückgabe von myVar1 + myVar2;
//Es folgen nur Objekte und Funktionen aus :: und NB.
int myVar3 = NB::func();
int main()
cout << myVar0 << " << fn() << " << myVar3 << '\n';
0 zurückgeben;
Die Ausgabe ist 6, 13, 7.
Hinweis: Der globale Namensraum ist mit . gekennzeichnet :: , Das bedeutet, dass vor dem folgenden Bereichsauflösungsoperator nichts steht.
Unter der Anweisung steht das „Verwenden des Namensraums NA;” Variablen aus den globalen und NA-Namensräumen können ohne Angabe ihres Quell-Namensraums verwendet werden. Die nächste Anweisung verwendet die varInt des NA-Namensraums. Die globale und NA-kombinierte Namespace-Region erstreckt sich in die fn() Funktionsnamensraum. Also, die varInt der ersten Aussage im fn() Funktionsumfang, gehört zum NA-Namensraum.
Da sich die Region für die globalen und NA-Namespaces über das gesamte fn() Umfang, nach dem „int myVar2 = NB::func();,” Jeder Name aus dem NB-Namensraum darf nur im fn() Umfang, ohne ihm voranzustellen „Hinweis::,” nur wenn es nicht in den NA- und globalen Namensräumen (Blöcken) vorgekommen ist. Andernfalls sollte ihm vorangestellt werden „Hinweis::.” Die Region der kombinierten Namensräume für NA und global wird unterhalb der fn() Definition und in die Main() Funktion bis zum Ende der Datei.
Die Erweiterung des NB-Namensraums beginnt bei „int myVar2 = NB::func();" in dem fn() Block und endet am Ende des fn() Definitionsblock.
Hinweis: Namespaces, deren Regionen verbunden sind, sollten nicht denselben Variablennamen in ihren verschiedenen Namespace-Blöcken haben, da dies immer noch Konflikte verursachen würde.
Namespace-Regionen
Ein Namespace ist ein Geltungsbereich. Abgesehen vom globalen Namensraum (globaler Geltungsbereich) sollte jeder Namensraum in einem Block deklariert werden. Dieser Block ist der erste Teil der möglicherweise verteilten Regionen des Namensraums. Mit der using-Direktive kann der Namespace als Regionen in anderen Scopes erweitert werden.
In einem Namensraumkörper deklarierte Entitäten werden als Mitglieder des Namensraums bezeichnet, und Namen, die durch diese Deklarationen in den deklarativen Bereich des Namensraums eingeführt werden, werden als Mitgliedsnamen des Namensraums bezeichnet.
Verschachtelte Namespaces
Das folgende Programm zeigt verschachtelte Namespaces:
#einschließenVerwenden von Namespace-Std;
Namensraum A
int i = 1;
Namensraum B
int i = 2;
Namensraum C
int i = 3;
int main()
cout << A::i << " << A::B::i << " << A::B::C::i << '\n';
0 zurückgeben;
Die Ausgabe ist:
1 2 3Beachten Sie, dass auf die drei Werte mit dem Bereichsauflösungsoperator zugegriffen wurde.
Standard-Namensraum
C++ hat eine Bibliothek namens Standardbibliothek. Die Namen von Objekten, Funktionen und anderen Entitäten in dieser Bibliothek stammen aus einem Namensraum namens Standard-Namensraum, geschrieben als std. Die Standardbibliothek enthält Unterbibliotheken, und eine dieser Unterbibliotheken ist iostream. Das iostream Bibliothek enthält das Objekt cout, die verwendet wird, um Ergebnisse an die Konsole (Terminal) zu senden.
Der Name cout muss in der sein std Namensraum. Benutzen iostream mit std Namensraum sollte das Programm wie folgt aussehen:
#einschließenVerwenden von Namespace-Std;
Beachten Sie die Verwendung der mit Richtlinie und std. Der Begriff "#einschließen
Fazit
Ein Namespace ist ein Geltungsbereich. Die Namespace-Beschreibung (Definition) enthält grundlegende Deklarationen und/oder Definitionen von C++-Objekten, Funktionen und anderen Entitäten. Außerhalb der Namensraumdefinition kann auf den Namen mit der Syntax „namespaceName::name.” Außer dem globalen Namensraum (globaler Geltungsbereich) sollte jeder Namensraum in einem Block deklariert werden. Dieser Block ist der erste Teil der möglicherweise verteilten Regionen des Namensraums. Mit dem mit -Direktive kann der Namespace als Regionen in anderen Scopes erweitert werden. Namespaces, deren Regionen verbunden sind, sollten nicht denselben Variablennamen in ihren verschiedenen Namespace-Blöcken haben, da dies immer noch zu Namenskonflikten führen würde.
Chrys
