Descontando semânticas sutilmente diferentes devido a ADL, como devo usar geralmente using
e por quê? É dependente da situação (por exemplo, cabeçalho que será #include
d vs. arquivo de origem que não será)?
Além disso, devo preferir ::std::
ou std::
?
No nível do espaço para nome
using namespace
:using namespace std; pair<string::const_iterator, string::const_iterator> f(const string &s) { return make_pair(s.begin(), s.end()); }
Sendo totalmente explícito:
std::pair<std::string::const_iterator, std::string::const_iterator> f(const std::string &s) { return std::make_pair(s.begin(), s.end()); }
Usando declarações de nível de espaço para nome:
using std::pair; using std::string; pair<string::const_iterator, string::const_iterator> f(const string &s) { return make_pair(s.begin(), s.end()); }
Função-local usando declarações:
std::pair<std::string::const_iterator, std::string::const_iterator> f(const std::string &s) { using std::make_pair; return make_pair(s.begin(), s.end()); }
Função local
using namespace
:std::pair<std::string::const_iterator, std::string::const_iterator> f(const std::string &s) { using namespace std; return make_pair(s.begin(), s.end()); }
Algo mais?
Isso pressupõe pré-C ++ 14 e, portanto, nenhuma dedução de tipo de retorno usando auto
.
::std::
vs.std::
embora.std
sem segundo embora. Alguém que define um espaço para nome std está solicitando problemas (e provavelmente buscando tirar vantagem que a maioria das pessoas está usandostd
e não::std
).Respostas:
Evite usar
using
nos cabeçalhos, pois isso quebra o objetivo dos espaços para nome.Não há problema em usá-lo nos arquivos de origem, mas eu ainda o evitaria em alguns casos (por exemplo
using std
).No entanto, se você tiver namespaces aninhados, tudo bem:
fonte
using
palavra - chave sem uma explicação completa do motivo pelo qual os namespaces são usados.using std::cout
e amigos, mas nãocout
é como se já fosse um nome horrivelmente longo.Ao colocar uma instrução using em um arquivo de origem, POR FAVOR, basta inserir o que você precisa. Por exemplo:
A questão aqui é que, se você fizer
você puxa TODA ÚNICA COISA de std no espaço para nome global. O que leva a mensagens de erro muito interessantes quando você acidentalmente usa um nome em seu código que corresponde a um que você desconhecia completamente no std. Se você apenas puxar o que deseja, não terá esse problema (ou, mais precisamente, o próximo programador a trabalhar no seu código não terá esse problema).
fonte
using namespace
apenas no escopo de uma função, evitando o problema.Como VJovic indica, não use
using
em um arquivo de cabeçalho.using
em um arquivo de cabeçalho afeta a unidade de compilação atual (o arquivo .cpp) de maneiras que o arquivo de origem pode não estar esperando.using namespace
também deve ser evitado em um arquivo de origem. Isso coloca todos os símbolos no mesmo escopo que o arquivo de origem. É mais claro para seus leitores o que você está fazendo se usar símbolos específicos no espaço para nome.fonte
using namespace JoystickModule
no início de um arquivo .cpp do queJoystickModule::
anexá-lo a todos os objetos.using
momento, estou trabalhando em uma declaração para meu próprio espaço de nome e todo o resto permanece no espaço de nome.using SomeNameSpace::SomeSymbol
. Isso evita mover todos os símbolos do espaço para nome para o escopo atual.Escrever
using
em cabeçalhos é a melhor maneira de criar todos os tipos de erros desagradáveis e impossíveis de depurar . Você não fazer isso.Escrever
using namespace XYZ
no arquivo de origem é um pouco melhor, mas ainda pode causar inúmeras dores de cabeça. A maneira segura é especificar explicitamente o que você está usando, por exemplousing Foo::Bar
.Digamos que você tenha o Bar.cpp com o seguinte:
A função funcionou bem, até que um dia - aparentemente sem nenhuma alteração de código nas classes relevantes - seu comportamento mudou: de repente,
currentIndex
sempre parece estar desligado um . Ao pesquisar nas alterações recentes, você descobre que não há alterações nem remotamente relacionadas ao código.Eventualmente, você descobre a causa:
você (indiretamente) inclui em
Foo.h
algum lugar. Nos arquivos do namespace Foo, uma nova função foi adicionada:Qual é uma correspondência inequivocamente melhor do
increment(int)
que a sua funçãoincrement(double)
- então agora aFoo::increment()
função é chamada porBar::someFunction()
. Ops.(E se você escrever
using
nos cabeçalhos,using namespace Foo
pode muito bem estar em qualquer lugar da sua árvore de inclusão ...)Então ... Não escreva nenhum
using
em Cabeçalhos e também tenha cuidado ao escreverusing namespace
em arquivos de origem.fonte