En C++, l'opérateur de résolution de portée est :: . Il est utilisé aux fins suivantes.
1) Pour accéder à une variable globale lorsqu'il existe une variable locale du même nom :
RPC
// C++ program to show that we can access a global variable // using scope resolution operator :: when there is a local // variable with same name #include using namespace std; int x; // Global x int main() { int x = 10; // Local x cout << 'Value of global x is ' << ::x; cout << '
Value of local x is ' << x; return 0; }> Sortir
Value of global x is 0 Value of local x is 10>
2) Définir une fonction en dehors d'une classe.
RPC // C++ program to show that scope resolution operator :: is // used to define a function outside a class #include using namespace std; class A { public: // Only declaration void fun(); }; // Definition outside class using :: void A::fun() { cout << 'fun() called'; } int main() { A a; a.fun(); return 0; }> Sortir
fun() called>
3) Pour accéder aux variables statiques d’une classe.
RPC // C++ program to show that :: can be used to access static // members when there is a local variable with same name #include using namespace std; class Test { static int x; public: static int y; // Local parameter 'x' hides class member // 'x', but we can access it using :: void func(int x) { // We can access class's static variable // even if there is a local variable cout << 'Value of static x is ' << Test::x; cout << '
Value of local x is ' << x; } }; // In C++, static members must be explicitly defined // like this int Test::x = 1; int Test::y = 2; int main() { Test obj; int x = 3 ; obj.func(x); cout << '
Test::y = ' << Test::y; return 0; }> Sortir
Value of static x is 1 Value of local x is 3 Test::y = 2>
4) En cas de succession multiple : Si le même nom de variable existe dans deux classes ancêtres, nous pouvons utiliser l'opérateur de résolution de portée pour faire la distinction.
RPC
// Use of scope resolution operator in multiple inheritance. #include using namespace std; class A { protected: int x; public: A() { x = 10; } }; class B { protected: int x; public: B() { x = 20; } }; class C: public A, public B { public: void fun() { cout << 'A's x is ' << A::x; cout << '
B's x is ' << B::x; } }; int main() { C c; c.fun(); return 0; }> Sortir
A's x is 10 B's x is 20>
5) Pour l'espace de noms Si une classe portant le même nom existe dans deux espaces de noms, nous pouvons utiliser le nom de l'espace de noms avec l'opérateur de résolution de portée pour faire référence à cette classe sans aucun conflit.
C++ #include #include using namespace std; #define nline '
' // Global Declarations string name1 = 'GFG'; string favlang = 'python'; string companyName = 'GFG_2.0'; // You can also do the same thing in classes as we did in // our struct example class Developer { public: string name = 'krishna'; string favLang = 'c++'; string company = 'GFG'; // Accessing Global Declarations Developer(string favlang, string company) : favLang(favlang) , company(companyName) { } }; int main() { Developer obj = Developer('python', 'GFG'); cout << 'favourite Language : ' << obj.favLang << endl; cout << 'company Name : ' << obj.company << nline; }> Sortir
favourite Language : python company Name : GFG_2.0>
6) Faites référence à une classe à l’intérieur d’une autre classe : Si une classe existe dans une autre classe, nous pouvons utiliser la classe d'imbrication pour faire référence à la classe imbriquée à l'aide de l'opérateur de résolution de portée
RPC // Use of scope resolution class inside another class. #include using namespace std; class outside { public: int x; class inside { public: int x; static int y; int foo(); }; }; int outside::inside::y = 5; int main() { outside A; outside::inside B; }> 7) Faites référence à un membre de la classe de base dans l'objet dérivé : Dans le cas d'avoir la même méthode dans les classes de base et dérivées, nous pourrions faire référence à chacune par l'opérateur de résolution de portée comme ci-dessous.
C++
// Refer to a member of the base class in the derived object. #include class Base { public: void func() { std::cout << 'This is Base class' << std::endl; } }; class Derived : public Base { public: void func() { std::cout << 'This is Derived class' << std::endl; } }; int main() { Derived obj; obj.Base::func(); obj.func(); return 0; }> Sortir
This is Base class This is Derived class>