O que me obriga a declarar “usando namespace std;”?

Question

Esta questão pode ser um duplicado, mas não consigo encontrar uma resposta boa. Curto e simples, o que me obriga a declarar

using namespace std;

em programas em C ++?

Answer 1

Uma vez que o padrão C ++ foi aceite, praticamente toda a biblioteca padrão está dentro do namespace std. Então, se você não quer se qualificar todas as chamadas da biblioteca padrão com std::, você precisa adicionar utilizando a directiva.

No entanto,

using namespace std;

é considerado uma má prática porque você está praticamente importar todo o namespace padrão, abrindo assim um monte de possibilidades de conflitos de nome. É melhor para importar apenas as coisas que você está realmente usando no seu código, como

using std::string;

Answer 2

Nada faz, é um atalho para evitar prefixo tudo em que namespace com std ::

Answer 3

Tecnicamente, você pode ser obrigado a usar usando (para namespaces inteiros ou nomes individuais) para ser capaz de usar Argumento Dependente Lookup.

Considere os dois seguintes funções que usam swap().

#include <iostream>
#include <algorithm>

namespace zzz
{
    struct X {};


void swap(zzz::X&, zzz::X&) 
{
    std::cout << "Swapping X\n";
}
}

template <class T>
void dumb_swap(T& a, T& b)
{
    std::cout << "dumb_swap\n";
    std::swap(a, b);
}

template <class T>
void smart_swap(T& a, T& b)
{
    std::cout << "smart_swap\n";
    using std::swap;
    swap(a, b);
}

int main()
{
    zzz::X a, b;
    dumb_swap(a, b);
    smart_swap(a, b);

    int i, j;
    dumb_swap(i, j);
    smart_swap(i, j);
}

dumb_swap sempre chama std::swap - embora nós preferimos usar zzz::swap para objetos zzz::X.

smart_swap marcas std::swap visível como uma escolha queda-back (por exemplo, quando chamado com ints), mas desde que não se qualificar totalmente o nome, zzz::swap será utilizado através de ADL para zzz::X.

---

Subjetivamente, o que me obriga a usar using namespace std; é escrever código que usa todos os tipos de objetos de função padrão, etc.

//copy numbers larger than 1 from stdin to stdout
remove_copy_if(
    std::istream_iterator<int>(std::cin), std::istream_iterator<int>(),
    std::ostream_iterator<int>(std::cout, "\n"),
    std::bind2nd(std::less_equal<int>(), 0)
);

IMO, em código como este std:: só faz para o ruído de linha.

Eu não iria encontrar using namespace std; um crime hediondo, em tais casos, se for usado no arquivo de implementação (mas pode ser ainda restrito ao espaço função, como no exemplo swap).

Definitivamente não colocar a instrução using nos arquivos de cabeçalho. A razão é que este polui o namespace para outros cabeçalhos, o que pode ser incluído após a ofensiva, levando potencialmente a erros em outros cabeçalhos que pode não ser sob seu controle. (Ele também adiciona o fator surpresa:. Pessoas, incluindo o arquivo pode não estar esperando todos os tipos de nomes para ser visível)

Answer 4

A capacidade para se referir a membros no namespace std sem a necessidade de se referir a std::member explicitamente. Por exemplo:

#include <iostream>
using namespace std;

...
cout << "Hi" << endl;

vs.

#include <iostream>

...
std::cout << "Hi" << std::endl;

Answer 5

Você definitivamente não deve dizer:

using namespace std;

em seus cabeçalhos C ++, porque que bate o ponto inteiro de usar namespaces (fazendo isso constituiria "a poluição do namespace"). Alguns recursos úteis sobre este tema são os seguintes:

1) Rosca stackoverflow sobre convenção para utilização do “std”

2) um artigo por Herb Sutter sobre migrando para Namespaces

3) FAQ 27,5 de ++ Faq de Marshall Cline C Lite.

Answer 6

