Dalam panduan ini, kita akan melihat dua titik dua (::) operator dalam C++ dan cara ia berfungsi dalam senario yang berbeza.
Apa yang :: Lakukan dalam C++?
Dalam C++, the resolusi skop pengendali (::) digunakan untuk mendapatkan semula nama pembolehubah yang terdapat pada pelbagai peringkat skop. Skop dalam pengaturcaraan merujuk kepada konteks di mana pembolehubah dan fungsi boleh diakses.
Penggunaan :: dalam Kes Berbeza dalam C++
Dalam C++, the pengendali resolusi skop (::) mempunyai pelbagai kegunaan bergantung kepada konteks di mana ia digunakan. Berikut adalah beberapa kegunaan penting pengendali ini:
1: Akses Pembolehubah atau Fungsi dalam Ruang Nama Berbeza
A ruang nama digunakan dalam C++ untuk mengumpulkan fungsi, kelas dan pembolehubah yang berkaitan untuk mengelakkan konflik penamaan. Apabila anda menentukan pembolehubah atau fungsi dalam a ruang nama , nama pembolehubah atau fungsi hanya kelihatan di dalamnya ruang nama .
Dalam C++, anda boleh menggunakan pengendali resolusi skop (::) bersama-sama dengan ruang nama nama dan nama pembolehubah atau fungsi untuk mengakses pembolehubah atau fungsi yang ditakrifkan dalam ruang nama yang berbeza. Ini membolehkan anda mengakses pembolehubah atau fungsi daripada a ruang nama selain daripada yang di dalamnya ia dicipta.
Untuk memahami kes di atas, pertimbangkan kod berikut sebagai contoh:
#includemenggunakan ruang nama std ;
matematik ruang nama {
const berganda PI = 3.14159 ;
berganda segi empat sama ( berganda x ) {
kembali x * x ;
}
}
int utama ( ) {
cout << 'Nilai PI ialah: ' << matematik :: PI << endl ;
cout << Kuasa dua bagi 5 ialah: << matematik :: segi empat sama ( 5 ) << endl ;
kembali 0 ;
}
Kod di atas menggunakan ruang nama matematik untuk mengakses “PI” malar dan “persegi” fungsi menggunakan pengendali resolusi skop '::' . Ia kemudian mencetak nilai ke konsol.
Pengeluaran
2: Akses Pembolehubah Global dalam Program
Apabila nama pembolehubah tempatan dan global yang sama terdapat dalam program, pembolehubah tempatan mungkin menyembunyikan pembolehubah global. Dalam situasi sedemikian, anda boleh menggunakan pengendali resolusi skop (::) untuk mengakses pembolehubah global. Operator ini membenarkan kami merujuk secara eksplisit kepada pembolehubah global berdasarkan skopnya.
Sebagai contoh, dalam kod yang diberikan di bawah, kami telah merujuk kepada pembolehubah global ‘a ‘melalui pengendali resolusi skop(::) , dari dalam fungsi di mana pembolehubah tempatan dengan nama yang sama telah ditakrifkan:
#includemenggunakan ruang nama std ;
int a = lima belas ;
int utama ( )
{
int a = 35 ;
cout << 'Nilai pembolehubah global a ialah ' << :: a << endl ;
cout << 'Nilai pembolehubah tempatan a ialah ' << a << endl ;
kembali 0 ;
}
Dalam kod di atas, pembolehubah a hadir di luar fungsi utama ialah pembolehubah global dan pembolehubah a dalam fungsi utama ialah pembolehubah tempatan dengan nama yang sama dengan pembolehubah global. Dalam pernyataan cout, kami telah menggunakan operator resolusi skop untuk mencetak pembolehubah global a .
Pengeluaran
3: Tentukan Fungsi Di Luar Kelas
Dalam C++, anda boleh menentukan fungsi kelas di luar definisi kelas dan ia boleh dilakukan menggunakan pengendali resolusi skop (::) untuk menentukan kelas mana fungsi itu dimiliki. Ini perlu kerana fungsi ditakrifkan di luar skop kelas.
Berikut ialah contoh kod yang menunjukkan penggunaan ini pengendali resolusi skop :
#includemenggunakan ruang nama std ;
kelas myClass {
awam :
batal fungsi saya ( ) ;
} ;
batal kelas saya :: fungsi saya ( ) {
cout << 'fungsi saya() Dipanggil!' ;
}
int utama ( )
{
myClass classObj ;
kelasObj. fungsi saya ( ) ;
kembali 0 ;
}
Dalam kod di atas, fungsi ahli myfunction() ditakrifkan di luar kelas menggunakan pengendali resolusi skop :: untuk menyatakan itu myfunction() tergolong dalam kelas myClass.
Pengeluaran
4: Akses Ahli Statik Kelas
Dalam C++, apabila terdapat ahli statik dan pembolehubah tempatan dengan nama yang sama terdapat dalam kelas, the pengendali resolusi skop (::) boleh digunakan untuk mengakses ahli statik kelas. Ini membolehkan program membezakan antara pembolehubah tempatan dan ahli statik.
Berikut ialah contoh kod yang mengaitkan penggunaan pengendali resolusi skop untuk kes sedemikian:
#includemenggunakan ruang nama std ;
kelas myClass {
awam :
statik int myStatVar ;
} ;
int kelas saya :: myStatVar = 5 ;
int utama ( ) {
int myStatVar = 10 ;
cout << 'Pembolehubah tempatan myStatVar: ' << myStatVar << endl ;
cout << 'Pembolehubah kelas myStatVar: ' << kelas saya :: myStatVar << endl ;
kembali 0 ;
}
Program di atas mula-mula mentakrifkan kelas kelas saya dengan pembolehubah ahli statik myStatVar . Ia kemudian mentakrifkan pembolehubah tempatan dengan nama yang sama di dalam fungsi utama program. Untuk mengakses pembolehubah kelas, the pengendali resolusi skop (::) digunakan dengan nama kelas kelas saya . Program ini mengeluarkan nilai kedua-dua pembolehubah kepada konsol.
Pengeluaran
5: Gunakan dengan Berbilang Warisan
The pengendali resolusi skop (::) juga digunakan untuk menunjukkan versi ahli yang hendak digunakan apabila kelas C++ diperoleh daripada berbilang kelas induk yang mempunyai pembolehubah atau fungsi ahli dengan nama yang sama. Kita boleh membezakan antara pelbagai versi ahli yang sama dengan menggunakan pengendali resolusi skop diikuti dengan nama kelas induk dan nama ahli.
#includemenggunakan ruang nama std ;
Ibu Bapa kelas1 {
awam :
batal cetak ( ) {
cout << 'Ini ialah fungsi cetakan kelas Parent1.' << endl ;
}
} ;
kelas Ibu bapa2 {
awam :
batal cetak ( ) {
cout << 'Ini ialah fungsi cetakan kelas Parent2.' << endl ;
}
} ;
kelas myClass : Ibu Bapa awam1 , Orang tua awam2 {
persendirian :
int pada satu ;
awam :
kelas saya ( int n ) {
pada satu = n ;
}
batal cetak ( ) {
Ibu bapa1 :: cetak ( ) ; // panggil fungsi cetakan Parent1
Ibu bapa2 :: cetak ( ) ; // panggil fungsi cetakan Parent2
cout << 'Nilai nombor ialah: ' << pada satu << endl ; // mencetak nilai num
}
} ;
int utama ( ) {
myClass obj ( 42 ) ; // buat objek MyClass dengan num dimulakan kepada 42
obj. cetak ( ) ; // panggil fungsi print() objek
kembali 0 ;
}
Program di atas menunjukkan penggunaan pengendali resolusi skop (::) untuk membezakan antara fungsi cetakan bagi Ibu bapa1 dan Ibu bapa2 apabila kedua-dua kelas diwarisi oleh kelas saya. Dengan memanggil fungsi dengan Kelas ibu bapa nama sebelum nama fungsi, kita boleh menentukan versi fungsi yang hendak digunakan.
Pengeluaran
Pokoknya
The pengendali resolusi skop (::) ialah komponen penting dalam C++ yang digunakan untuk mengakses nama pembolehubah merentas tahap skop yang berbeza. Pengendali mempunyai pelbagai kegunaan, termasuk mengakses pembolehubah atau fungsi dalam ruang nama yang berbeza, mengakses pembolehubah global, mentakrifkan fungsi di luar kelas, mengakses ahli statik kelas dan menggunakan berbilang warisan. Walaupun ia boleh mengelirukan bagi pembangun baharu, memahami pengendali resolusi skop (::) adalah penting untuk amalan pengaturcaraan yang baik.