Você prefere espaço para nome explícito ou 'usando' em C ++?

StackOverflow https://stackoverflow.com/questions/214927

  •  03-07-2019
  •  | 
  •  

Pergunta

Ao usar namespaces de C ++, você prefere nomeá -los explicitamente, assim:

std::cout << "Hello, world!\n";

Ou você prefere using namespace:

using namespace std;
cout << "Hello, world!\n";

E se você preferir o último, você declara seu uso no escopo de arquivo ou função?

Pessoalmente, prefiro nomear explicitamente - é mais digitação, mas ao usar uma mistura de namespaces (por exemplo std e boost) Acho mais legível.

Foi útil?

Solução

Eu sempre uso using namespace para std & boost. Tudo o mais que tendem a usar um espaço para nome explícito, a menos que seja usado tanto que irritaria o código.

Nos cabeçalhos, eu nunca uso using namespace Para evitar poluir o espaço de nome global da fonte #including.

Outras dicas

A digitação extra não é o problema aqui. O problema com nomes explicitamente qualificados é a desordem visual. Vamos ser sinceros, a sintaxe C ++ é desarrumada. Não há necessidade de piorar isso, tornando desnecessariamente os nomes por mais tempo e borrifar o código generosamente com ::s.

Estou com Jeff Atwood: O melhor código não é nenhum código. Isto é tão verdade.

As importações de namespace são uma ótima maneira de reduzir a desordem sem desvantagem: desde que o escopo de namespaces aberto seja reduzido a uma única unidade de compilação1, conflitos de nome, devem aparecer, podem ser resolvidos facilmente.

Por que os nomes explícitos deveriam (em geral) ser mais legíveis sempre foi um mistério para mim. Os leitores geralmente devem conhecer o código bom o suficiente para poder deduzir a semântica. Se não estiverem, o código precisa ser consertado de qualquer maneira.

1) Corolário: Não using Em cabeçalhos!

Eu uso sempre explícitos. Escrever a DST não me machuca e eu vejo claramente de onde é. É útil quando você tem algum projeto herdado para cuidar de suas próprias "Strings", "Vettores" etc. para manter. Quanto mais informações o código carrega, melhor.

Minha regra geral é sempre explicitamente usar o espaço para nome dos cabeçalhos e geralmente usar o uso no código. A razão para o primeiro é deixá -lo explicitamente claro em todas as partes da definição do que está sendo usado, e o motivo do último é que facilita o uso de substituições de outro espaço para nome, se isso for necessário. ou seja, se quisermos começar a usar o foo :: string em vez de std :: string, precisamos apenas atualizar o cabeçalho e a instrução usando em vez de substituir todas as instâncias do std :: string pelo foo :: string no código.

Obviamente, isso é menos útil para classes que residem no espaço de nome de DST ::, pois mesmo se você substituir uma classe, é provável que você ainda use outras pessoas na DST e possa encontrar problemas de ambiguidade, mas esse foi apenas um exemplo.

using e using namespace são muito úteis para tornar o código mais legível - remova a desordem.

Mas, em qualquer caso em que torna mais difícil descobrir de onde vem um símbolo, recuso a importação de seu espaço de nome inteiro.

Eu tento limitar o escopo dos namespaces importados:

void bar() {

   // do stuff without vector

   { using std::vector;
      // do stuff with vector
   }

   // do stuff without vector
}

Para bibliotecas "geralmente conhecidas", como std, Eu ousaria usar using namespace std. Há motivos para acreditar que todos que lêem esse código conhecem esses símbolos.

Como uma sidenote, o using A palavra -chave também é usada para indicar que uma classe derivada também exporta os membros sobrecarregados de sua superclasse.

class A {
  void f( A  );
  void f( bool );
};

class B : public A {
  using A::f; // without this, we get a compilation error in foo()
  void f(bool);
};

void foo() {
  B b;
  b.f( A() ); // here's a compilation error when no `using` is used in B
}

Eu só uso namespaces explícitos quando há alguma ambiguidade. É mais legível, mas a digitação extra é muito tediosa e você deve assumir que outros desenvolvedores têm um nível de base de familiaridade com as bibliotecas padrão.

As únicas outras vezes em que soletamos um espaço para nome são quando estou usando apenas uma ou duas vezes, como adicionar uma declaração rápida de depuração ou se estou usando uma biblioteca não padrão.

Normalmente, declaro o espaço para nome no escopo do arquivo, mas se você estiver misturando namespaces, pode fazer sentido colocar a declaração mais próxima do ponto em que é usado, no escopo da função.

using no escopo da função, ou se a função for muito pequena (geralmente é), apenas o nome de nome explícito

Costumo importar explicitamente os nomes que eu preciso no topo do arquivo .cpp, então ...

usando std :: cout; usando std :: endl;

etc ...

Dessa forma, tenho controle sobre os nomes que uso e é fácil ver de onde eles vêm e o código não está confuso no ponto de uso.

Nos casos raros em que estou usando dois nomes de diferentes namespaces, os qualifico totalmente no ponto de uso.

Eu sempre uso nomes totalmente qualificados nos cabeçalhos e quase nunca uso 'usando o namespace x' em qualquer lugar ...

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top