Espaço para nome em C++ | Conjunto 1 (Introdução) Espaço para nome em C++ | Conjunto 2 (ampliação de namespace e namespace sem nome)

Diferentes maneiras de acessar o namespace: Em C++, existem duas maneiras de acessar variáveis ​​e funções de namespace.

Definindo um Namespace:

Uma definição de namespace começa com a palavra-chave namespace seguida pelo nome do namespace como segue:

 namespace  namespace_name    
 {   
 // code declarations i.e. variable  (int a;)   
 method (void add();)   
 classes ( class student{};)   
 }  
 Deve-se observar que não há ponto e vírgula (;) após a chave de fechamento.   
 Para chamar a versão habilitada para namespace de qualquer função ou variável, acrescente o nome do namespace da seguinte maneira:   
 nome_do_espaço_de_nome::código;  // o código pode ser uma função variável ou classe.  
  
 A diretiva using:  
  
 Você também pode evitar a adição de namespaces com a diretiva using namespace. Esta diretiva informa ao compilador que o código subsequente está fazendo uso de nomes no namespace especificado.    
 O namespace está, portanto, implícito no seguinte código:  
 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  ;   }   
   
 Os nomes introduzidos em uma diretiva using obedecem às regras normais de escopo. O nome é visível desde o ponto da diretiva using até o final do escopo em que a diretiva se encontra. Entidades com o mesmo nome definido em um escopo externo ficam ocultas.  
  
 Namespaces aninhados:  
  
 Os namespaces podem ser aninhados onde você pode definir um namespace dentro de outro namespace da seguinte maneira:  
  
 namespace namespace_name1    
 {   
   // code declarations   
   namespace namespace_name2    
   {   
      // code declarations   
   }   
 }  
 Você pode acessar membros do namespace aninhado usando operadores de resolução da seguinte maneira:   
 // para acessar membros do namespace_name2   
 usando o namespace namespace_name1::namespace_name2;   
 // para acessar membros do namespace:name1   
 usando o namespace namespace_name1;  
  
  
 Nas instruções acima, se você estiver usando namespace_name1, os elementos de namespace_name2 serão disponibilizados no escopo da seguinte forma:  
 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. Maneira normal       
 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  ;   }   
   
 Saída :  
  
 300   
 
    2. Diretiva «usar»       
 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  ;   }   
   
 Saída:  
  
 300   
 
    Usando namespace em arquivos de cabeçalho    Podemos criar namespace em um arquivo e acessar o conteúdo usando outro programa. Isso é feito da seguinte maneira.  
  
 
 Precisamos criar dois arquivos. Um contendo o namespace e todos os membros de dados e funções de membro que desejamos usar posteriormente.  
 
 E o outro programa pode chamar diretamente o primeiro programa para usar todos os membros de dados e funções de membro nele.  
 
 
    Arquivo 1       
 CPP   
   // file1.h    namespace     foo   {      int     value  ()         {         return     5  ;         }   }   
   
    Arquivo 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  ;   }   
   
 Aqui podemos ver que o namespace é criado em file1.h e o valor() desse namespace está sendo chamado em file2.cpp.     Namespaces aninhados    Em C++, os namespaces também podem ser aninhados, ou seja, um namespace dentro de outro. A resolução das variáveis ​​de namespace é hierárquica.   
 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  ;   }   
   
 SAÍDA :  
  
 5   
 
    Alias ​​de namespace:    Em C++, você pode usar um nome alternativo para o nome do seu namespace para facilitar o uso. Os namespaces existentes podem receber novos nomes com a seguinte sintaxe:  
  
 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'  ;   }   
   
 Saída :  
  
 42   
 
 Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo usando    escreva.geeksforgeeks.org    ou envie seu artigo para [email protected]. Veja seu artigo aparecendo na página principal do GeeksforGeeks e ajude outros Geeks.