I den här guiden kommer vi att titta på dubbel kolon (::) operator i C++ och hur det fungerar i olika scenarier.
Vad gör :: i C++?
I C++ är räckviddsupplösning operatör (::) används för att hämta variabelns namn som finns på olika omfattningsnivåer. Omfattningen i programmering hänvisar till det sammanhang där variabler och funktioner kan nås.
Användning av :: i olika fall i C++
I C++ är scope resolution operator (::) har olika användningsområden beroende på i vilket sammanhang den används. Följande är några anmärkningsvärda användningsområden för denna operatör:
1: Få tillgång till en variabel eller funktion i ett annat namnområde
A namnutrymme används i C++ för att gruppera relaterade funktioner, klasser och variabler för att undvika namnkonflikter. När du definierar en variabel eller funktion inom en namnutrymme , är variabeln eller funktionens namn endast synligt inom det namnutrymme .
I C++ kan du använda scope resolution operator (::) tillsammans med namnutrymme namn och variabeln eller funktionsnamnet för att komma åt en variabel eller funktion definierad i ett annat namnområde. Detta låter dig komma åt variabeln eller funktionen från en namnutrymme annan än den där den skapades.
För att förstå fallet ovan, betrakta följande kod som ett exempel:
#includeanvänder namnutrymme std ;
namnområde matematik {
konst dubbel PI = 3,14159 ;
dubbel fyrkant ( dubbel x ) {
lämna tillbaka x * x ;
}
}
int huvud ( ) {
cout << 'Värdet på PI är:' << matematik :: PI << endl ;
cout << 'Kvadraten på 5 är:' << matematik :: fyrkant ( 5 ) << endl ;
lämna tillbaka 0 ;
}
Ovanstående kod använder matematiskt namnutrymme för att komma åt 'PI' konstant och 'fyrkant' funktion med hjälp av scope resolution operator '::' . Den skriver sedan ut värdena till konsolen.
Produktion
2: Få tillgång till Global Variable i programmet
När samma namn på lokala och globala variabler finns i programmet, kan den lokala variabeln dölja den globala. I sådana situationer kan du använda scope resolution operator (::) för att komma åt den globala variabeln. Denna operator tillåter oss att uttryckligen hänvisa till den globala variabeln baserat på dess omfattning.
Till exempel, i koden nedan, har vi hänvisat till den globala variabeln 'a ' via scope resolution operator(::) , inifrån en funktion där en lokal variabel med samma namn har definierats:
#includeanvänder namnutrymme std ;
int a = femton ;
int huvud ( )
{
int a = 35 ;
cout << 'Värdet för global variabel a är' << :: a << endl ;
cout << 'Värdet för lokal variabel a är' << a << endl ;
lämna tillbaka 0 ;
}
I ovanstående kod är variabeln a present utanför huvudfunktionen global variabel och variabeln a inom huvudfunktionen är lokal variabel med samma namn som den globala variabeln. I cout-satsen har vi använt scope resolution-operatorn för att skriva ut den globala variabeln a .
Produktion
3: Definiera en funktion utanför klassen
I C++ kan du definiera en klassfunktion utanför klassdefinitionen och det kan göras med hjälp av scope resolution operator (::) för att ange vilken klass funktionen tillhör. Detta är nödvändigt eftersom funktionen är definierad utanför klassomfånget.
Här är en exempelkod som visar denna användning av operatör för omfattningsupplösning :
#includeanvänder namnutrymme std ;
klass myClass {
offentlig :
tomhet min funktion ( ) ;
} ;
tomhet min klass :: min funktion ( ) {
cout << 'myfunction() Kallas !' ;
}
int huvud ( )
{
myClass classObj ;
classObj. min funktion ( ) ;
lämna tillbaka 0 ;
}
I ovanstående kod, medlemsfunktionen min funktion() definieras utanför klassen med hjälp av scope resolution operator :: att specificera det min funktion() tillhör klassen myClass.
Produktion
4: Få tillgång till statiska medlemmar i klassen
I C++, när det finns en statisk medlem och en lokal variabel med samma namn finns i klassen, scope resolution operator (::) kan användas för att komma åt statiska medlemmar i en klass. Detta gör att programmet kan skilja mellan den lokala variabeln och den statiska medlemmen.
Här är en exempelkod som relaterar användningen av operatör för omfattningsupplösning för ett sådant fall:
#includeanvänder namnutrymme std ;
klass myClass {
offentlig :
statisk int myStatVar ;
} ;
int min klass :: myStatVar = 5 ;
int huvud ( ) {
int myStatVar = 10 ;
cout << 'Lokal variabel myStatVar: ' << myStatVar << endl ;
cout << 'Klassvariabel myStatVar: ' << min klass :: myStatVar << endl ;
lämna tillbaka 0 ;
}
Ovanstående program definierar först en klass min klass med en statisk medlemsvariabel myStatVar . Den definierar sedan en lokal variabel med samma namn inuti programmets huvudfunktion. För att komma åt klassvariabeln, scope resolution operator (::) används med klassnamnet min klass . Programmet matar ut värdet för båda variablerna till konsolen.
Produktion
5: Använd med flera arv
De scope resolution operator (::) används också för att indikera vilken version av en medlem som ska användas när en C++-klass härrör från flera överordnade klasser som har medlemsvariabler eller funktioner med samma namn. Vi kan skilja mellan olika versioner av samma medlem genom att använda operatör för omfattningsupplösning följt av förälderklassens namn och medlemmens namn.
#includeanvänder namnutrymme std ;
klass Förälder 1 {
offentlig :
tomhet skriva ut ( ) {
cout << 'Detta är klass Parent1 utskriftsfunktion.' << endl ;
}
} ;
klass Förälder 2 {
offentlig :
tomhet skriva ut ( ) {
cout << 'Detta är klass Parent2 utskriftsfunktion.' << endl ;
}
} ;
klass myClass : offentlig förälder1 , offentlig förälder2 {
privat :
int på ett ;
offentlig :
min klass ( int n ) {
på ett = n ;
}
tomhet skriva ut ( ) {
Förälder 1 :: skriva ut ( ) ; // anrop Parent1s utskriftsfunktion
Förälder 2 :: skriva ut ( ) ; // anrop Parent2s utskriftsfunktion
cout << 'Värdet på num är: ' << på ett << endl ; // skriv ut värdet på num
}
} ;
int huvud ( ) {
myClass obj ( 42 ) ; // skapa ett objekt av MyClass med num initialiserat till 42
obj. skriva ut ( ) ; // anropa funktionen print() för objektet
lämna tillbaka 0 ;
}
Ovanstående program visar användningen av scope resolution operator (::) att skilja mellan utskriftsfunktionerna av Förälder 1 och Förälder 2 när båda klasserna ärvs av min klass. Genom att anropa funktionerna med Föräldraklass namn före funktionsnamnet kan vi ange vilken version av funktionen som ska användas.
Produktion
Slutsats
De scope resolution operator (::) är en viktig komponent i C++ som används för att komma åt variabelnamn över olika omfattningsnivåer. Operatören har olika användningsområden, inklusive att komma åt en variabel eller funktion i ett annat namnområde, komma åt en global variabel, definiera en funktion utanför klassen, komma åt statiska medlemmar i en klass och använda flera arv. Även om det kan vara förvirrande för nya utvecklare, förstå scope resolution operator (::) är avgörande för god programmeringspraxis.