În acest ghid, ne vom uita la operator dublu două puncte (::). în C++ și cum funcționează în diferite scenarii.
Ce face :: în C++?
În C++, rezoluția domeniului operator (::) este folosit pentru a prelua numele variabilelor prezente la diferite niveluri de domeniu. Domeniul de aplicare în programare se referă la contextul în care variabilele și funcțiile pot fi accesate.
Utilizări ale :: în diferite cazuri în C++
În C++, operator rezoluție domeniului (::) are diverse întrebuințări în funcție de contextul în care este utilizat. Următoarele sunt câteva utilizări notabile ale acestui operator:
1: Accesați o variabilă sau o funcție într-un spațiu de nume diferit
A spatiu de nume este folosit în C++ pentru a grupa funcții, clase și variabile asociate pentru a evita conflictele de denumire. Când definiți o variabilă sau o funcție în cadrul unui spatiu de nume , numele variabilei sau al funcției este vizibil numai în aceasta spatiu de nume .
În C++, puteți utiliza operator rezoluție domeniului (::) impreuna cu spatiu de nume nume și numele variabilei sau funcției pentru a accesa o variabilă sau o funcție definită într-un spațiu de nume diferit. Acest lucru vă permite să accesați variabila sau funcția din a spatiu de nume altul decât cel în care a fost creat.
Pentru a înțelege cazul de mai sus, luați în considerare următorul cod ca exemplu:
#includefolosind namespace std ;
matematica spatiului de nume {
const dubla PI = 3,14159 ;
dubla pătrat ( dubla X ) {
întoarcere X * X ;
}
}
int principal ( ) {
cout << 'Valoarea PI este: ' << matematica :: PI << endl ;
cout << „Pătratul lui 5 este:” << matematica :: pătrat ( 5 ) << endl ;
întoarcere 0 ;
}
Codul de mai sus folosește spatiu de nume matematic pentru a accesa „PI” constantă şi 'pătrat' funcția folosind operator de rezoluție domeniului „::” . Apoi imprimă valorile pe consolă.
Ieșire
2: Accesați variabila globală în program
Când același nume de variabile locale și globale este prezent în program, variabila locală o poate ascunde pe cea globală. În astfel de situații, puteți utiliza operator rezoluție domeniului (::) pentru accesarea variabilei globale. Acest operator ne permite să ne referim în mod explicit la variabila globală pe baza domeniului său.
De exemplu, în codul de mai jos, ne-am referit la variabila globală 'A 'prin intermediul operator rezoluție domeniului(::) , din interiorul unei funcții în care a fost definită o variabilă locală cu același nume:
#includefolosind namespace std ;
int A = cincisprezece ;
int principal ( )
{
int A = 35 ;
cout << „Valoarea variabilei globale a este” << :: A << endl ;
cout << „Valoarea variabilei locale a este” << A << endl ;
întoarcere 0 ;
}
În codul de mai sus, variabila a prezent în afara funcției principale este variabilă globală iar variabila a din cadrul funcției principale este variabilă locală cu același nume ca variabila globală. În instrucțiunea cout, am folosit operatorul de rezoluție pentru a tipări variabila globală A .
Ieșire
3: Definiți o funcție în afara clasei
În C++, puteți defini o funcție de clasă în afara definiției clasei și se poate face folosind operator rezoluție domeniului (::) pentru a specifica cărei clase îi aparține funcția. Acest lucru este necesar deoarece funcția este definită în afara domeniului de aplicare a clasei.
Iată un exemplu de cod care demonstrează această utilizare a codului operator rezoluție domeniului :
#includefolosind namespace std ;
clasa myClass {
public :
gol funcția mea ( ) ;
} ;
gol clasa mea :: funcția mea ( ) {
cout << 'funcția mea() Apelată!' ;
}
int principal ( )
{
myClass classObj ;
clasaObj. funcția mea ( ) ;
întoarcere 0 ;
}
În codul de mai sus, funcția membru functia mea() este definit în afara clasei folosind operator rezoluție domeniului :: pentru a preciza că functia mea() aparține clasei myClass.
Ieșire
4: Accesați membrii statici ai clasei
În C++, când există un membru static și o variabilă locală cu același nume este prezentă în clasă, operator rezoluție domeniului (::) poate fi folosit pentru a accesa membrii statici ai unei clase. Acest lucru permite programului să facă distincția între variabila locală și membrul static.
Iată un exemplu de cod care se referă la utilizarea operator rezoluție domeniului pentru un astfel de caz:
#includefolosind namespace std ;
clasa myClass {
public :
static int myStatVar ;
} ;
int clasa mea :: myStatVar = 5 ;
int principal ( ) {
int myStatVar = 10 ;
cout << 'Variabila locală myStatVar: ' << myStatVar << endl ;
cout << 'Variabila de clasă myStatVar: ' << clasa mea :: myStatVar << endl ;
întoarcere 0 ;
}
Programul de mai sus definește mai întâi o clasă clasa mea cu o variabilă membru statică myStatVar . Apoi definește o variabilă locală cu același nume în cadrul funcției principale a programului. Pentru a accesa variabila de clasă, the operator rezoluție domeniului (::) este folosit cu numele clasei clasa mea . Programul trimite valoarea ambelor variabile către consolă.
Ieșire
5: Utilizare cu moșteniri multiple
The operator rezoluție domeniului (::) este, de asemenea, folosit pentru a indica ce versiune a unui membru să folosească atunci când o clasă C++ este derivată din mai multe clase părinte care au variabile sau funcții membre cu același nume. Putem distinge între diferite versiuni ale aceluiași membru utilizând operator rezoluție domeniului urmat de numele clasei părinte și numele membrului.
#includefolosind namespace std ;
clasa Părinte1 {
public :
gol imprimare ( ) {
cout << „Aceasta este funcția de imprimare a clasei Parent1.” << endl ;
}
} ;
clasa Părinte2 {
public :
gol imprimare ( ) {
cout << „Aceasta este funcția de imprimare a clasei Parent2.” << endl ;
}
} ;
clasa myClass : Parinte public1 , Parinte public2 {
privat :
int pe unu ;
public :
clasa mea ( int n ) {
pe unu = n ;
}
gol imprimare ( ) {
Părinte1 :: imprimare ( ) ; // apelează funcția de imprimare a lui Parent1
Părinte2 :: imprimare ( ) ; // apelează funcția de imprimare a lui Parent2
cout << 'Valoarea lui num este: ' << pe unu << endl ; // imprimă valoarea lui num
}
} ;
int principal ( ) {
myClass obj ( 42 ) ; // creează un obiect din MyClass cu num inițializat la 42
obj. imprimare ( ) ; // apelează funcția print() a obiectului
întoarcere 0 ;
}
Programul de mai sus demonstrează utilizarea operator rezoluție domeniului (::) pentru a distinge între funcțiile de imprimare ale Părinte1 și Părinte2 când ambele clase sunt moștenite de clasa mea. Apelând funcțiile cu Clasa de părinți nume care precede numele funcției, putem specifica ce versiune a funcției să folosim.
Ieșire
Concluzie
The operator rezoluție domeniului (::) este o componentă vitală în C++ folosită pentru a accesa nume de variabile la diferite niveluri de domeniu. Operatorul are diverse utilizări, inclusiv accesarea unei variabile sau funcție într-un spațiu de nume diferit, accesarea unei variabile globale, definirea unei funcții în afara clasei, accesarea membrilor statici ai unei clase și utilizarea mai multor moșteniri. Deși poate fi confuz pentru dezvoltatorii noi, înțelegerea operator rezoluție domeniului (::) este esențială pentru buna practică de programare.