Operatore di risoluzione dell'ambito: ::

L'operatore :: di risoluzione dell'ambito viene usato per identificare e disambiguare gli identificatori usati in ambiti diversi. Per altre informazioni sull'ambito, vedere Ambito.

Sintassi

qualified-id:
 nested-name-specifiertemplate_optunqualified-id

nested-name-specifier:
 ::
 type-name ::
 namespace-name ::
 decltype-specifier ::
 nested-name-specifier identifier ::
 nested-name-specifiertemplate_optsimple-template-id::

unqualified-id:
 identifier
 operator-function-id
 conversion-function-id
 literal-operator-id
 ~ type-name
 ~ decltype-specifier
 template-id

Osservazioni:

identifier può essere una variabile una funzione oppure un valore di enumerazione.

Uso :: per classi e spazi dei nomi

L'esempio seguente mostra in che modo l'operatore di risoluzione dell'ambito viene usato con gli spazi dei nomi e le classi:

namespace NamespaceA{
    int x;
    class ClassA {
    public:
        int x;
    };
}

int main() {

    // A namespace name used to disambiguate
    NamespaceA::x = 1;

    // A class name used to disambiguate
    NamespaceA::ClassA a1;
    a1.x = 2;
}

Un operatore di risoluzione dell'ambito senza un qualificatore dell'ambito fa riferimento allo spazio dei nomi globale.

namespace NamespaceA{
    int x;
}

int x;

int main() {
    int x;

    // the x in main()
    x = 0;
    // The x in the global namespace
    ::x = 1;

    // The x in the A namespace
    NamespaceA::x = 2;
}

È possibile usare l'operatore di risoluzione dell'ambito per identificare un membro di un namespaceoggetto o per identificare uno spazio dei nomi che nomina lo spazio dei nomi del membro in una using direttiva. Nell'esempio seguente è possibile usare NamespaceC per qualificare ClassB, anche se ClassB è stato dichiarato nello spazio dei nomi NamespaceB, perché NamespaceB è stato nominato in NamespaceC da una using direttiva .

namespace NamespaceB {
    class ClassB {
    public:
        int x;
    };
}

namespace NamespaceC{
    using namespace NamespaceB;
}

int main() {
    NamespaceB::ClassB b_b;
    NamespaceC::ClassB c_b;

    b_b.x = 3;
    c_b.x = 4;
}

È possibile usare catene di operatori di risoluzione dell'ambito. Nell'esempio seguente, NamespaceD::NamespaceD1 identifica lo spazio dei nomi annidato NamespaceD1 e NamespaceE::ClassE::ClassE1 identifica la classe annidata ClassE1.

namespace NamespaceD{
    namespace NamespaceD1{
        int x;
    }
}

namespace NamespaceE{
    class ClassE{
    public:
        class ClassE1{
        public:
            int x;
        };
    };
}

int main() {
    NamespaceD:: NamespaceD1::x = 6;
    NamespaceE::ClassE::ClassE1 e1;
    e1.x = 7  ;
}

Uso :: per i membri statici

Per chiamare i membri statici delle classi è necessario usare l'operatore di risoluzione dell'ambito.

class ClassG {
public:
    static int get_x() { return x;}
    static int x;
};

int ClassG::x = 6;

int main() {

    int gx1 = ClassG::x;
    int gx2 = ClassG::get_x();
}

Usare :: per le enumerazioni con ambito

L'operatore di risoluzione con ambito viene usato anche con i valori di dichiarazioni di enumerazione con ambito, come nell'esempio seguente:

enum class EnumA{
    First,
    Second,
    Third
};

int main() {
    EnumA enum_value = EnumA::First;
}

Vedi anche

Operatori, precedenza e associatività predefiniti C++
Namespaces (Spazi dei nomi)