En aquesta guia, veurem el operador de dos punts (::). en C++ i com funciona en diferents escenaris.
Què fa :: en C++?
En C++, el resolució d'abast operador (::) s'utilitza per recuperar els noms de les variables presents a diversos nivells d'abast. L'abast de la programació fa referència al context on es pot accedir a variables i funcions.
Usos de :: en diferents casos en C++
En C++, el operador de resolució d'abast (::) té diversos usos segons el context en què s'utilitza. A continuació es mostren alguns usos notables d'aquest operador:
1: Accediu a una variable o funció en un espai de noms diferent
A espai de noms s'utilitza en C++ per agrupar funcions, classes i variables relacionades per evitar conflictes de noms. Quan definiu una variable o funció dins d'a espai de noms , el nom de la variable o de la funció només és visible dins d'aquesta espai de noms .
En C++, podeu utilitzar el operador de resolució d'abast (::) juntament amb el espai de noms nom i el nom de la variable o de la funció per accedir a una variable o funció definida en un espai de noms diferent. Això us permet accedir a la variable o funció des de a espai de noms diferent d'aquell en què va ser creat.
Per entendre el cas anterior, considereu el codi següent com a exemple:
#inclouutilitzant l'espai de noms std ;
matemàtiques de l'espai de noms {
const doble Pi = 3.14159 ;
doble quadrat ( doble x ) {
tornar x * x ;
}
}
int principal ( ) {
cout << 'El valor de PI és:' << matemàtiques :: Pi << endl ;
cout << 'El quadrat de 5 és:' << matemàtiques :: quadrat ( 5 ) << endl ;
tornar 0 ;
}
El codi anterior utilitza el espai de noms matemàtics per accedir a 'PI' constant i 'quadrat' funció utilitzant la operador de resolució d'abast '::' . A continuació, imprimeix els valors a la consola.
Sortida
2: Accés a la variable global al programa
Quan el mateix nom de variables locals i globals està present al programa, la variable local pot ocultar la global. En aquestes situacions, podeu utilitzar el operador de resolució d'abast (::) per accedir a la variable global. Aquest operador ens permet fer referència explícita a la variable global en funció del seu abast.
Per exemple, al codi que es mostra a continuació, ens hem referit a la variable global ‘a 'a través del operador de resolució d'abast(::) , des d'una funció on s'ha definit una variable local amb el mateix nom:
#inclouutilitzant l'espai de noms std ;
int a = 15 ;
int principal ( )
{
int a = 35 ;
cout << 'El valor de la variable global a és' << :: a << endl ;
cout << 'El valor de la variable local a és' << a << endl ;
tornar 0 ;
}
En el codi anterior, la variable a present fora de la funció principal és la variable global i la variable a dins de la funció principal és la variable local amb el mateix nom que la variable global. A la instrucció cout, hem utilitzat l'operador de resolució d'abast per imprimir la variable global a .
Sortida
3: Definiu una funció fora de la classe
En C++, podeu definir una funció de classe fora de la definició de classe i es pot fer amb el operador de resolució d'abast (::) per especificar a quina classe pertany la funció. Això és necessari perquè la funció es defineix fora de l'àmbit de la classe.
Aquí hi ha un exemple de codi que demostra aquest ús del operador de resolució d'abast :
#inclouutilitzant l'espai de noms std ;
classe myClass {
públic :
buit la meva funció ( ) ;
} ;
buit la meva classe :: la meva funció ( ) {
cout << 'La meva funció() S'ha cridat!' ;
}
int principal ( )
{
myClass classObj ;
classObj. la meva funció ( ) ;
tornar 0 ;
}
Al codi anterior, la funció membre la meva funció () es defineix fora de la classe mitjançant el operador de resolució d'abast :: per concretar-ho la meva funció () pertany a la classe myClass.
Sortida
4: Accés als membres estàtics de la classe
En C++, quan hi ha un membre estàtic i una variable local amb el mateix nom està present dins de la classe, el operador de resolució d'abast (::) es pot utilitzar per accedir als membres estàtics d'una classe. Això permet al programa distingir entre la variable local i el membre estàtic.
Aquí teniu un exemple de codi que relaciona l'ús de operador de resolució d'abast per a aquest cas:
#inclouutilitzant l'espai de noms std ;
classe myClass {
públic :
estàtica int myStatVar ;
} ;
int la meva classe :: myStatVar = 5 ;
int principal ( ) {
int myStatVar = 10 ;
cout << 'Variable local myStatVar: ' << myStatVar << endl ;
cout << 'Variable de classe myStatVar: ' << la meva classe :: myStatVar << endl ;
tornar 0 ;
}
El programa anterior defineix primer una classe la meva classe amb una variable membre estàtica myStatVar . A continuació, defineix una variable local amb el mateix nom dins de la funció principal del programa. Per accedir a la variable de classe, el operador de resolució d'abast (::) s'utilitza amb el nom de la classe la meva classe . El programa envia el valor d'ambdues variables a la consola.
Sortida
5: Ús amb múltiples herències
El operador de resolució d'abast (::) també s'utilitza per indicar quina versió d'un membre s'ha d'utilitzar quan una classe C++ es deriva de diverses classes pares que tenen variables de membre o funcions amb el mateix nom. Podem distingir entre diverses versions d'un mateix membre utilitzant el operador de resolució d'abast seguit del nom de la classe dels pares i del nom del membre.
#inclouutilitzant l'espai de noms std ;
classe Parent 1 {
públic :
buit imprimir ( ) {
cout << 'Aquesta és la funció d'impressió de la classe Parent1'. << endl ;
}
} ;
classe pares 2 {
públic :
buit imprimir ( ) {
cout << 'Aquesta és la funció d'impressió de la classe Parent2'. << endl ;
}
} ;
classe myClass : Pare públic 1 , Pare públic 2 {
privat :
int en una ;
públic :
la meva classe ( int n ) {
en una = n ;
}
buit imprimir ( ) {
Pare 1 :: imprimir ( ) ; // crida a la funció d'impressió de Parent1
Pare 2 :: imprimir ( ) ; // crida a la funció d'impressió de Parent2
cout << 'El valor de num és:' << en una << endl ; // imprimeix el valor de num
}
} ;
int principal ( ) {
myClass obj ( 42 ) ; // crea un objecte de MyClass amb num inicialitzat a 42
obj. imprimir ( ) ; // crida a la funció print() de l'objecte
tornar 0 ;
}
El programa anterior demostra l'ús de la operador de resolució d'abast (::) per distingir entre les funcions d'impressió de Pare 1 i Pare 2 quan les dues classes són heretades per la meva classe. En cridar les funcions amb el Classe de pares nom que precedeix el nom de la funció, podem especificar quina versió de la funció utilitzarem.
Sortida
Linia inferior
El operador de resolució d'abast (::) és un component vital en C++ utilitzat per accedir a noms de variables a diferents nivells d'abast. L'operador té diversos usos, com ara accedir a una variable o funció en un espai de noms diferent, accedir a una variable global, definir una funció fora de la classe, accedir a membres estàtics d'una classe i utilitzar múltiples herències. Encara que pot ser confús per als nous desenvolupadors, entendre el operador de resolució d'abast (::) és essencial per a una bona pràctica de programació.