Operator rozpoznawania zakresu: ::

Operator :: rozpoznawania zakresu służy do identyfikowania i uściślania identyfikatorów używanych w różnych zakresach. Aby uzyskać więcej informacji na temat zakresu, zobacz Zakres.

Składnia

qualified-id:
  nested-name-specifier template _Zdecydowaćunqualified-id

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

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

Uwagi

Może identifier to być zmienna, funkcja lub wartość wyliczenia.

Używanie :: dla klas i przestrzeni nazw

W poniższym przykładzie pokazano, jak operator rozpoznawania zakresu jest używany z przestrzeniami nazw i klasami:

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

Operator rozpoznawania zakresu bez kwalifikatora zakresu odwołuje się do globalnej przestrzeni nazw.

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

Za pomocą operatora rozpoznawania zakresu można zidentyfikować element członkowski namespaceobiektu lub zidentyfikować przestrzeń nazw, która nominuje przestrzeń nazw członka w using dyrektywie. W poniższym przykładzie można użyć NamespaceC polecenia , aby zakwalifikować ClassBelement , mimo że ClassB został zadeklarowany w przestrzeni nazw NamespaceB, ponieważ NamespaceB został nominowany przez NamespaceC dyrektywę using .

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

Można użyć łańcuchów operatorów rozpoznawania zakresu. W poniższym przykładzie NamespaceD::NamespaceD1 identyfikuje zagnieżdżona przestrzeń nazw NamespaceD1i NamespaceE::ClassE::ClassE1 identyfikuje zagnieżdżonych klasę 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  ;
}

Używanie :: dla statycznych elementów członkowskich

Aby wywołać statyczne elementy członkowskie klas, należy użyć operatora rozpoznawania zakresu.

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

Użyj :: dla wyliczeń o określonym zakresie

Operator rozpoznawania zakresu jest również używany z wartościami deklaracji wyliczenia w zakresie, jak w poniższym przykładzie:

enum class EnumA{
    First,
    Second,
    Third
};

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

Zobacz także

Wbudowane operatory, pierwszeństwo i kojarzenie języka C++
Przestrzenie nazw