¿Usa `using` en C ++ o lo evita?

Descontando semánticas sutilmente diferentes debido a ADL, ¿cómo debería usarlo en general usingy por qué? ¿Depende de la situación (por ejemplo, el encabezado que será #included frente al archivo fuente que no)?

Además, ¿debería preferir ::std::o std::?

1. Nivel de espacio de nombres using namespace:

   using namespace std;
   
   pair<string::const_iterator, string::const_iterator>
   f(const string &s) {
       return make_pair(s.begin(), s.end());
   }

2. Siendo completamente 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. Declaraciones de uso de nivel de espacio de nombres:

   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. Declaraciones de uso de funciones locales:

   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. Función 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 más?

_{Esto supone que es anterior a C ++ 14 y, por lo tanto, no se utiliza la deducción de tipo de retorno auto.}

Evite usar usingen encabezados, porque eso rompe el propósito de los espacios de nombres.

Está bien usarlo en archivos fuente, pero aún así lo evitaría en algunos casos (por ejemplo using std).

Sin embargo, si tienes espacios de nombres anidados, está bien:

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

Al poner una declaración de uso en un archivo de origen, POR FAVOR, solo ingrese las cosas que necesita. Por ejemplo:

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

El problema aquí es que si lo haces

using namespace std;

introduces TODAS LAS COSAS desde el estándar en el espacio de nombres global. Lo que conduce a mensajes de error muy interesantes cuando accidentalmente usa un nombre en su código que coincide con uno que no conocía en std. Si solo obtiene las cosas que desea, entonces no tendrá ese problema (o, más precisamente, el próximo programador que trabaje en su código no tendrá ese problema).

Como indica VJovic, no lo use usingen un archivo de encabezado. usingen un archivo de encabezado afecta a la unidad de compilación actual (el archivo .cpp) en formas que el archivo de origen puede no estar esperando.

using namespacetambién se debe evitar en un archivo fuente. Esto trae cada símbolo al mismo alcance que el archivo fuente. Es más claro para sus lectores lo que está haciendo si usa símbolos específicos del espacio de nombres.

Escribir usingen encabezados es la mejor manera de crear todo tipo de errores desagradables e imposibles de depurar . No no hacer esto.

Escribir using namespace XYZen el archivo fuente es un poco mejor, pero aún puede causarle innumerables dolores de cabeza. La forma segura es especificar explícitamente lo que está utilizando, por ejemplo using Foo::Bar.

Digamos que tienes Bar.cpp con lo siguiente:

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

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

La función funcionó bien, hasta que un día, aparentemente sin ningún cambio de código en las clases relevantes, su comportamiento cambió: de repente, currentIndexsiempre parece estar desactivado por uno . Al explorar los cambios recientes, no descubre cambios, ni siquiera remotamente relacionados con el código.

Eventualmente descubres la causa:
tú (indirectamente) incluyes en Foo.halguna parte. En los archivos para el espacio de nombres de Foo se agregó una nueva función:

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

Que es una coincidencia inequívocamente mejor increment(int)que su función increment(double), por lo que ahora Foo::increment()se llama a la función en su Bar::someFunction()lugar. Whoops

(Y si tuviera que escribir usingen Encabezados que using namespace Foomuy bien podría estar en cualquier lugar de su árbol de inclusión ...)

Entonces ... No escriba ninguno usingen Encabezados, y también tenga cuidado de escribir using namespaceen archivos fuente.