Considere as duas instruções escalares a seguir em um escopo global, no seguinte programa:
#incluir
usando namespace std;
intvarId= 5;
flutuadorvarId= 2,3;
inta Principal()
{
Retorna 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 elas 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:
#incluir
usando namespace std;
namespace NA
{
intvarId= 5;
}
namespace NB
{
flutuadorvarId= 2,3;
}
inta Principal()
{
custo<<N / D::varId << ' n';
custo<<NB::varId << ' n';
Retorna 0;
}
O resultado é o seguinte:
5
2,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 página da web linuxhint.com e pressione Enter. Isso o levará ao artigo que este autor escreveu.
Conteúdo do Artigo
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;
intident= 55;
flutuadorident= 12,17;
inta Principal()
{
Retorna 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 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
{
intvarInt= 6;
flutuadorflt;
}
namespace NB
{
intvarInt= 7;
flutuadorflt;
}
inta Principal()
{
custo<<N / D::varInt << ' n';
custo<<NB::varInt << ' n';
N / D::flt = 2,5;
NB::flt = 4,8;
custo<<N / D::flt << ' n';
custo<<NB::flt << ' n';
Retorna 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 nome após declarar o namespace, você pode usar o usando diretiva. A sintaxe para usar o usando diretiva é a seguinte:
usando namespace Namespace_name;o usando diretiva não é uma diretiva de pré-processador, portanto, termina com um ponto e vírgula (;).
O programa a seguir ilustra o uso do usando diretiva e mais:
#incluirusando namespace std;
namespace NB
{
intvarInt= 7;
intfunção()
{
RetornavarInt;
}
}
intfn()
{
usando namespace NB;
intmyVar2=função();
// outros objetos e funções do NB seguem.
RetornamyVar2;
}
intmyVar3=NB::função();
inta Principal()
{
custo<<fn() << '' <<myVar3<< ' n';
Retorna 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 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 o 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:
intmyVar3=NB::função();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 da função e os dois namespaces anteriores continuam até o final do arquivo (leia o código).
#incluirusando namespace std;
namespace NA
{
intvarInt= 6;
intfunção()
{
RetornavarInt;
}
}
namespace NB
{
intvarInt= 7;
intfunção()
{
RetornavarInt;
}
}
usando namespace NA;
intmyVar0=varInt;
// outros objetos e funções de :: e NB seguem.
intfn()
{
intmyVar1=varInt;
usando namespace NB;
intmyVar2=NB::função();
// outros objetos e funções do NB seguem, até o final deste escopo.
RetornamyVar1+myVar2;
}
// Seguem apenas objetos e funções de :: e NB.
intmyVar3=NB::função();
inta Principal()
{
custo<<myVar0<< '' <<fn() << '' <<myVar3<< ' n';
Retorna 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 se 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 () o escopo da função é do namespace de 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 :: , somente se não ocorrer 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 a partir de 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 os nomes introduzidos por essas declarações na região declarativa do namespace são chamados de nomes de membros do namespace.
Namespaces aninhados
O programa a seguir mostra namespaces aninhados:
#incluirusando namespace std;
namespace A
{
inteu= 1;
namespace B
{
inteu= 2;
namespace C
{
inteu= 3;
}
}
}
inta Principal()
{
custo<<PARA::eu << '' <<PARA::B::eu << '' <<PARA::B::C::eu << ' n';
Retorna 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 horas . A biblioteca padrão contém sub-bibliotecas, e uma dessas sub-bibliotecas é iostream . o iostream biblioteca contém o objeto custo , que é usado para enviar resultados ao console (terminal).
O nome custo deve estar no horas namespace. Usar iostream com o seu horas namespace, o programa deve ser o seguinte:
#incluirusando namespace std;
Observe o uso do usando diretiva e horas . O termo #incluir é uma diretiva do pré-processador e não termina com um ponto-e-vírgula. Inclui o arquivo iostream na posição de sua diretiva.
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 , 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