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

Notes

identifier peut être une variable, une fonction ou 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 de portée est utilisé avec les espaces de noms et les 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 de portée sans qualificateur de portée 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 de portée. Dans l'exemple suivant, NamespaceD::NamespaceD1 identifie l'espace de noms imbriqué NamespaceD1 et NamespaceE::ClassE::ClassE1 identifie la classe imbriquée 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  ;
}

Utiliser :: pour les membres statiques

Vous devez utiliser l'opérateur de résolution de portée 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é
Espaces de noms