Namensräume in C++

Stellen Sie sich eine Situation vor, in der wir zwei Personen mit demselben Namen, Zara, in derselben Klasse haben. Wann immer wir sie definitiv unterscheiden müssen, müssten wir einige zusätzliche Informationen zusammen mit ihrem Namen verwenden, wie entweder die Gegend, ob sie in einer anderen Gegend leben oder den Namen ihrer Mutter oder ihres Vaters usw.

Dieselbe Situation kann in Ihren C++-Anwendungen auftreten. Zum Beispiel könnten Sie einen Code schreiben, der eine Funktion namens xyz() hat, und es gibt eine andere verfügbare Bibliothek, die auch dieselbe Funktion xyz() hat. Jetzt hat der Compiler keine Möglichkeit zu wissen, auf welche Version der xyz()-Funktion Sie sich in Ihrem Code beziehen.

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

Definieren eines Namensraums

Eine Namespace-Definition beginnt mit dem Schlüsselwort namespace gefolgt vom Namespace-Namen wie folgt:−

namespace namespace_name {
   // code declarations
}

Um die Namespace-aktivierte Version einer Funktion oder Variablen aufzurufen, stellen Sie dem Namespace-Namen (::) wie folgt voran −

name::code;  // code could be variable or function.

Lassen Sie uns sehen, wie der Namensraum die Entitäten umfasst, einschließlich Variablen und Funktionen −

Live-Demo

#include <iostream>
using namespace std;

// first name space
namespace first_space {
   void func() {
      cout << "Inside first_space" << endl;
   }
}

// second name space
namespace second_space {
   void func() {
      cout << "Inside second_space" << endl;
   }
}

int main () {
   // Calls function from first name space.
   first_space::func();
   
   // Calls function from second name space.
   second_space::func(); 

   return 0;
}

Wenn wir den obigen Code kompilieren und ausführen, würde dies das folgende Ergebnis erzeugen −

Inside first_space
Inside second_space

Die using-Direktive

Sie können das Voranstellen von Namespaces auch mit using namespace vermeiden Richtlinie. Diese Direktive teilt dem Compiler mit, dass der nachfolgende Code Namen im angegebenen Namespace verwendet. Der Namensraum ist somit für den folgenden Code impliziert −

Live-Demo

#include <iostream>
using namespace std;

// first name space
namespace first_space {
   void func() {
      cout << "Inside first_space" << endl;
   }
}

// second name space
namespace second_space {
   void func() {
      cout << "Inside second_space" << endl;
   }
}

using namespace first_space;
int main () {
   // This calls function from first name space.
   func();
   
   return 0;
}

Wenn wir den obigen Code kompilieren und ausführen, würde dies das folgende Ergebnis erzeugen −

Inside first_space

Die Direktive „using“ kann auch verwendet werden, um auf ein bestimmtes Element innerhalb eines Namensraums zu verweisen. Wenn zum Beispiel der einzige Teil des std-Namensraums, den Sie verwenden möchten, cout ist, können Sie wie folgt darauf verweisen −

using std::cout;

Nachfolgender Code kann auf cout verweisen, ohne den Namespace voranzustellen, aber auf andere Elemente in std Namespace muss weiterhin wie folgt explizit angegeben werden −

Live-Demo

#include <iostream>
using std::cout;

int main () {
   cout << "std::endl is used with std!" << std::endl;
   
   return 0;
}

Wenn wir den obigen Code kompilieren und ausführen, würde dies das folgende Ergebnis erzeugen −

std::endl is used with std!

Namen, die in einer Verwendung eingeführt wurden Direktive gehorchen den normalen Geltungsbereichsregeln. Der Name ist ab dem Punkt der Verwendung sichtbar Richtlinie bis zum Ende des Geltungsbereichs, in dem sich die Richtlinie befindet. Entitäten mit demselben Namen, die in einem äußeren Gültigkeitsbereich definiert sind, werden ausgeblendet.

Nicht zusammenhängende Namespaces

Ein Namensraum kann in mehreren Teilen definiert werden und somit setzt sich ein Namensraum aus der Summe seiner separat definierten Teile zusammen. Die einzelnen Teile eines Namensraums können über mehrere Dateien verteilt werden.

Wenn also ein Teil des Namensraums einen Namen erfordert, der in einer anderen Datei definiert ist, muss dieser Name dennoch deklariert werden. Das Schreiben einer folgenden Namespace-Definition definiert entweder einen neuen Namespace oder fügt einem bestehenden neue Elemente hinzu −

namespace namespace_name {
   // code declarations
}

Verschachtelte Namespaces

Namensräume können verschachtelt werden, wobei Sie einen Namensraum innerhalb eines anderen Namensraums wie folgt definieren können −

namespace namespace_name1 {
   // code declarations
   namespace namespace_name2 {
      // code declarations
   }
}

Sie können auf Mitglieder des verschachtelten Namensraums zugreifen, indem Sie Auflösungsoperatoren wie folgt verwenden −

// to access members of namespace_name2
using namespace namespace_name1::namespace_name2;

// to access members of namespace:name1
using namespace namespace_name1;

Wenn Sie in den obigen Anweisungen namespace_name1 verwenden, werden Elemente von namespace_name2 wie folgt im Geltungsbereich verfügbar gemacht −

Live-Demo

#include <iostream>
using namespace std;

// first name space
namespace first_space {
   void func() {
      cout << "Inside first_space" << endl;
   }
   
   // second name space
   namespace second_space {
      void func() {
         cout << "Inside second_space" << endl;
      }
   }
}

using namespace first_space::second_space;
int main () {
   // This calls function from second name space.
   func();
   
   return 0;
}

Wenn wir den obigen Code kompilieren und ausführen, würde dies das folgende Ergebnis erzeugen −

Inside second_space