Espace de noms en C++ | Ensemble 1 (Introduction) Espace de noms en C++ | Ensemble 2 (espace de noms étendu et espace de noms sans nom)

Différentes manières d'accéder à l'espace de noms : En C++, il existe deux manières d’accéder aux variables et fonctions d’espace de noms.

Définir un espace de noms :

Une définition d'espace de noms commence par le mot-clé namespace suivi du nom de l'espace de noms comme suit :

 namespace  namespace_name    
 {   
 // code declarations i.e. variable  (int a;)   
 method (void add();)   
 classes ( class student{};)   
 }  
 Il est à noter qu’il n’y a pas de point-virgule (;) après l’accolade fermante.   
 Pour appeler la version compatible avec l'espace de noms d'une fonction ou d'une variable, ajoutez le nom de l'espace de noms comme suit :   
 nom_espace de noms : :code;  // le code peut être une fonction ou une classe variable.  
  
 La directive using :  
  
 Vous pouvez également éviter de pré-ajouter des espaces de noms avec la directive using namespace. Cette directive indique au compilateur que le code suivant utilise des noms dans l'espace de noms spécifié.    
 L'espace de noms est donc implicite pour le code suivant :  
 C++   
   #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  ;   }   
   
 Les noms introduits dans une directive using obéissent aux règles de portée normales. Le nom est visible du point de la directive using jusqu'à la fin de la portée dans laquelle se trouve la directive. Les entités portant le même nom définies dans une portée externe sont masquées.  
  
 Espaces de noms imbriqués :  
  
 Les espaces de noms peuvent être imbriqués où vous pouvez définir un espace de noms dans un autre espace de noms comme suit :  
  
 namespace namespace_name1    
 {   
   // code declarations   
   namespace namespace_name2    
   {   
      // code declarations   
   }   
 }  
 Vous pouvez accéder aux membres d'un espace de noms imbriqué à l'aide des opérateurs de résolution comme suit :   
 // pour accéder aux membres de namespace_name2   
 en utilisant l'espace de noms namespace_name1::namespace_name2 ;   
 // pour accéder aux membres de l'espace de noms:name1   
 en utilisant l'espace de noms namespace_name1 ;  
  
  
 Dans les instructions ci-dessus, si vous utilisez namespace_name1, les éléments de namespace_name2 seront disponibles dans la portée comme suit :  
 C++   
   #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. Voie normale       
 CPP   
   // 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     &  lt  ;  &  lt  ;     geek  ::  rel     &  lt  ;  &  lt  ;     &  quot  ;    n  &  quot  ;;     // prints 300      return     0  ;   }   
   
 Sortir :  
  
 300   
 
    2. directive « utilisation »       
 CPP   
   // 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     &  lt  ;  &  lt  ;     rel     &  lt  ;  &  lt  ;     &  quot  ;    n  &  quot  ;;     //prints 300          return     0  ;   }   
   
 Sortir:  
  
 300   
 
    Utilisation de l'espace de noms dans les fichiers d'en-tête    Nous pouvons créer un espace de noms dans un fichier et accéder au contenu à l'aide d'un autre programme. Cela se fait de la manière suivante.  
  
 
 Nous devons créer deux fichiers. Celui contenant l’espace de noms et toutes les données membres et fonctions membres que nous souhaitons utiliser plus tard.  
 
 Et l'autre programme peut appeler directement le premier programme pour utiliser toutes les données membres et fonctions membres qu'il contient.  
 
 
    Fichier 1       
 CPP   
   // file1.h    namespace     foo   {      int     value  ()         {         return     5  ;         }   }   
   
    Fichier 2       
 CPP   
   // file2.cpp - Not to be executed online   #include      #include file1.h   // Including file1   using     namespace     std  ;   int     main     ()      {      cout     &  lt  ;  &  lt  ;     foo  ::  value  ();      return     0  ;   }   
   
 Ici, nous pouvons voir que l'espace de noms est créé dans file1.h et que la valeur() de cet espace de noms est appelée dans file2.cpp.     Espaces de noms imbriqués    En C++, les espaces de noms peuvent également être imbriqués, c'est-à-dire un espace de noms dans un autre. La résolution des variables d'espace de noms est hiérarchique.   
 CPP   
   // 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     &  lt  ;  &  lt  ;     out  ::  in  ::  val2  ;     // prints 5      return     0  ;   }   
   
 SORTIR :  
  
 5   
 
    Alias ​​d'espace de noms :    En C++, vous pouvez utiliser un alias pour le nom de votre espace de noms pour plus de facilité d'utilisation. Les espaces de noms existants peuvent être attribués à de nouveaux noms avec la syntaxe suivante :  
  
 namespace new_name = current_name;   
 CPP   
   #include      namespace     name1      {      namespace     name2         {      namespace     name3         {      int     var     =     42  ;      }      }   }   // Aliasing    namespace     alias     =     name1  ::  name2  ::  name3  ;       int     main  ()   {      std  ::  cout     &  lt  ;  &  lt  ;     alias  ::  var     &  lt  ;  &  lt  ;     'n'  ;   }   
   
 Sortir :  
  
 42   
 
 Si vous aimez GeeksforGeeks et souhaitez contribuer, vous pouvez également écrire un article en utilisant    écrire.geeksforgeeks.org    ou envoyez votre article à [email protected]. Consultez votre article apparaissant sur la page principale de GeeksforGeeks et aidez les autres Geeks.