Quando importar nomes para o espaço para nome global? (usando x :: y, de x import y etc.)

Venho programando em várias linguagens há cerca de 10 anos. E ainda não descobri quando é uma boa ideia importar algo para o espaço de nomes global ( using x::yem C ++, from x import yem Python etc.), por isso quase nunca faço isso.

Quase sempre parece uma má idéia para mim, mesmo que apenas porque limita o conjunto de nomes de variáveis ​​que posso usar. Por exemplo: Onde eu devo usar using namespace std;ou using std::string;em C ++, não posso mais usar stringcomo nome de variável, o que ocasionalmente faço (por exemplo, para funções de utilitário de string).

Mas estou me perguntando: há algumas situações em que a importação de um nome para o espaço de nome global realmente faz sentido? Alguma regra de ouro?

Em C ++, geralmente é desaprovado - especialmente using namespace std. Esse stdespaço para nome tem muitos nomes, muitos dos quais são algoritmos muito genéricos, e você pode obter algumas surpresas extremamente desagradáveis ​​quando using namespace std. Algo como using std::cout;não é tão ruim. Mas nunca, nunca, usingnada no espaço de nomes global em um arquivo de cabeçalho. Isso é uma ofensa do esquadrão de tiro.

Você deve fazer isso quando simplificar seu código. Você não deve fazer isso quando isso causa conflitos de nomenclatura ou quando pode ser trazido posteriormente para escopos nos quais causa conflitos de nomenclatura, como um arquivo de cabeçalho.

Algumas pessoas pensam que isso deve ser raro. Eu acho que (fora dos arquivos de cabeçalho) não usá-lo deve ser raro, porque o prefixo do espaço para nome geralmente não adiciona nenhuma informação útil, como usar o nome completo de alguém toda vez que você os endereça.

Deixe-me colocar deste jeito. Quando você vê stringcomo um nome de classe, você pensa automaticamente std::stringou mycustom::string? É como o velho ditado. Quando você ouve o som de cascos, pensa em cavalos, não em zebras. Em outras palavras, using namespace stdquase sempre não é grande coisa. using namespace mycustomda mesma forma, geralmente não é um grande problema, a menos que contenha um conflito std; nesse caso, seu namespace personalizado é aquele para o qual você deseja sempre exigir o prefixo.

Trabalhando em Python, uso x import y (como z) constantemente, para ter nomes claros e concisos para fazer referência às importações.

As importações são inestimáveis ​​em uma base de código com uma hierarquia profunda de namespace. Isso ocorre especialmente quando o padrão de estilo da base de código é o PEP 8 , que limita o comprimento da linha a menos de 80 caracteres.

Por exemplo, considere:

import foo

foo.bar.baz.baf.perform_task(foo.bar.baz.quux.SOME_CONSTANT, foo.bar.alice.bob.preferred_hash_function, '42', foo.bar.magic_numbers.MY_SALT)

O que poderia ser escrito:

from foo.bar import baf
from foo.bar.alice import bob
from foo.bar.baz.quux import SOME_CONSTANT
from foo.bar.magic_numbers import MY_SALT

baf.perform_task(SOME_CONSTANT, bob.preferred_hash_function, '42', MY_SALT)

Como os identificadores Python fazem distinção entre maiúsculas e minúsculas e tamanho ilimitado , não ficaremos sem nomes, independentemente de quantos importamos.

Se queremos usar o mesmo nome em nosso módulo como um dos módulos que desejamos importar, podemos usar um alias para a importação:

from foo.bar.alice import bob as carol

def bob(x, y):
    print "running bob function"
    return carol(x, y, 42)

Cabe ao programador quando usá-lo. IMHO é melhor não usá-los, especialmente em arquivos de cabeçalho. Mas há vários casos em que eu uso

• Quando quero introduzir algo em outro espaço para nome, por exemplo

  namespace cg
  {
    namespace details
    {
      //lots of stuff
      void some_cool_foo()
      {
        //uses a lot stuff from details, here because I don't want prefix everything with details::
      }
    }
    using details::some_cool_foo;
  }

• Para habilitar o ADL para alguns algoritmos de outro espaço para nome

  namespace n1
  {
  //some general foo
  }
  namespace n2
  {
    using n1::foo;
  //some struct
  }
  namespace n3
  {
    using n1::foo;
  //some struct
  }

Se não quiser escrever nomes longos de espaços para nome em .cpp, sempre posso criar um alias

namespace bl = boost::lambda;
namespace fs = boost::filesystem;