Unterschied in using namespace (std :: vs :: std: :)

Question

using ::std::...; 

VS

using std::...; 

Gibt es einen Unterschied (n)? Wenn ja, welche)?

sah ich dies:

using ::std::nullptr_t; 

, die mich fragen, gemacht.

Answer 1

In Ihrem Fall gibt es höchstwahrscheinlich keinen Unterschied. Jedoch in der Regel wird die Differenz wie folgt:

using A::foo; löst A vom aktuellen Umfang, während using ::A::foo sucht nach A aus dem Stammnamespace.Zum Beispiel:

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 2

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

Mit-Deklaration ein Mitglied eines anderen Namespace in aktuellen Namensraum einführt oder Umfang

Daher blockieren, wenn Ihr bereits aktuellen Bereich eine Klasse mit dem gleichen Namen hat, Es wird eine Zweideutigkeit zwischen der von Ihnen eingegebenen und der in Ihrem aktuellen Namespace/Block bestehen.

Eine using-Deklaration ist nur eine Teilmenge einer using-Anweisung. Die Verwendung von Richtlinien wie folgt definiert sind (http://en.cppreference.com/w/cpp/language/namespace):

Aus der Sicht von unqualifizierter Namen-Suche von einem beliebigen Namen nach einem mit-Richtlinie und bis zum Ende des Bereichs, in dem es erscheint, alle Namen from namespace-name ist sichtbar, als ob es in dem nächsten umschließenden Namespace deklariert wäre, der sowohl die using-Direktive als auch den Namespace-name enthält.

So können Sie diese zwei Beispiele betrachten, die die Probleme anzeigen, die auftreten können.

Es verhindert Mehrdeutigkeit zwischen Namespaces, die den gleichen Namen (Beispiel 1) sowie Ambiguität zwischen Klassennamen in verschiedenen Namespaces (Beispiel 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:: 
} 

Betrachten Sie dieses Beispiel, das zeigt, warum die Menschen die Verwendung von 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 3

Es hängt davon ab, zu meiden, wo Sie die using Erklärung verwenden. In einem globalen Namespace-Bereich gibt es keinen Unterschied. Wenn Sie jedoch haben Code wie

#include <iostream> 
#include <vector> 

namespace my_namespace { 
    namespace std { 
     class vector { 
     }; 
    } 

    using std::vector; 
} 

int main() 
{ 
    my_namespace::vector<int> v; 
} 

es wird nicht kompiliert, wenn Sie den Compiler informiert den globalen Namespace suchen -> std-Namespace -> Vektor in Ihrer Erklärung using ::std::vector Angabe.

Answer 4

Wenn Sie in einem anderen Namensraum, der seinen eigenen verschachtelten std Namensraum hat, dann ::std und std unterschiedlich sind. Ein einfaches Beispiel:

#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 
} 

Obwohl definitiv keine gute Praxis, jemals einen verschachtelten std Namespace.