Wir haben Namespaces im folgenden Satz 1 eingeführt.
Namespace in C++ | Set 1 (Einführung)

Definieren eines Namespace:

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

Namespace  namespace_name 
{
// Code-Deklarationen, d. h. Variable  (int a;)
Methode (void add();)
Klassen ( Klasse 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:

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:

SYNTAX: 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:

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

Es ist auch möglich, mehr als einen Namensraum im globalen Raum zu erstellen. Dies kann auf zwei Arten erfolgen. 
 

Namespaces mit unterschiedlichen Namen  
 

   // A C++ program to show more than one namespaces    // with different names.   #include      using     namespace     std  ;   // first name space   namespace     first   {      int     func  ()     {     return     5  ;     }   }   // second name space   namespace     second   {      int     func  ()     {     return     10  ;     }   }   int     main  ()   {      // member function of namespace      // accessed using scope resolution operator      cout     &  lt  ;  &  lt  ;     first  ::  func  ()     &  lt  ;  &  lt  ;  &  quot  ;    n  &  quot  ;;         cout     &  lt  ;  &  lt  ;     second  ::  func  ()     &  lt  ;  &  lt  ;  &  quot  ;    n  &  quot  ;;         return     0  ;   }   

• 
  Ausgabe: 
   

5 10 

Namensräume erweitern (gleichen Namen zweimal verwenden)  
Es ist auch möglich, zwei Namensraumblöcke mit demselben Namen zu erstellen. Der zweite Namensraumblock ist eigentlich nichts anderes als die Fortsetzung des ersten Namensraums. Mit einfacheren Worten können wir sagen, dass beide Namensräume nicht unterschiedlich, sondern tatsächlich gleich sind und in Teilen definiert werden. 
 

   // C++ program to demonstrate namespace extension   #include      using     namespace     std  ;   // first name space   namespace     first      {         int     val1     =     500  ;      }   // rest part of the first namespace   namespace     first      {         int     val2     =     501  ;      }   int     main  ()   {      cout     &  lt  ;  &  lt  ;     first  ::  val1     &  lt  ;  &  lt  ;  &  quot  ;    n  &  quot  ;;         cout     &  lt  ;  &  lt  ;     first  ::  val2     &  lt  ;  &  lt  ;  &  quot  ;    n  &  quot  ;;         return     0  ;   }   

• 
  Ausgabe: 
   

500 501 

Unbenannte Namespaces  
 

• Sie sind direkt im selben Programm verwendbar und dienen der Deklaration eindeutiger Bezeichner.
• Bei unbenannten Namensräumen wird der Name des Namensraums in der Namensraumdeklaration nicht erwähnt.
• Der Name des Namespace wird vom Compiler eindeutig generiert.
• Auf die von Ihnen erstellten unbenannten Namespaces kann nur innerhalb der Datei zugegriffen werden, in der Sie sie erstellt haben.
• Unbenannte Namensräume sind der Ersatz für die statische Deklaration von Variablen.

   // C++ program to demonstrate working of unnamed    // namespaces   #include      using     namespace     std  ;   // unnamed namespace declaration   namespace      {      int     rel     =     300  ;      }   int     main  ()   {      cout     &  lt  ;  &  lt  ;     rel     &  lt  ;  &  lt  ;     &  quot  ;    n  &  quot  ;;     // prints 300      return     0  ;   }   

Ausgabe: 
 

300