Alles, was Sie über Namespace in C ++ wissen müssen

Dieser Artikel vermittelt Ihnen detaillierte und umfassende Kenntnisse des Namespace in C ++. Es gibt verschiedene Arten und Verwendungen in jedem Programm.

Der Namespace in C ++ wird verwendet, um Code in logischen Gruppen zu organisieren und Namenskollisionen zu verhindern, die insbesondere dann auftreten können, wenn Ihre Codebasis mehrere Bibliotheken enthält. In diesem Artikel werden die folgenden Hinweise behandelt:

Die Notwendigkeit für Namespace

Stellen Sie sich eine Situation vor, wir schreiben Code mit einer Funktion namens abc () und es steht eine weitere vordefinierte Bibliothek zur Verfügung, die ebenfalls dieselbe Funktion abc () hat. Zum Zeitpunkt der Kompilierung hat der Compiler keine Ahnung, auf welche Version der Funktion abc () wir in unserem Code verweisen.



Namespace in c ++

Um diese Schwierigkeit zu überwinden, wurde der Namespace entworfen und als zusätzliche Information verwendet, um ähnliche Funktionen, Variablen, Klassen usw. mit demselben Namen zu unterscheiden, die in verschiedenen Bibliotheken verfügbar sind. Mit dem Namespace können wir den Kontext definieren, in dem Namen definiert werden. Im Wesentlichen definiert ein Namespace einen Bereich.

Alle C ++ - Standardbibliothekstypen und -funktionen werden im Standard-Namespace oder in Namespaces deklariert, die in Standard verschachtelt sind. Daher wird es in den meisten Programmen häufig verwendet.

Namespace definieren

Um den Namespace zu definieren, beginnen wir mit dem Schlüsselwort Namespace, gefolgt vom Namespace-Namen wie folgt:

