Bereichsauflösungsoperator: ::

Der Bereichsauflösungsoperator :: wird zur Identifikation und eindeutigen Angabe von Bezeichnern in unterschiedlichen Geltungsbereichen verwendet. Weitere Informationen zu Geltungsbereichen finden Sie unter Geltungsbereich.

Syntax

qualified-id:
 nested-name-specifieropttemplate unqualified-id

nested-name-specifier:
 ::
 type-name ::
 namespace-name ::
 decltype-specifier ::
 nested-name-specifier identifier ::
 nested-name-specifier template_opt simple-template-id ::

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

Hinweise

identifier kann eine Variable, eine Funktion oder ein Enumerationswert sein.

Verwenden von :: für Klassen und Namespaces

Das folgende Beispiel zeigt die Verwendung des Bereichsauflösungsoperators mit Namespaces und Klassen:

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

Ein Bereichsauflösungsoperator ohne Bereichsqualifizierer verweist auf den globalen Namespace.

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

Mit dem Bereichsauflösungsoperator können Sie ein Member eines namespace oder einen Namespace, der den Namespace des Members benennt, in einer using-Anweisung identifizieren. Im folgenden Beispiel können Sie NamespaceC zum Qualifizieren von ClassB verwenden, obwohl ClassB im NamespaceB-Namespace deklariert wurde, da NamespaceB in NamespaceC durch eine using-Anweisung benannt wurde.

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

Bereichsauflösungsoperatoren können verkettet werden. Im folgenden Beispiel identifiziert NamespaceD::NamespaceD1 den geschachtelten Namespace NamespaceD1, und NamespaceE::ClassE::ClassE1 identifiziert die geschachtelte Klasse 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  ;
}

Verwenden von :: für statische Member

Sie müssen den Bereichsauflösungsoperator verwenden, um statische Member von Klassen aufzurufen.

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();
}

Verwenden von :: für bereichsbezogene Enumerationen

Der Bereichsauflösungsoperator wird außerdem mit den Werten einer bereichsbezogenen Enumeration in Enumerationsdeklarationen verwendet, wie im folgenden Beispiel gezeigt:

enum class EnumA{
    First,
    Second,
    Third
};

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

Weitere Informationen

Integrierte C++-Operatoren, Rangfolge und Assoziativität
Namespaces