Operador de resolução de escopo: ::

O operador :: de resolução de escopo é usado para identificar e desambiguar identificadores usados em escopos diferentes. Para obter mais informações sobre o escopo, consulte Escopo.

Sintaxe

qualified-id:
  nested-name-specifier template _optarunqualified-id

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

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

Observações

Pode identifier 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 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 namespacenamespace ou identificar um namespace que nomeia o namespace do membro em uma using diretiva. No exemplo abaixo, você pode usar NamespaceC para se qualificar ClassB, mesmo que tenha ClassB sido declarado no namespace NamespaceB, porque NamespaceB foi indicado 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  ;
}

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

Usar :: para enumerações com escopo

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

enum class EnumA{
    First,
    Second,
    Third
};

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

Consulte também

Operadores internos, precedência e associação do C++
Namespaces