c++ - que - Diferencia en el uso del espacio de nombres(std:: vs:: std::)

using declarations c++

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Por qué añadir un espacio de nombres con ::, por ejemplo :: std :: vector 5 respuestas

using ::std::...;

VS

using std::...;

¿Hay alguna diferencia (s)? De ser asi, cuales)?

Yo vi esto:

using ::std::nullptr_t;

lo que me hizo preguntarme.

Answer 1

De: http://en.cppreference.com/w/cpp/language/using_declaration

La declaración de uso introduce a un miembro de otro espacio de nombres en el espacio de nombres actual o en el ámbito de bloque

Por lo tanto, si su alcance actual ya tiene una clase con el mismo nombre, habrá una ambigüedad entre la que introdujo y la que se encuentra en su espacio / bloque de nombre actual.

Una declaración de uso es solo un subconjunto de una directiva de uso. Las directivas de uso se definen de la siguiente manera ( http://en.cppreference.com/w/cpp/language/namespace ):

Desde el punto de vista de la búsqueda de nombres no calificados de cualquier nombre después de una directiva de uso y hasta el final del ámbito en el que aparece, todos los nombres del nombre de espacio de nombres son visibles como si estuvieran declarados en el espacio de nombres de cierre más cercano que contenga ambos La directiva using y el nombre de espacio de nombres.

Por lo tanto, puede considerar estos dos ejemplos que muestran los problemas que pueden surgir.

Evita la ambigüedad entre los espacios de nombres que comparten el mismo nombre (ejemplo 1), así como la ambigüedad entre los nombres de clase en diferentes espacios de nombres (ejemplo 2).

namespace A
{
namespace B
{
struct my_struct {};
}
}
namespace B
{
struct my_struct {};
}
using namespace A; // removing this line makes B:: resolve to the global B::
int main()
{
::B::my_struct; // from global, will not pick A::B::
B::my_struct; // error: ''B'' is ambiguous, there is A::B:: and B::
}

Considere este ejemplo que muestra por qué las personas evitan el uso del uso de using namespace std;

using namespace std;
template <typename T>
class vector
{ };
int main()
{
vector<int> v; // which one did you want? ambiguous
::vector<int> v_global; // global one
::std::vector<int> v_std; // std::vector<T>
}

Answer 2

Depende de dónde uses la declaración de using . En un ámbito de espacio de nombres global no habrá diferencia. Sin embargo, si tienes código como

#include <iostream>
#include <vector>
namespace my_namespace {
namespace std {
class vector {
};
}
using std::vector;
}
int main()
{
my_namespace::vector<int> v;
}

no se compilará a menos que informe al compilador que busque el espacio de nombres global -> espacio de nombres estándar -> vector en su declaración indicando using ::std::vector .

Answer 3

En tu caso, lo más probable es que no haya diferencia. Sin embargo, en general, la diferencia es la siguiente:

using A::foo; resuelve A del alcance actual , mientras using ::A::foo busca A desde el espacio de nombres de la raíz. Por ejemplo:

namespace A
{
namespace B
{
class C;
}
}
namespace B
{
class C;
}
namespace A
{
using B::C; // resolves to A::B::C
using ::B::C; // resolves to B::C
// (note that one of those using declarations has to be
// commented for making this valid code!)
}

Answer 4

Si está dentro de otro espacio de nombres que tiene su propio std nombres std anidado, entonces ::std y std son diferentes. Un ejemplo simple:

#include <iostream>
namespace A {
namespace std {
void foo() { ::std::cout << "foo" << ::std::endl;}
}
//using std::cout; // compile error
using ::std::cout; //ok
using std::foo; // ok
//using ::std::foo; // compile error
}

Aunque definitivamente no es una buena práctica tener un std nombres std anidado.