Ebben az útmutatóban megvizsgáljuk a kettős kettőspont (::) operátor C++ nyelven, és hogyan működik a különböző forgatókönyvekben.
Mit csinál :: C++ nyelven?
C++ nyelven a hatókör felbontása operátor (::) a különböző hatóköri szinteken található változók nevének lekérésére szolgál. A programozási hatókör arra a kontextusra vonatkozik, ahol a változók és függvények elérhetők.
A :: felhasználása különböző esetekben C++ nyelven
C++ nyelven a hatókör felbontás operátor (::) különböző felhasználási területei vannak, attól függően, hogy milyen környezetben használják. Az alábbiakban bemutatjuk ennek az operátornak néhány figyelemre méltó felhasználását:
1: Hozzáférés egy változóhoz vagy függvényhez egy másik névtérben
A névtér A C++-ban a kapcsolódó függvények, osztályok és változók csoportosítására használják, hogy elkerüljék az elnevezési ütközéseket. Amikor egy változót vagy függvényt definiál a névtér , a változó vagy a függvény neve csak azon belül látható névtér .
C++ nyelven használhatod a hatókör felbontás operátor (::) együtt a névtér név és a változó vagy függvény neve egy másik névtérben meghatározott változó vagy függvény eléréséhez. Ez lehetővé teszi a változó vagy függvény elérését a névtér más, mint amelyikben létrehozták.
A fenti eset megértéséhez vegye figyelembe a következő kódot példaként:
#includenévtér std használatával ;
névtér matematika {
const kettős PI = 3.14159 ;
kettős négyzet ( kettős x ) {
Visszatérés x * x ;
}
}
int fő- ( ) {
cout << 'A PI értéke: ' << matematika :: PI << endl ;
cout << 'Az 5 négyzete: << matematika :: négyzet ( 5 ) << endl ;
Visszatérés 0 ;
}
A fenti kód a matematikai névtér hozzáférni a 'PI' állandó és 'négyzet' funkció segítségével hatókör felbontási operátor '::' . Ezután kiírja az értékeket a konzolra.
Kimenet
2: Globális változó elérése a programban
Ha a helyi és a globális változók azonos neve szerepel a programban, a lokális változó elrejtheti a globális változót. Ilyen helyzetekben használhatja a hatókör felbontás operátor (::) a globális változó eléréséhez. Ez az operátor lehetővé teszi számunkra, hogy kifejezetten hivatkozzunk a globális változóra a hatóköre alapján.
Például az alábbi kódban a globális változóra hivatkoztunk ‘a ‘ keresztül a hatókör felbontás operátor(::) , egy függvény belsejéből, ahol azonos nevű helyi változót határoztak meg:
#includenévtér std használatával ;
int a = tizenöt ;
int fő- ( )
{
int a = 35 ;
cout << 'Az a globális változó értéke' << :: a << endl ;
cout << 'Az a helyi változó értéke' << a << endl ;
Visszatérés 0 ;
}
A fenti kódban a fő függvényen kívül jelen lévő a változó a globális változó a főfüggvényen belüli a változó pedig az helyi változó ugyanazzal a névvel, mint a globális változó. A cout utasításban a hatókör felbontási operátorát használtuk a globális változó kinyomtatására a .
Kimenet
3: Határozzon meg egy funkciót az osztályon kívül
A C++ nyelven az osztálydefiníción kívül is definiálhatunk egy osztályfüggvényt, és ez a következővel is megtehető hatókör felbontás operátor (::) hogy a függvény melyik osztályba tartozik. Erre azért van szükség, mert a függvény az osztály hatókörén kívül van definiálva.
Íme egy példakód, amely bemutatja a hatókör felbontási operátor :
#includenévtér std használatával ;
osztály myClass {
nyilvános :
üres funkcióm ( ) ;
} ;
üres az osztályom :: funkcióm ( ) {
cout << 'myfunction() Called!' ;
}
int fő- ( )
{
myClass classObj ;
osztályObj. funkcióm ( ) ;
Visszatérés 0 ;
}
A fenti kódban a tagfüggvény myfunction() osztályon kívül van definiálva a hatókör felbontás kezelő :: annak pontosítására myfunction() a myClass osztályba tartozik.
Kimenet
4: Hozzáférés az osztály statikus tagjaihoz
C++-ban, ha van egy statikus tag és egy azonos nevű helyi változó van jelen az osztályon belül, a hatókör felbontás operátor (::) osztály statikus tagjainak elérésére használható. Ez lehetővé teszi a program számára, hogy különbséget tudjon tenni a helyi változó és a statikus tag között.
Itt van egy példakód, amely a használatára vonatkozik hatókör felbontási operátor ilyen esetre:
#includenévtér std használatával ;
osztály myClass {
nyilvános :
statikus int myStatVar ;
} ;
int az osztályom :: myStatVar = 5 ;
int fő- ( ) {
int myStatVar = 10 ;
cout << 'MyStatVar helyi változó: ' << myStatVar << endl ;
cout << 'Osztályváltozó myStatVar: ' << az osztályom :: myStatVar << endl ;
Visszatérés 0 ;
}
A fenti program először meghatároz egy osztályt az osztályom statikus tagváltozóval myStatVar . Ezután a program fő funkciójában meghatároz egy azonos nevű helyi változót. Az osztályváltozó eléréséhez a hatókör felbontás operátor (::) osztálynévvel együtt használatos az osztályom . A program mindkét változó értékét kiírja a konzolra.
Kimenet
5: Használja többszörös öröklődéssel
A hatókör felbontás operátor (::) azt is jelzi, hogy egy tag melyik verzióját kell használni, ha egy C++ osztály több szülőosztályból származik, amelyeknek azonos nevű tagváltozói vagy függvényei vannak. Megkülönböztethetjük ugyanannak a tagnak a különböző verzióit a segítségével hatókör felbontási operátor ezt követi a szülő osztály neve és a tag neve.
#includenévtér std használatával ;
osztály Szülő1 {
nyilvános :
üres nyomtatás ( ) {
cout << 'Ez a Parent1 osztályú nyomtatási funkció.' << endl ;
}
} ;
osztály Szülő2 {
nyilvános :
üres nyomtatás ( ) {
cout << 'Ez a Parent2 osztályú nyomtatási funkció.' << endl ;
}
} ;
osztály myClass : nyilvános Szülő1 , nyilvános Szülő2 {
magán :
int az egyiken ;
nyilvános :
az osztályom ( int n ) {
az egyiken = n ;
}
üres nyomtatás ( ) {
Szülő1 :: nyomtatás ( ) ; // a Parent1 nyomtatási funkciójának meghívása
Szülő2 :: nyomtatás ( ) ; // a Parent2 nyomtatási funkciójának meghívása
cout << 'A szám értéke: ' << az egyiken << endl ; // kiírja a szám értékét
}
} ;
int fő- ( ) {
myClass obj ( 42 ) ; // hozzon létre egy objektumot a MyClassból 42-re inicializált számmal
obj. nyomtatás ( ) ; // az objektum print() függvényének meghívása
Visszatérés 0 ;
}
A fenti program bemutatja a hatókör felbontás operátor (::) különbséget tenni a nyomtatási funkciói között Szülő1 és Szülő2 amikor mindkét osztályt örökli az osztályom. A függvények meghívásával a Szülői osztály a függvény nevét megelőzően megadhatjuk, hogy a függvény melyik verzióját használjuk.
Kimenet
Bottom Line
A hatókör felbontás operátor (::) A C++ létfontosságú összetevője a változónevek különböző hatóköri szinteken való eléréséhez. Az operátor többféleképpen használható, beleértve egy változó vagy függvény elérését egy másik névtérben, hozzáférhet egy globális változóhoz, definiálhat egy függvényt az osztályon kívül, hozzáférhet egy osztály statikus tagjaihoz, és többszörös öröklődést használ. Bár ez zavaró lehet az új fejlesztők számára, megértve a hatókör felbontás operátor (::) elengedhetetlen a helyes programozási gyakorlathoz.