Em primeiro lugar, este não é necessária em C - C não tem namespaces. Em C ++, tudo no espaço de nomes std que inclui a maior parte da biblioteca padrão. Se você não fizer isso, você tem que acessar os membros do namespace explicitamente assim:

std::cout << "I am accessing stdout" << std::endl;

Answer 7

Em primeiro lugar, a directiva using nunca é exigido em C desde C não suporta namespaces em tudo.

A directiva using nunca está realmente necessário em C ++ desde qualquer um dos itens encontrados no espaço de nomes pode ser acessada diretamente pelo prefixo-los com std:: vez. Assim, por exemplo:

using namespace std;
string myString;

é equivalente a:

std::string myString;

Se vai ou não optar por usá-lo é uma questão de preferência, mas expondo todo o namespace std para salvar algumas teclas é geralmente considerado uma forma ruim. Um método alternativo que só expõe itens específicos no espaço de nomes é a seguinte:

using std::string;
string myString;

Este permite expor apenas os itens no namespace std que você particularmente precisa, sem o risco de involuntariamente expor algo que você não tinha a intenção de.

Answer 8

Namespaces são uma forma de código de embalagem para evitar confusão e nomes entrem em conflito. Por exemplo:

common1.h arquivo:

namespace intutils
{
    int addNumbers(int a, int b)
    {
        return a + b;
    }
}

arquivo de Uso:

#include "common1.h"    
int main()
{
    int five = 0;
    five = addNumbers(2, 3); // Will fail to compile since the function is in a different namespace.
    five = intutils::addNumbers(2, 3); // Will compile since you have made explicit which namespace the function is contained within.

    using namespace intutils;
    five = addNumbers(2, 3); // Will compile because the previous line tells the compiler that if in doubt it should check the "intutils" namespace.
}

Assim, quando você escreve using namespace std tudo o que você está fazendo é dizer ao compilador que em caso de dúvida, deve olhar no namespace std para funções, etc., que não pode encontrar definições para. Isto é vulgarmente utilizado no exemplo (e produção) de código, simplesmente porque ele torna a digitação funções comuns, etc., como cout é mais rápido do que ter de se qualificar totalmente cada um como std::cout.

Answer 9

Você nunca tem que declarar usando namespace std; usá-lo é é uma prática ruim e você deve usar std :: se você não deseja digitar std :: sempre que você poderia fazer algo parecido com isso em alguns casos:

using std::cout;

Ao usar std :: você pode também dizer qual parte do seu programa usa a biblioteca padrão e que não funciona. Que é ainda mais importante que pode haver conflitos com outras funções que são incluídos.

Rgds Layne

Answer 10

Todos os arquivos na biblioteca C ++ padrão declarar todas as suas entidades dentro do namespace std.
por exemplo: Para uso cin,cout definido no iostream

Alternativas:

using std::cout;
using std::endl;
cout << "Hello" << endl;

std::cout << "Hello" << std::endl;

Answer 11

Nada requer que você faça - a menos que você está implementador da biblioteca C ++ padrão e você quer evitar a duplicação de código ao declarar arquivos de cabeçalho em ambos os "novo" e estilo "velho":

// cstdio
namespace std
{
  // ...
  int printf(const char* ...);
  // ...
}

.

// stdio.h
#include <cstdio>
using namespace std;

Bem, é claro exemplo é um pouco artificial (que poderia igualmente bem usar <stdio.h> simples e colocar tudo em std em <cstdio>), mas noreferrer mostra Bjarne Stroustrup este exemplo na sua A C ++ Linguagem de programação .

Answer 12

É usado sempre que você está usando algo que é declarada dentro de um namespace. biblioteca padrão do C ++ é declarada dentro do namespace std. Portanto, você tem que fazer

using namespace std;

a menos que queira especificar o namespace ao chamar funções dentro de outro namespace, assim:

std::cout << "cout is declared within the namespace std";

Você pode ler mais sobre isso em http://www.cplusplus.com/doc / tutorial / namespaces / .