Ahogy a neve is sugallja, a Scope resolution operátort használják a rejtett nevek megszerzésére a változó hatókörök miatt, hogy továbbra is használhassa őket. Ebben a cikkben megértjük, hogyan kell használni a hatókörfeloldási operátort a C ++ nyelven, és mi különbözik az a céltól .
A C ++ - ban a hatókörfeloldási operátor ::. A C ++ nyelvű hatókörfelbontási operátor használható:
- Globális változó elérése, ha van egy azonos nevű helyi változó
- Funkció meghatározása osztályon kívül
- Hozzáférés egy osztály statikus változóihoz
- Hivatkozás egy másik osztályon belüli osztályra
- Többszörös öröklés esetén
- Névtér
Most a példák segítségével egyesével értsük meg a célokat.
Globális változó elérése, ha van egy helyi változó ugyanaz a név
A globális változó eléréséhez a hatókör-felbontás operátort használhatja, ha azonos nevű helyi változója van. Az alábbi példában két változó áll rendelkezésünkre, mindkettő neve globális és lokális. Tehát a fő osztály globális numer változójának eléréséhez használnia kell a hatókör felbontás operátort (azaz :: num).
Példa
#include névtér használatával std int num = 30 // Globális változó inicializálása num int main () {int num = 10 // A lokális változó num cout inicializálása<< 'Value of global num is ' << ::num cout << 'nValue of local num is ' << num return 0 } Kimenet
Folytatás ezzel a cikkel a Cope+ Operator in C ++ nyelven
Funkció meghatározása osztályon kívül
Ha egy funkciót deklarál egy osztályban, majd később az osztályon kívül szeretné meghatározni, akkor ezt megteheti a hatókör-felbontás operátorral. Az alábbi példában a Speed in Class Bike funkciót deklaráljuk. Később meghatározzuk a függvényt a fő osztályban a hatókör-felbontás operátor segítségével.
Példa
#include névtér használatával std osztály Bike {public: // Csak a funkció deklarációja érvénytelen Speed ()} // A Speed funkció meghatározása a Bike osztályon kívül a :: void Bike :: Speed () {cout használatával<< 'Speed of Bike is 90 KMPH' } int main() { Bike bike bike.Speed() return 0 } Kimenet
Folytatás ezzel a cikkel a Cope+ Operator in C ++ nyelven
Hozzáférés egy osztály statikájához változók
Az osztály statikus változójához az osztálynév és a hatókör-felbontás operátor (azaz osztálynév :: statikus_változó) segítségével férhet hozzá. Az alábbi példában láthatja, hogy statikus változót deklarálunk az osztályban. Az osztályon kívüli változót a hatókörfeloldás operátorral definiáljuk. Ezután az osztálynév és a hatókör felbontás operátor segítségével érjük el.
Példa
#include névtér használatával std class Próbálja ki {static int num1 public: static int num2 // Helyi paraméter elrejti az osztálytagot // Az osztálytag a :: void függvény segítségével érhető el (int num1) {// num1 statikus változó a következővel érhető el: :: // a num1 cout helyi változó ellenére<< 'Static num1: ' << Try::num1 cout << 'nLocal num1: ' << num1 } } // Defining a static members explicitly using :: int Try::num1 = 10 int Try::num2 = 15 int main() { Try o int num1 = 20 o.function(num1) cout << 'nTry::num2 = ' << Try::num2 return 0 } Kimenet
Folytatás ezzel a cikkel a Cope+ Operator in C ++ nyelven
Hivatkozás egy másik osztályon belüli osztályra
Hozhat létre beágyazott osztályt ugyanazokkal a változónevekkel mindkét osztályban. Mindkét változót a hatókörfeloldás operátorral érheti el. A belső osztályú változóhoz használni kell Külső_osztály :: belső_osztály :: változó.
mi az oka annak, hogy létrehozunk egy példányt a fájlosztályból?
Példa
#include a névtér használatával std class Outside_class {public: int num class Inside_class {public: int num static int x}} int Outside_class :: Inside_class :: x = 5 int main () {Outside_class A Outside_class :: Inside_class B}Folytatás ezzel a cikkel a Cope+ Operator in C ++ nyelven
Többszörös öröklés esetén
Ha két szülőosztálya van azonos változónevekkel, és mindkettőt örökli a gyermekosztályban, akkor az osztálynévvel rendelkező hatókörfeloldási operátorral elérheti az egyes változókat.
Az alábbi példában két szülőosztályt hozunk létre: Parent1 és Parent2, és mindkettő változó számmal rendelkezik. Amikor mindkettőjüket öröklik a Gyerek osztályban, mindkét szám változóhoz hozzáférhetünk az osztálynév és a hatókör felbontás operátorral.
Példa
#include névtér használatával std osztály Parent1 {védett: int num public: Parent1 () {num = 100}} class Parent2 {védett: int num public: Parent2 () {num = 200}} osztály Child: public Parent1, public Parent2 { public: void function () {cout<< 'Parent1's num is ' << Parent1::num cout << 'nParent2's num is ' << Parent2::num } } int main() { Child obj obj.function() return 0 } Kimenet
Folytatás ezzel a cikkel a Cope+ Operator in C ++ nyelven
Névtér
Tegyük fel, hogy két névterünk van, és mindkettő azonos nevű osztályt tartalmaz. Tehát a konfliktusok elkerülése érdekében használhatjuk a névtér nevét a hatókörfeloldás operátorral. Az alábbi példában használjuk std :: cout .
Példa
#include int main () {std :: cout<< 'Hello' << std::endl } Kimenet
A fenti programok áttekintése után mindent megértett volna a hatókörfeloldás operátorról a C ++ nyelven. Remélem, hogy ez a blog informatív és hozzáadott értéket jelent Önnek.
A fenti program végrehajtása után megértette volna a Scope Resolution Operator programot C ++ nyelven. Így a „Quicksort a Java-ban” című cikk végéhez értünk. Ha többet szeretne megtudni, nézze meg a Java Training by Edureka, egy megbízható online tanulási társaságot. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát arra tervezték, hogy mind az alapvető, mind a fejlett Java koncepciókra kiképezzen különféle Java keretrendszereket, például a Hibernate & Spring.
Van egy kérdésünk? Kérjük, említse meg a blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.