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:

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

#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  

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

Saída :

300  

2. Diretiva «usar»  

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

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  

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

Arquivo 2  

// file2.cpp - Not to be executed online #include    #include file1.h // Including file1 using namespace std; int main ()  {  cout << 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. 

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

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;  

#include    namespace name1  {  namespace name2   {  namespace name3   {  int var = 42;  }  } } // Aliasing  namespace alias = name1::name2::name3;   int main() {  std::cout << alias::var << '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.