using declarations c++

¿Qué me obliga a declarar "utilizando namespace std;"?

Question

Esta pregunta puede ser un duplicado, pero no puedo encontrar una buena respuesta. Corto y sencillo, lo que me obliga a declarar.

using namespace std;

en los programas de C ++?

Answer 1

Dado que el estándar de C ++ ha sido aceptado, prácticamente toda la biblioteca estándar está dentro del espacio de nombres estándar. Entonces, si no desea calificar todas las llamadas de biblioteca estándar con std:: , debe agregar la directiva using.

Sin embargo,

using namespace std;

se considera una mala práctica porque prácticamente está importando todo el espacio de nombres estándar, lo que abre muchas posibilidades para conflictos de nombres. Es mejor importar solo lo que realmente está usando en su código, como

using std::string;

Answer 2

Definitivamente no debes decir:

using namespace std;

en sus encabezados de C ++, porque eso supera todo el sentido de usar espacios de nombres (ya que eso constituiría "contaminación de espacios de nombres"). Algunos recursos útiles sobre este tema son los siguientes:

1) hilo de en la convención estándar para usar "std"

2) un artículo de Herb Sutter sobre la migración a espacios de nombres

3) Preguntas frecuentes 27.5 de C ++ Faq lite de Marshall Cline.

Answer 3

En primer lugar, esto no es necesario en C - C no tiene espacios de nombres. En C ++, cualquier cosa en el std nombres estándar que incluye la mayoría de la biblioteca estándar. Si no haces esto, debes acceder a los miembros del espacio de nombres explícitamente de esta manera:

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

Answer 4

En primer lugar, la directiva de using nunca se requiere en C, ya que C no admite espacios de nombres.

La directiva de using nunca es realmente necesaria en C ++, ya que se puede acceder directamente a cualquiera de los elementos que se encuentran en el espacio de nombres prefijándolos con std:: lugar. Así por ejemplo:

using namespace std;
string myString;

es equivalente a:

std::string myString;

Independientemente de si elige usarlo o no, es una cuestión de preferencia, pero exponer todo el std nombres std para guardar algunas pulsaciones de teclado generalmente se considera una forma incorrecta. Un método alternativo que solo expone elementos particulares en el espacio de nombres es el siguiente:

using std::string;
string myString;

Esto le permite exponer solo los elementos en el std nombres std que necesita particularmente, sin el riesgo de exponer involuntariamente algo que no tenía la intención de exponer.

Answer 5

La capacidad de referirse a miembros en el std nombres std sin la necesidad de referirse explícitamente a std::member . Por ejemplo:

#include <iostream>
using namespace std;

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

contra

#include <iostream>

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

Answer 6

Los espacios de nombres son una forma de envolver el código para evitar confusiones y que los nombres no entren en conflicto. Por ejemplo:

Archivo common1.h:

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

Archivo 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.
}

Por lo tanto, cuando escribe using namespace std todo lo que está haciendo es decirle al compilador que, en caso de duda, debe buscar en el espacio de nombres std funciones, etc., para las que no puede encontrar definiciones. Esto se usa comúnmente en el código de ejemplo (y producción) simplemente porque hace que escribir funciones comunes, etc. como cout es más rápido que tener que calificar completamente cada una de ellas como std::cout .

Answer 7

Nada lo hace, es una abreviatura para evitar el prefijo de todo en ese espacio de nombres con std ::

Answer 8

No es necesario que haga nada, a menos que sea implementador de la biblioteca estándar de C ++ y desee evitar la duplicación de código al declarar los archivos de encabezado en estilo "nuevo" y "viejo":

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

.

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

Bueno, por supuesto, el ejemplo es un tanto artificial (también podría usar plain <stdio.h> y ponerlo todo en std en <cstdio> ), pero Bjarne Stroustrup muestra este ejemplo en su lenguaje de programación C ++ .

Answer 9

Nunca tienes que declarar usando namespace std; su uso es una mala práctica y debe usar std :: si no desea escribir std :: siempre podría hacer algo como esto en algunos casos:

using std::cout;

Al usar std :: también puede decir qué parte de su programa usa la biblioteca estándar y cuál no. Lo que es aún más importante es que puede haber conflictos con otras funciones que se incluyen.

Rgds Layne

Answer 10

Se usa cuando estás usando algo que se declara dentro de un espacio de nombres. La biblioteca estándar de C ++ se declara dentro del espacio de nombres estándar. Por lo tanto tienes que hacer

using namespace std;

a menos que desee especificar el espacio de nombres al llamar a funciones dentro de otro espacio de nombres, así:

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

Puede leer más sobre esto en http://www.cplusplus.com/doc/tutorial/namespaces/ .

Answer 11

Técnicamente, es posible que se le solicite usar (para espacios de nombres completos o nombres individuales) para poder usar la búsqueda dependiente de argumentos.

Considere las dos funciones siguientes que usan 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 siempre llama a std::swap , aunque preferiríamos usar zzz::swap para los objetos zzz::X

smart_swap hace que std::swap visible como una opción alternativa (por ejemplo, cuando se llama con ints), pero como no califica completamente el nombre, zzz::swap se usará a través de ADL para zzz::X

Subjetivamente, lo que me obliga a usar using namespace std; Está escribiendo código que utiliza todo tipo de objetos de función estándar, 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)
);

OMI, en código como este std:: solo hace ruido de línea.

No encontraría using namespace std; un crimen atroz en tales casos, si se usa en el archivo de implementación (pero puede restringirse incluso al alcance de la función, como en el ejemplo de intercambio).

Definitivamente no ponga la instrucción using en los archivos de encabezado. La razón es que esto contamina el espacio de nombres para otros encabezados, que podrían incluirse después del ofensivo, lo que podría generar errores en otros encabezados que podrían no estar bajo su control. (También agrega el factor sorpresa: es posible que las personas que incluyen el archivo no esperen que se vean todos los tipos de nombres).

Answer 12

Todos los archivos en la biblioteca estándar de C ++ declaran todas sus entidades dentro del espacio de nombres estándar.
Por ejemplo: para usar cin,cout definido en iostream.

Alternativas:

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

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