Operador de resolução do escopo: ::

O operador de resolução do escopo :: é utilizado para identificar e remover ambiguidades de identificadores usados em escopos diferentes. Para mais informações sobre escopo, confira Escopo.

Sintaxe

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

Comentários

O identifier pode ser uma variável, uma função ou um valor de enumeração.

Usar :: para classes e namespaces

O exemplo a seguir mostra como o operador de resolução do escopo é usado com namespaces e classes:

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

Um operador de resolução do escopo sem um qualificador de escopo refere-se ao namespace global.

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

Você pode usar o operador de resolução de escopo para identificar um membro de um , ou para identificar um namespacenamespace que nomeia o namespace do membro em uma using diretiva. No exemplo abaixo, você pode usar NamespaceC para qualificar ClassB, embora ClassB tenha sido declarada em namespace NamespaceB porque NamespaceB foi nomeado em NamespaceC por uma diretiva 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;
}

Você pode usar cadeias de operadores de resolução do escopo. No exemplo a seguir, NamespaceD::NamespaceD1 identifica o namespace aninhado NamespaceD1 e NamespaceE::ClassE::ClassE1 identifica a classe aninhada 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  ;
}

Usar :: para membros estáticos

Você deve usar o operador de resolução do escopo para chamar membros estáticos de classes.

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

Usar :: para enumerações com escopo

O operador de resolução do escopo é também usado com os valores de uma enumeração com escopo Declarações de enumeração, como no seguinte exemplo:

enum class EnumA{
    First,
    Second,
    Third
};

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

Confira também

Operadores internos, precedência e associatividade no C++
Namespaces