Phenquestions
Considere as duas instruções escalares a seguir em um escopo global, no seguinte programa:
#incluirusando namespace std;
int varId = 5;
float varId = 2.3;
int main ()
return 0;
Uma tentativa de compilar este programa leva a um erro de compilação. Existem duas variáveis com o mesmo nome, varId. Embora sejam duas variáveis diferentes de dois tipos diferentes, int e flutuador, o compilador rejeita as duas declarações porque têm o mesmo nome. O programa a seguir resolve esse problema declarando as variáveis com o mesmo nome em dois escopos generalizados diferentes:
#incluirusando namespace std;
namespace NA
int varId = 5;
namespace NB
float varId = 2.3;
int main ()
cout << NA::varId << '\n';
cout << NB::varId << '\n';
return 0;
O resultado é o seguinte:
52.3
Existem dois namespaces no programa acima: N / D, que tem a definição de um inteiro, e NB, que tem a definição de um float, mas com o mesmo nome do inteiro para NA. Finalmente, quando o programa foi executado, o mesmo nome para duas variáveis diferentes foi usado. Observe que para acessar o mesmo nome de duas variáveis diferentes, o nome específico para o namespace deve ser usado, seguido pelo identificador comum. O nome do namespace e o identificador comum são separados pelo operador de resolução de escopo, “::.”O nome dos namespaces irá diferenciar os objetos.
Este artigo cobre o conceito básico de um namespace e seu uso na linguagem de programação C ++. Para acompanhar este artigo, você deve ter um conhecimento básico da linguagem C ++. Você também deve ter conhecimento do escopo C ++, embora seja brevemente explicado neste artigo. Para saber mais sobre o escopo C ++, pesquise a frase “Escopo em C ++” (sem aspas) na caixa de pesquisa de qualquer linuxhint.com página da web e pressione Enter. Isso o levará ao artigo que este autor escreveu.
Conteúdo do Artigo
- O que é um namespace?
- A diretriz de uso
- Namespaces aninhados
- Namespace padrão
- Conclusão
O que é um namespace?
Uma região declarativa é a maior parte de um programa em que o nome de uma entidade (variável) é válido. Esta região é chamada de escopo. Um namespace em C ++ é um escopo generalizado cujo objetivo principal é resolver conflitos de nomes. Um namespace tem declarações básicas e / ou definições de entidades.
Namespace global e seu problema
O namespace global é o escopo global. Considere o seguinte programa curto:
#incluirusando namespace std;
int ident = 55;
float ident = 12.17;
int main ()
return 0;
No programa acima, existem duas variáveis, ambas chamadas ident. Essas variáveis estão no escopo global; ou seja, eles estão no namespace global. Uma tentativa de compilar este programa irá falhar com uma mensagem de erro. O escopo global não aceita mais de uma variável com o mesmo nome, portanto, é necessário um namespace personalizado.
Namespace personalizado
Um namespace não tem apenas um nome. Em vez disso, um namespace tem um conjunto de nomes para evitar conflito com outros conjuntos de nomes. Para evitar conflito inferior no código, preceda cada nome com o nome do namespace e :: . O programa a seguir ilustra isso usando dois namespaces personalizados:
#incluirusando namespace std;
namespace NA
int varInt = 6;
float flt;
namespace NB
int varInt = 7;
float flt;
int main ()
cout << NA::varInt << '\n';
cout << NB::varInt << '\n';
NA :: flt = 2.5;
NB :: flt = 4.8;
cout << NA::flt << '\n';
cout << NB::flt << '\n';
return 0;
O resultado é:
67
2.5
4.8
Observe que os nomes NA :: flt e NB :: flt em última análise, foram definidos no a Principal() função. C ++ não permite tal definição no escopo global.
Observe que o namespace personalizado é um namespace aninhado para o namespace global.
A diretriz de uso
Para evitar digitar “namespace :: name” o tempo todo em vez de apenas “name” após declarar o namespace, você pode usar o usando diretriz. A sintaxe para usar o usando diretiva é a seguinte:
using namespace Namespace_name;O usando diretiva não é uma diretiva de pré-processador, então termina com um ponto e vírgula (;).
O programa a seguir ilustra o uso do usando diretiva e mais:
#incluirusando namespace std;
namespace NB
int varInt = 7;
int func ()
return varInt;
int fn ()
usando o namespace NB;
int minhaVar2 = func ();
// outros objetos e funções do NB seguem.
return myVar2;
int minhaVar3 = NB :: func ();
int main ()
cout << fn() << " << myVar3 << '\n';
return 0;
O resultado deste programa é 7 7. O termo "usando o namespace NB;”Foi colocado no início do fn () definição. O função () do namespace NB é chamado logo abaixo disso, sem precedê-lo com “NB ::.”
Uma variável declarada no escopo global (namespace global) é vista do ponto de declaração até o final do arquivo. Também é visto nos namespaces aninhados (escopos aninhados), como o aninhado fn () escopo da função acima. O usando diretiva junta seu namespace a partir da posição em que é colocada até o final do escopo em que é colocada.
O nome função () do namespace NB não pode ser visto abaixo do fn () definição porque “usando namespace NB; ” foi colocado dentro do escopo da função (bloco). Sob esta condição, para usar “função ()”Fora do bloco de namespace NB (escopo), deve ser precedido por“NB ::,”Como na seguinte declaração:
int minhaVar3 = NB :: func ();O usando diretiva une seu namespace com o namespace de aninhamento externo da posição em que é colocada até o final do namespace de aninhamento externo. No programa a seguir, o namespace NA é associado ao namespace global. Ambos os namespaces se estendem para o fn () namespace de definição de função, no qual eles são unidos ao namespace NB. O namespace NB termina no final do fn () definição de função, e os dois namespaces anteriores continuam até o final do arquivo (leia o código).
#incluirusando namespace std;
namespace NA
int varInt = 6;
int func ()
return varInt;
namespace NB
int varInt = 7;
int func ()
return varInt;
usando o namespace NA;
int minhaVar0 = varInt;
// outros objetos e funções de :: e NB seguem.
int fn ()
int minhaVar1 = varInt;
usando o namespace NB;
int minhaVar2 = NB :: func ();
// outros objetos e funções do NB seguem, até o final deste escopo.
return myVar1 + myVar2;
// Apenas objetos e funções de :: e NB seguem.
int minhaVar3 = NB :: func ();
int main ()
cout << myVar0 << " << fn() << " << myVar3 << '\n';
return 0;
A saída é 6, 13, 7.
Observação: O namespace global é indicado com :: , o que significa que não há nada antes do operador de resolução de escopo que segue.
Abaixo da declaração, o “usando o namespace NA;”Variáveis dos namespaces globais e NA podem ser usadas sem uma indicação de seu namespace de origem. A próxima declaração usa o varInt do namespace de NA. A região de namespace global e combinada de NA se estende até o fn () namespace de função. Então o varInt da primeira declaração no fn () escopo da função, é do namespace NA.
Uma vez que a região para os namespaces globais e de NA se estendem por todo o fn () escopo, após o “int minhaVar2 = NB :: func ();,”Qualquer nome do namespace NB só pode ser usado no fn () escopo sem precedê-lo com “NB ::,”Apenas se não ocorresse no NA e nos namespaces globais (blocos). Caso contrário, deve ser precedido por “NB ::.”A região dos namespaces combinados para NA e global continua abaixo do fn () definição e no a Principal() função até o final do arquivo.
A extensão do namespace NB começa em “int minhaVar2 = NB :: func ();" no fn () bloco e termina no final do fn () bloco de definição.
Observação: Os namespaces cujas regiões são unidas não devem ter o mesmo nome de variável em seus diferentes blocos de namespace, pois isso ainda causaria conflito.
Regiões de namespace
Um namespace é um escopo. Além do namespace global (escopo global), qualquer namespace deve ser declarado em um bloco. Esse bloco é a primeira parte das regiões possivelmente distribuídas do namespace. Com a diretiva using, o namespace pode ser estendido como regiões em outros escopos.
Entidades declaradas em um corpo de namespace são consideradas membros do namespace, e nomes introduzidos por essas declarações na região declarativa do namespace são considerados nomes de membros do namespace.
Namespaces aninhados
O programa a seguir mostra namespaces aninhados:
#incluirusando namespace std;
namespace A
int i = 1;
namespace B
int i = 2;
namespace C
int i = 3;
int main ()
cout << A::i << " << A::B::i << " << A::B::C::i << '\n';
return 0;
O resultado é:
1 2 3Observe que os três valores foram acessados usando o operador de resolução de escopo.
Namespace padrão
C ++ tem uma biblioteca chamada biblioteca padrão. Os nomes de objetos, funções e outras entidades nesta biblioteca são de um namespace chamado de namespace padrão, escrito como std. A biblioteca padrão contém sub-bibliotecas, e uma dessas sub-bibliotecas é iostream. O iostream biblioteca contém o objeto cout, que é usado para enviar resultados para o console (terminal).
O nome cout deve estar no std namespace. Usar iostream com o seu std namespace, o programa deve ser o seguinte:
#incluirusando namespace std;
Observe o uso do usando diretiva e std. O termo "#incluir
Conclusão
Um namespace é um escopo. A descrição do namespace (definição) contém declarações básicas e / ou definições de objetos C ++, funções e outras entidades. Fora da definição de namespace, o nome pode ser acessado com a sintaxe, “namespaceName :: name.”Além do namespace global (escopo global), qualquer namespace deve ser declarado em um bloco. Esse bloco é a primeira parte das regiões possivelmente distribuídas do namespace. Com o usando diretiva, o namespace pode ser estendido como regiões em outros escopos. Os namespaces cujas regiões são unidas não devem ter o mesmo nome de variável em seus diferentes blocos de namespace, pois isso ainda causaria conflito de nomes.
Chrys
