Sa gabay na ito, titingnan natin ang double colon (::) operator sa C++ at kung paano ito gumagana sa iba't ibang mga sitwasyon.
Ano ang Ginagawa :: Ginagawa sa C++?
Sa C++, ang resolusyon ng saklaw operator (::) ay ginagamit upang kunin ang mga pangalan ng variable na nasa iba't ibang antas ng saklaw. Ang saklaw sa programming ay tumutukoy sa konteksto kung saan maaaring ma-access ang mga variable at function.
Mga paggamit ng :: sa Iba't ibang Kaso sa C++
Sa C++, ang operator ng resolution ng saklaw (::) ay may iba't ibang gamit depende sa konteksto kung saan ito ginagamit. Ang mga sumusunod ay ilang kapansin-pansing paggamit ng operator na ito:
1: Mag-access ng Variable o Function sa Ibang Namespace
A namespace ay ginagamit sa C++ upang pangkatin ang mga nauugnay na function, klase, at variable upang maiwasan ang mga salungatan sa pagbibigay ng pangalan. Kapag tinukoy mo ang isang variable o function sa loob ng a namespace , ang pangalan ng variable o function ay makikita lamang sa loob nito namespace .
Sa C++, maaari mong gamitin ang operator ng resolution ng saklaw (::) kasama ang namespace pangalan at ang variable o pangalan ng function upang ma-access ang isang variable o function na tinukoy sa ibang namespace. Binibigyang-daan ka nitong ma-access ang variable o function mula sa a namespace maliban sa kung saan ito nilikha.
Upang maunawaan ang kaso sa itaas, isaalang-alang ang sumusunod na code bilang isang halimbawa:
#includegamit ang namespace std ;
namespace math {
const doble PI = 3.14159 ;
doble parisukat ( doble x ) {
bumalik x * x ;
}
}
int pangunahing ( ) {
cout << 'Ang halaga ng PI ay: ' << matematika :: PI << endl ;
cout << 'Ang parisukat ng 5 ay: ' << matematika :: parisukat ( 5 ) << endl ;
bumalik 0 ;
}
Ang code sa itaas ay gumagamit ng namespace ng matematika para ma-access ang “PI” pare-pareho at “parisukat” function gamit ang operator ng resolution ng saklaw '::' . Pagkatapos ay ipi-print nito ang mga halaga sa console.
Output
2: I-access ang Global Variable sa Programa
Kapag ang parehong pangalan ng mga lokal at pandaigdigang variable ay nasa programa, maaaring itago ng lokal na variable ang global. Sa ganitong mga sitwasyon, maaari mong gamitin ang operator ng resolution ng saklaw (::) para sa pag-access sa global variable. Binibigyang-daan kami ng operator na ito na tahasang sumangguni sa pandaigdigang variable batay sa saklaw nito.
Halimbawa, sa ibinigay na code sa ibaba, tinukoy namin ang global variable ‘a 'sa pamamagitan ng operator ng resolution ng saklaw(::) , mula sa loob ng isang function kung saan tinukoy ang isang lokal na variable na may parehong pangalan:
#includegamit ang namespace std ;
int a = labinlima ;
int pangunahing ( )
{
int a = 35 ;
cout << 'Ang Halaga ng pandaigdigang variable a ay ' << :: a << endl ;
cout << 'Ang Halaga ng lokal na variable a ay ' << a << endl ;
bumalik 0 ;
}
Sa code sa itaas, ang variable a present sa labas ng pangunahing function ay ang pandaigdigang variable at ang variable a sa loob ng pangunahing function ay ang lokal na variable na may parehong pangalan bilang global variable. Sa cout statement, ginamit namin ang scope resolution operator para i-print ang global variable a .
Output
3: Tukuyin ang isang Function sa Labas ng Klase
Sa C++, maaari mong tukuyin ang isang function ng klase sa labas ng kahulugan ng klase at maaari itong gawin gamit ang operator ng resolution ng saklaw (::) upang tukuyin kung saang klase nabibilang ang function. Ito ay kinakailangan dahil ang function ay tinukoy sa labas ng saklaw ng klase.
Narito ang isang halimbawang code na nagpapakita ng paggamit ng operator ng resolusyon ng saklaw :
#includegamit ang namespace std ;
klase myClass {
pampubliko :
walang bisa my function ( ) ;
} ;
walang bisa myClass :: my function ( ) {
cout << 'myfunction() Called !' ;
}
int pangunahing ( )
{
myClass classObj ;
classObj. my function ( ) ;
bumalik 0 ;
}
Sa code sa itaas, ang function ng miyembro myfunction() ay tinukoy sa labas ng klase gamit ang operator ng resolusyon ng saklaw :: upang tukuyin iyon myfunction() kabilang sa klase ng myClass.
Output
4: I-access ang Mga Static na Miyembro ng Klase
Sa C++, kapag mayroong isang static na miyembro at isang lokal na variable na may parehong pangalan ay naroroon sa loob ng klase, ang operator ng resolution ng saklaw (::) ay maaaring gamitin upang ma-access ang mga static na miyembro ng isang klase. Pinapayagan nito ang programa na makilala ang pagkakaiba sa pagitan ng lokal na variable at ng static na miyembro.
Narito ang isang halimbawang code na nauugnay sa paggamit ng operator ng resolusyon ng saklaw para sa ganitong kaso:
#includegamit ang namespace std ;
klase myClass {
pampubliko :
static int myStatVar ;
} ;
int myClass :: myStatVar = 5 ;
int pangunahing ( ) {
int myStatVar = 10 ;
cout << 'Lokal na variable myStatVar: ' << myStatVar << endl ;
cout << 'Ang variable ng klase myStatVar: ' << myClass :: myStatVar << endl ;
bumalik 0 ;
}
Ang programa sa itaas ay unang tumutukoy sa isang klase myClass na may static na variable ng miyembro myStatVar . Pagkatapos ay tinukoy nito ang isang lokal na variable na may parehong pangalan sa loob ng pangunahing function ng programa. Upang ma-access ang variable ng klase, ang operator ng resolution ng saklaw (::) ay ginagamit sa pangalan ng klase myClass . Ang programa ay naglalabas ng halaga ng parehong mga variable sa console.
Output
5: Gamitin na may Maramihang Pamana
Ang operator ng resolution ng saklaw (::) ay ginagamit din upang ipahiwatig kung aling bersyon ng isang miyembro ang gagamitin kapag ang isang C++ na klase ay hinango mula sa maraming parent na klase na may mga variable o function ng miyembro na may parehong pangalan. Maaari nating makilala ang iba't ibang bersyon ng parehong miyembro sa pamamagitan ng paggamit ng operator ng resolusyon ng saklaw sinusundan ng pangalan ng klase ng magulang at pangalan ng miyembro.
#includegamit ang namespace std ;
Magulang ng klase1 {
pampubliko :
walang bisa print ( ) {
cout << 'Ito ang function ng pag-print ng class Parent1.' << endl ;
}
} ;
klase Magulang2 {
pampubliko :
walang bisa print ( ) {
cout << 'Ito ang function ng pag-print ng class Parent2.' << endl ;
}
} ;
klase myClass : pampublikong Magulang1 , pampublikong Magulang2 {
pribado :
int sa isa ;
pampubliko :
myClass ( int n ) {
sa isa = n ;
}
walang bisa print ( ) {
Magulang1 :: print ( ) ; // tawagan ang function ng pag-print ng Parent1
Magulang2 :: print ( ) ; // tawagan ang function ng pag-print ng Parent2
cout << 'Ang halaga ng num ay: ' << sa isa << endl ; // i-print ang halaga ng num
}
} ;
int pangunahing ( ) {
myClass obj ( 42 ) ; // lumikha ng isang bagay ng MyClass na may num na nasimulan sa 42
obj. print ( ) ; // tawagan ang print() function ng object
bumalik 0 ;
}
Ang programa sa itaas ay nagpapakita ng paggamit ng operator ng resolution ng saklaw (::) upang makilala sa pagitan ng mga pag-print ng function ng Magulang1 at Magulang2 kapag ang parehong klase ay minana ng myClass. Sa pamamagitan ng pagtawag sa mga function gamit ang Klase ng magulang pangalan bago ang pangalan ng function, maaari naming tukuyin kung aling bersyon ng function ang gagamitin.
Output
Bottom Line
Ang operator ng resolution ng saklaw (::) ay isang mahalagang bahagi sa C++ na ginagamit upang ma-access ang mga variable na pangalan sa iba't ibang antas ng saklaw. Ang operator ay may iba't ibang gamit, kabilang ang pag-access sa isang variable o function sa ibang namespace, pag-access sa isang global variable, pagtukoy ng isang function sa labas ng klase, pag-access sa mga static na miyembro ng isang klase, at paggamit ng maraming inheritance. Bagama't maaaring nakakalito para sa mga bagong developer, ang pag-unawa sa operator ng resolution ng saklaw (::) ay mahalaga para sa mahusay na kasanayan sa programming.