En C++, el operador de resolución de alcance es :: . Se utiliza para los siguientes propósitos.
1) Para acceder a una variable global cuando hay una variable local con el mismo nombre:
// 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<iostream>
using namespace std;
int x; // Global x
int main()
{
int x = 10; // Local x
cout << "Value of global x is " << ::x;
cout << "\nValue of local x is " << x;
return 0;
}
Producción:
Value of global x is 0 Value of local x is 10
2) Para definir una función fuera de una clase.
// C++ program to show that scope resolution operator :: is used
// to define a function outside a class
#include<iostream>
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;
}
Producción:
fun() called
3) Para acceder a las variables estáticas de una clase.
// C++ program to show that :: can be used to access static
// members when there is a local variable with same name
#include<iostream>
using namespace std;
class Test
{
static int x;
public:
static int y;
// Local parameter 'a' hides class member
// 'a', 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 << "\nValue 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 << "\nTest::y = " << Test::y;
return 0;
}
Producción:
Value of static x is 1 Value of local x is 3 Test::y = 2;
4) En caso de herencia múltiple:
si existe el mismo nombre de variable en dos clases de ancestros, podemos usar el operador de resolución de alcance para distinguir.
// Use of scope resolution operator in multiple inheritance.
#include<iostream>
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 << "\nB's x is " << B::x;
}
};
int main()
{
C c;
c.fun();
return 0;
}
Producción:
A's x is 10 B's x is 20
5) Para el espacio de nombres
Si existe una clase con el mismo nombre dentro de dos espacios de nombres, podemos usar el nombre del espacio de nombres con el operador de resolución de alcance para referirnos a esa clase sin ningún conflicto.
// Use of scope resolution operator for namespace.
#include<iostream>
int main(){
std::cout << "Hello" << std::endl;
}
Here, cout and endl belong to the std namespace.
6) Hacer referencia a una clase dentro de otra clase:
si existe una clase dentro de otra clase, podemos usar la clase de anidamiento para referir la clase anidada usando el operador de resolución de alcance
// Use of scope resolution class inside another class.
#include<iostream>
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;
}
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA