Operador de resolução do âmbito: ::

O operador :: de resolução do âmbito é utilizado para identificar e desambiguar identificadores utilizados em diferentes âmbitos. Para obter mais informações sobre escopo, consulte Escopo.

Sintaxe

qualified-id:
  nested-name-specifier template _{optar por}unqualified-id

nested-name-specifier:
 ::
  type-name ::
  namespace-name ::
  decltype-specifier ::
  nested-name-specifier identifier ::
  nested-name-specifier template _{optar por}simple-template-id::

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

Observações

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

Uso :: para classes e namespaces

O exemplo a seguir mostra como o operador de resolução de 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 de 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 namespace, ou para identificar um namespace que nomeia o namespace do membro em uma using diretiva. No exemplo abaixo, você pode usar NamespaceC para qualificar ClassB, mesmo que ClassB tenha sido declarado em namespace NamespaceB, porque NamespaceB foi nomeado em NamespaceC por uma using diretiva.

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 de escopo. No exemplo a seguir, NamespaceD::NamespaceD1 identifica o namespace NamespaceD1aninhado e NamespaceE::ClassE::ClassE1 identifica a classe ClassE1aninhada.

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 :: para membros estáticos

Você deve usar o operador de resolução de 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();
}

Uso :: para enumerações com escopo

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

enum class EnumA{
    First,
    Second,
    Third
};

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

Ver também

Operadores, precedência e associatividade integrados do C++
Namespaces (Espaços de nomes)