En esta guía, veremos los operador de dos puntos dobles (::) en C++ y cómo funciona en diferentes escenarios.
¿Qué hace :: en C++?
En C++, el resolución de alcance operador (::) se utiliza para recuperar los nombres de las variables presentes en varios niveles de alcance. El alcance en la programación se refiere al contexto donde se puede acceder a las variables y funciones.
Usos de :: en diferentes casos en C++
En C++, el operador de resolución de alcance (::) tiene varios usos dependiendo del contexto en el que se utilice. Los siguientes son algunos usos notables de este operador:
1: acceder a una variable o función en un espacio de nombres diferente
A espacio de nombres se usa en C++ para agrupar funciones, clases y variables relacionadas para evitar conflictos de nombres. Cuando define una variable o función dentro de un espacio de nombres , el nombre de la variable o función solo es visible dentro de ese espacio de nombres .
En C++, puede usar el operador de resolución de alcance (::) junto con espacio de nombres name y el nombre de la variable o función para acceder a una variable o función definida en un espacio de nombres diferente. Esto le permite acceder a la variable o función desde un espacio de nombres distinto de aquél en que fue creado.
Para comprender el caso anterior, considere el siguiente código como ejemplo:
#incluirusando el espacio de nombres estándar ;
matemáticas del espacio de nombres {
constante doble Pi = 3.14159 ;
doble cuadrado ( doble X ) {
devolver X * X ;
}
}
En t principal ( ) {
cout << 'El valor de PI es: ' << matemáticas :: Pi << final ;
cout << 'El cuadrado de 5 es: ' << matemáticas :: cuadrado ( 5 ) << final ;
devolver 0 ;
}
El código anterior utiliza el espacio de nombres matemático para acceder a la 'PI' constante y 'cuadrado' función usando el operador de resolución de alcance '::' . Luego imprime los valores en la consola.
Producción
2: Acceder a la variable global en el programa
Cuando el mismo nombre de variables locales y globales está presente en el programa, la variable local puede ocultar la global. En tales situaciones, puede utilizar el operador de resolución de alcance (::) para acceder a la variable global. Este operador nos permite referirnos explícitamente a la variable global en función de su alcance.
Por ejemplo, en el código dado a continuación, nos hemos referido a la variable global 'a ' mediante el operador de resolución de alcance (::) , desde dentro de una función donde se ha definido una variable local con el mismo nombre:
#incluirusando el espacio de nombres estándar ;
En t a = 15 ;
En t principal ( )
{
En t a = 35 ;
cout << 'El valor de la variable global a es' << :: a << final ;
cout << 'El valor de la variable local a es ' << a << final ;
devolver 0 ;
}
En el código anterior, la variable a presente fuera de la función principal es el variable global y la variable a dentro de la función principal es la variable local con el mismo nombre que la variable global. En la instrucción cout, hemos utilizado el operador de resolución de alcance para imprimir la variable global a .
Producción
3: Definir una función fuera de la clase
En C ++, puede definir una función de clase fuera de la definición de clase y se puede hacer usando el operador de resolución de alcance (::) para especificar a qué clase pertenece la función. Esto es necesario porque la función se define fuera del alcance de la clase.
Aquí hay un código de ejemplo que demuestra este uso de la operador de resolución de alcance :
#incluirusando el espacio de nombres estándar ;
clase miclase {
público :
vacío mi función ( ) ;
} ;
vacío mi clase :: mi función ( ) {
cout << 'myfunction() Llamado!' ;
}
En t principal ( )
{
miClase classObj ;
classObj. mi función ( ) ;
devolver 0 ;
}
En el código anterior, la función miembro mifuncion() se define fuera de la clase usando el operador de resolución de alcance :: para especificar que mifuncion() pertenece a la clase myClass.
Producción
4: Acceder a miembros estáticos de la clase
En C++, cuando hay un miembro estático y una variable local con el mismo nombre está presente dentro de la clase, el operador de resolución de alcance (::) se puede utilizar para acceder a miembros estáticos de una clase. Esto permite que el programa distinga entre la variable local y el miembro estático.
Aquí hay un código de ejemplo que relaciona el uso de operador de resolución de alcance para tal caso:
#incluirusando el espacio de nombres estándar ;
clase miclase {
público :
estático En t miEstadVar ;
} ;
En t mi clase :: miEstadVar = 5 ;
En t principal ( ) {
En t miEstadVar = 10 ;
cout << 'Variable local myStatVar: ' << miEstadVar << final ;
cout << 'Variable de clase myStatVar: ' << mi clase :: miEstadVar << final ;
devolver 0 ;
}
El programa anterior primero define una clase mi clase con una variable miembro estática miEstadVar . Luego define una variable local con el mismo nombre dentro de la función principal del programa. Para acceder a la variable de clase, el operador de resolución de alcance (::) se usa con el nombre de la clase mi clase . El programa envía el valor de ambas variables a la consola.
Producción
5: Uso con Herencias Múltiples
El operador de resolución de alcance (::) también se usa para indicar qué versión de un miembro usar cuando una clase de C++ se deriva de varias clases principales que tienen funciones o variables de miembro con el mismo nombre. Podemos distinguir entre varias versiones del mismo miembro usando el operador de resolución de alcance seguido del nombre de la clase principal y el nombre del miembro.
#incluirusando el espacio de nombres estándar ;
clase Padre1 {
público :
vacío imprimir ( ) {
cout << 'Esta es la función de impresión de la clase Parent1'. << final ;
}
} ;
clase Padre2 {
público :
vacío imprimir ( ) {
cout << 'Esta es la función de impresión de la clase Parent2'. << final ;
}
} ;
clase miclase : padre1 público , Padre2 público {
privado :
En t en uno ;
público :
mi clase ( En t norte ) {
en uno = norte ;
}
vacío imprimir ( ) {
Padre1 :: imprimir ( ) ; // llamar a la función de impresión de Parent1
padre2 :: imprimir ( ) ; // llamar a la función de impresión de Parent2
cout << 'El valor de num es: ' << en uno << final ; // imprime el valor de num
}
} ;
En t principal ( ) {
miClase obj ( 42 ) ; // crea un objeto de MyClass con num inicializado a 42
objeto imprimir ( ) ; // llama a la función print() del objeto
devolver 0 ;
}
El programa anterior demuestra el uso de la operador de resolución de alcance (::) distinguir entre las funciones de impresión de Padre1 y padre2 cuando ambas clases son heredadas por mi clase. Llamando a las funciones con el clase padre nombre que precede al nombre de la función, podemos especificar qué versión de la función usar.
Producción
Línea de fondo
El operador de resolución de alcance (::) es un componente vital en C++ que se usa para acceder a nombres de variables en diferentes niveles de alcance. El operador tiene varios usos, incluido el acceso a una variable o función en un espacio de nombres diferente, el acceso a una variable global, la definición de una función fuera de la clase, el acceso a miembros estáticos de una clase y el uso de herencias múltiples. Aunque puede ser confuso para los nuevos desarrolladores, entender el operador de resolución de alcance (::) es esencial para una buena práctica de programación.