Namespace in C++ | Set 1 (Einführung) Namespace in C++ | Satz 2 (Erweiternder Namespace und Unbenannter Namespace)

Verschiedene Möglichkeiten, auf den Namespace zuzugreifen: In C++ gibt es zwei Möglichkeiten, auf Namespace-Variablen und -Funktionen zuzugreifen.

Definieren eines Namespace:

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

namespace  namespace_name   
{  
// code declarations i.e. variable  (int a;)  
method (void add();)  
classes ( class student{};)  
}

Es ist zu beachten, dass nach der schließenden Klammer kein Semikolon (;) steht.
Um die Namespace-fähige Version einer Funktion oder Variable aufzurufen, stellen Sie den Namespace-Namen wie folgt voran:
namespace_name: :code;  // Code könnte eine variable Funktion oder Klasse sein.

Die using-Direktive:

Algorithmen binäre Suche

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

#include    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; } 

Namen, die in einer using-Direktive eingeführt werden, unterliegen den normalen Gültigkeitsregeln. Der Name ist vom Punkt der using-Direktive bis zum Ende des Bereichs, in dem die Direktive gefunden wird, sichtbar. Entitäten mit demselben Namen, die in einem äußeren Bereich definiert sind, werden ausgeblendet.

Verschachtelte Namespaces:

Namespaces können verschachtelt sein, wobei Sie wie folgt einen Namespace innerhalb eines anderen Namespace definieren können:

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

Sie können auf Mitglieder eines verschachtelten Namespace zugreifen, indem Sie Auflösungsoperatoren wie folgt verwenden:
// um auf Mitglieder von namespace_name2 zuzugreifen
Verwenden des Namensraums namespace_name1::namespace_name2;
// um auf Mitglieder von namespace:name1 zuzugreifen
Verwenden des Namensraums namespace_name1;

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

chmod 755

#include    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; } 

1. Normaler Weg  

// C++ program to demonstrate accessing of variables // in normal way i.e. using '::' #include    using namespace std; namespace geek {  int rel = 300;  } int main() {  // variable ‘rel’ accessed   // using scope resolution operator  cout << geek::rel << "n"; // prints 300  return 0; } 

Ausgabe :

300  

2. „using“-Direktive  

// C++ program to demonstrate accessing of variables // in normal way i.e. using 'using' directive #include    using namespace std; namespace geek {  int rel = 300;  } // use of ‘using’ directive using namespace geek; int main() {  // variable ‘rel’ accessed   // without using scope resolution variable  cout << rel << "n"; //prints 300    return 0; } 

Ausgabe:

300  

Namespace in Header-Dateien verwenden Wir können einen Namespace in einer Datei erstellen und mit einem anderen Programm auf Inhalte zugreifen. Dies geschieht auf folgende Weise.

• Wir müssen zwei Dateien erstellen. Eines, das den Namespace und alle Datenelemente und Elementfunktionen enthält, die wir später verwenden möchten.
• Und das andere Programm kann das erste Programm direkt aufrufen, um alle darin enthaltenen Datenmitglieder und Mitgliedsfunktionen zu verwenden.

Datei 1  

String-Funktionen in Java

// file1.h  namespace foo {  int value()   {   return 5;   } } 

Datei 2  

// file2.cpp - Not to be executed online #include    #include file1.h // Including file1 using namespace std; int main ()  {  cout << foo::value();  return 0; } 

Hier können wir sehen, dass der Namespace in file1.h erstellt wird und der Wert() dieses Namespace in file2.cpp aufgerufen wird. Verschachtelte Namespaces In C++ können Namespaces auch verschachtelt sein, d. h. ein Namespace in einem anderen. Die Auflösung von Namespace-Variablen erfolgt hierarchisch. 

// C++ program to demonstrate nesting of namespaces #include    using namespace std; // Nested namespace namespace out {  int val = 5;   namespace in  {  int val2 = val;   } } // Driver code int main() {  cout << out::in::val2; // prints 5  return 0; } 

AUSGABE :

5  

Namespace-Aliasing: In C++ können Sie zur Vereinfachung der Verwendung einen Aliasnamen für Ihren Namespace-Namen verwenden. Vorhandene Namespaces können mit der folgenden Syntax mit neuen Namen versehen werden:

namespace new_name = current_name;  

#include    namespace name1  {  namespace name2   {  namespace name3   {  int var = 42;  }  } } // Aliasing  namespace alias = name1::name2::name3;   int main() {  std::cout << alias::var << 'n'; } 

Ausgabe :

42  

Wenn Ihnen GeeksforGeeks gefällt und Sie einen Beitrag leisten möchten, können Sie auch einen Artikel über schreiben write.geeksforgeeks.org oder senden Sie Ihren Artikel per E-Mail an [email protected]. Sehen Sie, wie Ihr Artikel auf der Hauptseite von GeeksforGeeks erscheint, und helfen Sie anderen Geeks.