namespaces c
Uma visão geral completa dos namespaces em C ++ com exemplos simples.
Até agora, em nossos tutoriais anteriores, vimos tudo sobre variáveis, declarações, funções e outras entidades usadas em C ++.
Ao desenvolver aplicativos em C ++, algumas situações peculiares podem surgir, como os mesmos nomes de variáveis sendo usados duas vezes ou funções definidas com os mesmos protótipos etc. Quando esses cenários surgem, torna-se difícil para o compilador deduzir a variável correta ou chamada de função que está causando ambiguidade .
=> Confira o guia de treinamento perfeito C ++ aqui.
O que você aprenderá:
- O que é namespace?
- Definindo um namespace
- Acessando membros do namespace
- A Diretiva de Uso
- Namespaces aninhados
- Namespaces externos
- Namespaces contíguos
- Conclusão
- Leitura recomendada
O que é namespace?
Vamos ver o exemplo abaixo:
#include #include int main() { int var; double var; std::cin>>var; }
Resultado:
Na função ‘int main ()’:
8:10: erro: declaração conflitante ‘double var’
7: 7: nota: declaração anterior como ‘int var’
como abrir arquivos apk no telefone Android
No exemplo acima, definimos duas variáveis com tipos diferentes, mas o mesmo identificador. Portanto, quando compilamos este exemplo, obtemos um erro conforme mostrado na janela Saída. Essas declarações conflitantes surgem porque o mesmo identificador é usado para nomear duas variáveis.
Esse tipo de situação gera ambigüidade nas aplicações.
C ++ apresenta algo chamado “ namespaces ”Para resolver este problema. O namespace em C ++ é como um pacote ou região ou biblioteca que é usada para diferenciar entre a variável ou funções com os mesmos identificadores.
Um namespace pode conter variáveis, funções, classes ou outros objetos e até mesmo outro namespace. Cada membro do namespace pode ser referido usando um namespace. Isso ajuda o compilador a diferenciar entre várias entidades de programação, mesmo que tenham os mesmos nomes.
Definindo um namespace
Em C ++, podemos definir um namespace usando a palavra-chave “ namespace ' como mostrado abaixo:
namespace namespace_name{ namespace_declarations; }
Portanto, se precisarmos definir um namespace chamado “test_space”, podemos fazer como a seguir:
namespace test_space{ int var=10; }
A declaração acima define um namespace denominado “test_space”. Como mostrado, ele possui uma variável inteira var como seu membro.
Acessando membros do namespace
Agora, definimos nosso próprio namespace “test_space” e como acessamos o conteúdo desse namespace?
No programa C ++, podemos acessar os membros do namespace usando a sintaxe:
namespace_name::namespace_member;
Assim, a variável inteira var declarada no namespace “test_space” acima pode ser acessada da seguinte forma:
test_space::var;
Veja o exemplo completo abaixo para demonstrar os namespaces e seu uso.
#include #include namespace test_space{ int var = 10; } int main() { double var = 20.53; std::cout<<'local var = '< Resultado:
var local = 20,53
test_space :: var = 10
Demonstramos tudo sobre como criar e acessar namespace no exemplo de programação acima. Como vemos, “test_space” é um namespace que definimos. Ele tem uma única variável inteira var definida nele. Então, na função principal, temos outra variável dupla var que é inicializada.
Posteriormente, exibimos essas duas variáveis. Observe que embora a variável double local dentro do main possa ser impressa diretamente, para imprimir a variável do namespace, temos que precedê-la com o nome do namespace.
Isso também resolveu o problema de confrontos entre as variáveis por causa dos mesmos nomes que discutimos anteriormente.
A Diretiva de Uso
Em nosso tópico anterior, vimos que podemos acessar membros do namespace usando namespace_name :: namespace_member.
Se não quisermos especificar um nome de namespace em todos os lugares do programa, podemos usar o “ usando ”Para incluir o namespace no programa.
sites de teste de produto que enviam coisas
Isto se faz do seguinte modo:
#include #include namespace test_space{ int var = 10; } using namespace std; using namespace test_space; int main() { double var = 20.53; cout<<'local var = '< Resultado:
var local = 20,53
test_space :: var = 10
No exemplo acima, usamos duas instruções após definir o namespace “test_space”.
Esses são:
using namespace std; using namespace test_space;
A primeira instrução usa a declaração para acessar o namespace “std”, que é um namespace padrão predefinido na biblioteca C ++. Este namespace é usado para acessar várias funções como cin, cout, etc.
A segunda instrução é usada para incluir o namespace “test_space” no programa.
Na função principal, podemos ver que funções como cout e variável var não precisam ser precedidas por um nome de namespace. Podemos nos referir diretamente a eles. Mas como var tem um conflito de nome com uma variável local na função principal, nos referimos a ela usando o operador de resolução de escopo (: :), pois os namespaces sempre têm um escopo global.
Namespaces aninhados
C ++ também permite ter namespaces aninhados, ou seja, um namespace definido dentro de outro namespace.
A sintaxe geral de namespaces aninhados é a seguinte:
namespace ns1{ ns1_code; namespace ns2{ ns2_code; } }
Se precisarmos acessar ns2_code, podemos acessá-lo da seguinte maneira:
ns1::ns2::ns2_code;
Vamos demonstrar os namespaces aninhados usando o exemplo de código a seguir.
#include #include namespace first{ int var = 10; namespace second{ int secVar = 20; } } using namespace std; using namespace first; using namespace first::second; int main() { double var = 20.53; cout<<'local var = '< Resultado:
var local = 20,53
primeiro :: var = 10
segundo :: var = 20
Usamos namespaces aninhados no programa acima. Observe a maneira como a diretiva using é usada para acessar os namespaces. Não é suficiente referir-se apenas ao namespace mais interno uma vez. Se precisarmos de um código do namespace mais externo, precisamos consultá-lo separadamente.
Podemos usar outro nome para namespaces conhecido como “alias”. Isso é especialmente útil ao usar namespaces aninhados e o grau de aninhamento é alto.
Podemos demonstrar o alias de um namespace modificando o exemplo acima.
#include #include namespace first{ int var = 10; namespace second{ int secVar = 20; } } using namespace std; using namespace first; namespace nested = first::second; int main() { double var = 20.53; cout<<'local var = '< Resultado:
var local = 20,53
primeiro :: var = 10
segundo :: var = 20
Observe o alias aninhado que é definido para o namespace first :: second. Depois que um alias é definido, podemos nos referir ao namespace usando um nome de alias.
Namespaces externos
Às vezes, quando temos muitos namespaces para usar em nosso aplicativo, podemos querer colocar todos os namespaces em um arquivo separado. Isso pode ser feito facilmente. Quando os namespaces estão em um arquivo separado, apenas incluímos esse arquivo em nosso programa e, em seguida, usamos diretamente os namespaces e seu conteúdo em nosso programa.
Por exemplo, se tivermos um arquivo denominado ns.h que contém o seguinte namespace.
implementando uma pilha c ++
//ns.h namespace first{ int var = 25; }
Agora, em nosso programa, podemos usar o namespace “primeiro” da seguinte maneira:
#include #include “ns.h” using namespace std; int main() { cout<Assim, uma vez que incluímos o arquivo contendo namespaces em nosso programa, podemos usar os namespaces como se fossem declarados globalmente no mesmo programa.
Namespaces contíguos
C ++ também nos permite definir algo chamado de namespaces contíguos. Namespaces contíguos são os namespaces definidos mais de uma vez por terem o mesmo nome. Na realidade, esses não são namespaces separados, mas as extensões do mesmo namespace.
Os namespaces contíguos são evidentes no exemplo abaixo.
#include #include . namespace first{ int var = 10; } namespace first{ namespace second{ int secVar = 20; } } using namespace std; using namespace first; namespace nested = first::second; int main() { double var = 20.53; cout<<'local var = '< Resultado:
var local = 20,53
primeiro :: var = 10
segundo :: var = 20
Observe no exemplo acima que definimos o mesmo namespace duas vezes. Na primeira definição, temos uma variável chamada var. Enquanto na segunda declaração temos outro namespace definido.
Na função principal, acessamos os membros do namespace externo e interno e observamos que os membros são facilmente acessados.
Este é o exemplo de namespaces contíguos, às vezes também conhecidos como “namespaces descontínuos”. Suas definições parecem separadas, mas, na realidade, são namespaces contínuos.
Conclusão
Com isso, chegamos ao final deste tutorial sobre namespaces em C ++. Namespaces de uma maneira que nos permite separar nosso código em diferentes espaços ou regiões, para que tenhamos clareza na leitura e também no uso de seus membros.
Em nossos tutoriais subsequentes, aprenderemos mais sobre os vários tópicos básicos de C ++ como tratamento de exceções, entrada / saída de arquivo, etc.
=> Verifique aqui para ver os tutoriais de treinamento A-Z de C ++ aqui.
Leitura recomendada
- Best FREE C # Tutorial Series: The Ultimate C # Guide for Beginners
- Teste de carga com tutoriais HP LoadRunner
- Funções de biblioteca em C ++
- Mais de 70 MELHORES tutoriais em C ++ para aprender programação C ++ GRATUITAMENTE
- Programação orientada a objetos em C ++
- Listas de inicializadores em C ++
- Iteradores em STL
- Encapsulamento em C ++