Namespace Namespace-Name {int a, b // Code-Deklarationen, wobei // a und b im Bereich des // Namespace-Namens deklariert sind}

Punkte, die beim Definieren eines Namespace zu beachten sind

  • Namespace-Deklarationen werden nur im globalen Bereich angezeigt.
  • Namespace-Deklarationen haben keine Zugriffsspezifizierer.
  • Namespace-Deklarationen können in einem anderen Namespace verschachtelt werden.
  • Nach der schließenden Klammer der Definition des Namespace muss kein Semikolon angegeben werden.
  • Die Namespace-Definition kann auf mehrere Einheiten aufgeteilt werden.
#include using namespace std namespace first_function {void func () {cout<< 'Inside first_function' << endl } } namespace second_function { void func() { cout << 'Inside second_function' << endl } } int main () { // Calls function from first name space. first_function::func() // Calls function from second name space. second_function::func() return 0 }

Ausgabe:

Im obigen Beispiel verwenden wir das Namespace-Konzept, um die Funktion func () zwei Mal zu definieren. Wir definieren die erste Funktion unter dem Namespace first_function undzweite Funktion unter dem Namespace second_function. Um diese Funktionen aufzurufen, verwenden wir den Operator für die Bereichsauflösung auf folgende Weise: first_function :: func () und second_function :: func ().

Verwenden des Namespace in C ++

Es gibt drei Möglichkeiten, einen Namespace im Programm zu verwenden:

  1. Die using-Direktive
  2. Die using-Deklaration
  3. Scope Resolution Operator (: :)

Die using-Direktive

Wir können vermeiden, dass Namespaces mit dem vorangestellt werden mit Namespace-Direktive. mit Mit dem Schlüsselwort können wir einen gesamten Namespace mit einem globalen Gültigkeitsbereich in Ihr Programm importieren. Es kann verwendet werden, um einen Namespace gemäß unserer Anforderung in einen anderen Namespace oder ein beliebiges Programm zu importieren.

Marker-Schnittstelle in Java-Beispiel

Betrachten Sie eine Header-Datei Namespace_first.h:

Namespace First {int eine Klasse First_class {int i}}

Einfügen der obigen Namespace-Headerdatei in die Datei Namespace_second.h: include 'Namespace_first.h'

Was ist ein Postgraduierten-Zertifikat?
Namespace Second {Verwenden des Namespace First First_class obj int y}

Wir importieren den Namespace_First in den Namespace_Second, daher ist die Klasse First_class jetzt im Namespace_Second verfügbar. Daher können wir das folgende Programm in eine separate Datei schreiben, sagen wir new_file.cpp.

#include 'Namespace_second.h' void test () {using namespace Second // Objekt der Klasse First_class First_class obj2 erstellen}

Daher Die using-Direktive erleichtert die Verwendung eines Namespace in C ++ erheblich, wo immer Sie möchten.

Die using-Deklaration

In der using-Deklaration importieren wir jeweils einen bestimmten Namen, der nur innerhalb des aktuellen Bereichs verfügbar ist und mit Hilfe der Bereichsauflösung aufgerufen wird. HINWEIS: Der mit der using-Deklaration importierte Name kann den mit der using-Direktive importierten Namen überschreiben. Wir können dies im folgenden Beispiel sehen.

Betrachten wir eine Header-Datei New_File.h:

Namespace First {void A () {cout<< 'A of First namespacen' } } namespace Second { void A() { cout << 'A of Second namespacen' } }

Erstellen wir nun eine neue Programmdatei mit dem Namen New_file_2.cpp mit dem folgenden Code:

#include 'New_file.h' void B () {Verwenden des Namespace First // Verwenden der Direktive Verwenden von Second :: A // Verwenden der Deklaration First :: A () // Klasse A () des Ersten Namespace A () // Ruft A auf () des zweiten Namespace}

Scope Resolution Operator (: :)

Wir können jeden in einem Namespace deklarierten Namen explizit angeben, indem wir den Namen des Namespaces und die Bereichsauflösung verwenden. :: ' Operator mit der Kennung.

Namespace New_space {Klasse X {statisch int i public: void func ()} // Klassennamendeklaration Klasse Y} // Initialisierung der statischen Klassenvariablen int New_space :: X :: i = 23 Klasse New_space :: Y {int a public: int getdata () {cout<< a } // Constructor declaration Y() } // Constructor definition explicitly New_space::Y::Y() { a=0 }

Nicht zusammenhängender Namespace in C ++

Wie wir wissen, kann ein Namespace in C ++ in mehreren Teilen definiert werden, daher besteht er aus der Summe seiner separat definierten Teile. Wenn für einen Teil des Namespace ein in einer anderen Datei definierter Name erforderlich ist, muss dieser Name dennoch in seinem Gültigkeitsbereich deklariert werden. Wenn Sie den folgenden Namespace folgendermaßen schreiben, wird entweder ein neuer Namespace definiert oder einem vorhandenen Element werden neue Elemente hinzugefügt:

Namespace Namespace-Name {// Code Body}

Verschachtelter Namespace in C ++

Namespaces können einfach verschachtelt werden und wir können einen Namespace in einem anderen Namespace wie folgt definieren:

Namespace Namespace-Name1 {// Code-Body von Namespace-Name1 Namespace-Namespace-Name2 {// Code-Body verschachtelter Namespace-Name2}}

Damit ist der Namespace im C ++ - Artikel beendet. Ich hoffe, Sie haben eine Vorstellung davon, was genau ein Namespace in C ++ ist und wie Sie ihn auf unterschiedliche Weise definieren. Wenn Sie mehr erfahren möchten, lesen Sie die von Edureka, einem vertrauenswürdigen Online-Lernunternehmen. Der Java J2EE- und SOA-Schulungs- und Zertifizierungskurs von Edureka wurde entwickelt, um Sie sowohl für Kern- als auch für fortgeschrittene Java-Konzepte sowie für verschiedene Java-Frameworks wie Hibernate & Spring zu schulen.

Hast du eine Frage an uns? Bitte erwähne es im Kommentarbereich dieses Blogs und wir werden uns so schnell wie möglich bei dir melden.