Opérateur de résolution d’étendue : ::

L’opérateur :: de résolution d’étendue est utilisé pour identifier et lever l’ambiguïté des identificateurs utilisés dans différentes étendues. Pour plus d’informations sur l’étendue, consultez Étendue.

Syntaxe

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

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

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

Remarques

Il identifier peut s’agir d’une variable, d’une fonction ou d’une valeur d’énumération.

Utiliser :: pour les classes et les espaces de noms

L’exemple suivant montre comment l’opérateur de résolution d’étendue est utilisé avec des espaces de noms et des 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;
}

Un opérateur de résolution d’étendue sans qualificateur d’étendue fait référence à l’espace de noms 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;
}

Vous pouvez utiliser l’opérateur de résolution d’étendue pour identifier un membre d’un namespaceou pour identifier un espace de noms qui nomme l’espace de noms du membre dans une using directive. Dans l’exemple ci-dessous, vous pouvez utiliser NamespaceC pour qualifier ClassB, même si ClassB elle a été déclarée dans l’espace de noms NamespaceB, car NamespaceB elle a été nommée par NamespaceC une using directive.

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

Vous pouvez utiliser des chaînes d’opérateurs de résolution d’étendue. Dans l’exemple suivant, NamespaceD::NamespaceD1 identifie l’espace de noms NamespaceD1imbriqué et NamespaceE::ClassE::ClassE1 identifie la classe ClassE1imbriquée.

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

Utiliser :: pour les membres statiques

Vous devez utiliser l’opérateur de résolution d’étendue pour appeler des membres statiques 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();
}

Utiliser :: pour les énumérations délimitées

L’opérateur de résolution délimité est également utilisé avec les valeurs d’une énumération délimitée, comme dans l’exemple suivant :

enum class EnumA{
    First,
    Second,
    Third
};

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

Voir aussi

Opérateurs intégrés C++, priorité et associativité
Namespaces