Use `using` em C ++ ou evite-o?

Descontando semânticas sutilmente diferentes devido a ADL, como devo usar geralmente usinge por quê? É dependente da situação (por exemplo, cabeçalho que será #included vs. arquivo de origem que não será)?

Além disso, devo preferir ::std::ou std::?

1. 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());
   }
   

2. 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());
   }
   

3. 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());
   }
   

4. 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());
   }

5. 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());
   }

6. Algo mais?

_{Isso pressupõe pré-C ++ 14 e, portanto, nenhuma dedução de tipo de retorno usando auto.}

Evite usar usingnos 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:

namespace A {
namespace B {
namespace C {
class s;
} // C
} // B
namespace D{
using B::C::s;
} // D
} // A

Ao colocar uma instrução using em um arquivo de origem, POR FAVOR, basta inserir o que você precisa. Por exemplo:

using std::string;
using std::ostringstream;

A questão aqui é que, se você fizer

using namespace std;

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).

Como VJovic indica, não use usingem um arquivo de cabeçalho. usingem 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 namespacetambé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.

Escrever usingem 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 XYZno 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 exemplo using Foo::Bar.

Digamos que você tenha o Bar.cpp com o seguinte:

//Bar.cpp
using namespace Foo;
namespace
{
    double increment(double v) { return (v + 1); }
}

void Bar::someFunction()
{
    //...
    int currentIndex = 0;
    int nextIndex = increment(currentIndex);
    //...
}

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, currentIndexsempre 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.halgum lugar. Nos arquivos do namespace Foo, uma nova função foi adicionada:

//Foo.h
namespace Foo
{
    //...
    int& increment(int& v) { v += 1; return v; };
    //...
}

Qual é uma correspondência inequivocamente melhor do increment(int)que a sua função increment(double)- então agora a Foo::increment()função é chamada por Bar::someFunction(). Ops.

(E se você escrever usingnos cabeçalhos, using namespace Foopode muito bem estar em qualquer lugar da sua árvore de inclusão ...)

Então ... Não escreva nenhum usingem Cabeçalhos e também tenha cuidado ao escrever using namespaceem arquivos de origem.