Kandungan Artikel
- Wilayah dan Skop Deklaratif
- Skop Global
- Skop Blok
- Skop Fungsi
- Skop Penghitungan
- Skop Kelas
- Skop Parameter Templat
- Menyembunyikan Nama
- Kemungkinan untuk Mengulangi Deklarasi dalam Skop yang Sama
- Skop Ruang Nama
- Skop dalam Bahagian Berbeza
- Kesimpulannya
Wilayah dan Skop Deklaratif
Kawasan deklaratif adalah bahagian terbesar dari teks program di mana nama entiti adalah sah. Ini adalah wilayah di mana nama yang tidak memenuhi syarat dapat digunakan (dilihat) untuk merujuk kepada entiti yang sama. Pertimbangkan program pendek berikut:
#sertakan
menggunakan ruang namaJam;
batalfn()
{
intdi mana= 3;
sekiranya (1==1)
{
kos<<di mana<<' n';
}
}
intutama()
{
fn();
kembali 0;
}
Fungsi fn () mempunyai dua blok: blok dalaman untuk keadaan if dan blok luar untuk badan fungsi. Pengecam, var, diperkenalkan dan dilihat di blok luar. Ia juga dilihat di blok dalam, dengan pernyataan cout. Blok luar dan dalam adalah ruang lingkup nama, var.
Walau bagaimanapun, nama, var, masih boleh digunakan untuk menyatakan entiti yang berbeza seperti pelampung di blok dalam. Kod berikut menggambarkan ini:
#sertakan
menggunakan ruang namaJam;
batalfn()
{
intdi mana= 3;
sekiranya (1==1)
{
terapungdi mana= 7.5;
kos<<di mana<<' n';
}
}
intutama()
{
fn();
kembali 0;
}
Keluarannya ialah 7.5. Dalam hal ini, nama, var, tidak lagi dapat digunakan di blok dalam untuk merujuk pada bilangan bulat nilai 3, yang diperkenalkan (dinyatakan) di blok luar. Blok dalaman tersebut disebut sebagai ruang lingkup berpotensi untuk entiti yang dinyatakan di blok luar.
Catatan: Entiti jenis yang sama, seperti blok luar, masih boleh dinyatakan dalam blok dalaman. Namun, dalam kes ini, apa yang berlaku di blok dalam adalah deklarasi baru dan maknanya, sementara deklarasi lama dan maknanya di luar blok dalaman tetap berlaku di blok luar.
Pengisytiharan nama yang sama dalam blok dalaman biasanya mengatasi pengisytiharan nama yang sama di luar blok dalaman itu. Blok dalaman boleh bersarang blok dalaman yang lain.
Skop Global
Apabila pengaturcara mula menaip fail, itu adalah skop global. Program pendek berikut menggambarkan ini:
#sertakanmenggunakan ruang namaJam;
terapungdi mana= 9.4;
intutama()
{
kos <<di mana<<' n';
kos <<::di mana<<' n';
kembali 0;
}
Keluarannya adalah:
9.4
9.4
Dalam kes ini, wilayah deklarasi atau ruang lingkup untuk var bermula dari titik deklarasi untuk var, terus ke bawah hingga akhir fail (unit terjemahan).
Blok fungsi utama () adalah skop yang berbeza; ia adalah ruang bersarang untuk skop global. Untuk mengakses entiti skop global, dari skop yang berbeza, pengenal digunakan secara langsung atau didahului oleh operator resolusi skop, ::.
Catatan: Entiti, utama (), juga dinyatakan dalam skop global.
Skop Blok
Pernyataan if, while, do, for, atau switch masing-masing dapat menentukan blok. Pernyataan seperti itu adalah pernyataan majmuk. Nama pemboleh ubah yang dinyatakan dalam blok mempunyai ruang lingkup blok. Skopnya bermula pada titik pengisytiharannya dan berakhir di hujung bloknya. Program pendek berikut menggambarkan ini untuk pemboleh ubah, ident:
#sertakanmenggunakan ruang namaJam;
intutama()
{
sekiranya (1==1)
{
/ * beberapa kenyataan * /
intident= 5;
kos<<ident<<' n';
/ * beberapa kenyataan * /
}
kembali 0;
}
Pemboleh ubah, seperti ident, dinyatakan pada ruang lingkup blok adalah pemboleh ubah tempatan.
Pemboleh ubah yang dinyatakan di luar ruang lingkup blok dan di atasnya dapat dilihat pada tajuk blok (mis., Syarat untuk if-block) dan juga di dalam blok. Program pendek berikut menggambarkan ini untuk pemboleh ubah, identif:
#sertakanmenggunakan ruang namaJam;
intutama()
{
intmengenal pasti= 8;
sekiranya (mengenal pasti== 8)
{
kos<<mengenal pasti<<' n';
}
kembali 0;
}
Outputnya adalah 8. Terdapat dua ruang lingkup blok di sini: blok untuk fungsi utama () dan penyataan if-compound bersarang. Blok bersarang adalah ruang lingkup potensi blok fungsi utama ().
Deklarasi yang diperkenalkan dalam ruang lingkup blok tidak dapat dilihat di luar blok. Program pendek berikut, yang tidak menyusun, menggambarkan ini dengan pemboleh ubah, pemboleh ubah:
#sertakanmenggunakan ruang namaJam;
intutama()
{
sekiranya (1 == 1)
{
intvariab= lima belas;
}
kos<<variab<<' n'; // ralat: diakses di luar skopnya.
kembali 0;
}
Penyusun menghasilkan mesej ralat untuk pemboleh ubah.
Entiti yang diperkenalkan, dinyatakan dalam tajuk fungsi gabungan, tidak dapat dilihat di luar (di bawah) pernyataan kompaun. Kod untuk gelung berikut tidak akan disusun, menghasilkan mesej ralat:
#sertakanmenggunakan ruang namaJam;
intutama()
{
untuk (inti=0;i<4; ++i)
{
kos<<i<<'';
}
kos<<i<<'';
kembali 0;
}
Pemboleh ubah iterasi, i, dilihat di dalam blok untuk gelung tetapi tidak di luar blok untuk gelung.
Skop Fungsi
Parameter fungsi dilihat pada blok fungsi. Entiti yang dinyatakan dalam blok fungsi dilihat dari sudut deklarasi hingga akhir blok fungsi. Program pendek berikut menggambarkan ini:
#sertakan#sertakan
menggunakan ruang namaJam;
tali fn(tali tali)
{
charberusaha[] = 'pisang';
/ * pernyataan lain * /
rentetan totalStr=hlm+berusaha;
kembalitotalStr;
}
intutama()
{
tali totStr=fn('makan');
kos<<totStr<<' n';
kembali 0;
}
Keluarannya adalah:
makan pisang
Catatan: Entiti yang dinyatakan di luar fungsi (di atasnya) dapat dilihat dalam daftar parameter fungsi dan juga di blok fungsi.
Label
Skop label adalah fungsi di mana ia muncul. Kod berikut menggambarkan ini:
#sertakanmenggunakan ruang namaJam;
batalfn()
{
pergi kelabl;
/ * pernyataan lain * /
labl: inttidak= 2;
kos<<tidak<<' n';
}
intutama()
{
fn();
kembali 0;
}
Keluarannya adalah 2.
Skop Penghitungan
Penghitungan Tidak Terkawal
Pertimbangkan if-block berikut:
{
enum {a, b, c=b+2};
kos<<ke<<''<<b<<''<<c<<' n';
}
Keluarannya adalah 0 1 3.
Baris pertama dalam blok adalah penghitungan, a, b, dan c adalah penghitungnya. Skop pembilang bermula dari titik perisytiharan hingga akhir blok enumerasi.
Pernyataan berikut tidak akan disusun kerana titik pengisytiharan c adalah selepas dari:
enum {ke=c+2, b, c};Segmen kod berikut tidak akan disusun kerana penghitung diakses setelah blok enumerasi yang dilampirkan:
sekiranya (1==1){
enum {a, b, c=b+2};
}
kos<<ke<<''<<b<<''<<c<<' n'; // ralat: di luar ruang lingkup
Penghitungan di atas digambarkan sebagai penghitung yang tidak dipotong, dan penghitungnya digambarkan sebagai penghitung yang tidak dipotong. Ini kerana ia bermula hanya dengan kata kunci, enum. Penghitungan yang dimulai dengan kelas enum atau enum struct digambarkan sebagai penghitungan skop. Pencacah mereka digambarkan sebagai pencacah skop.
Penghitungan Skop
Penyataan berikut adalah OK:
Ini adalah contoh penghitungan skop. Nama kelas adalah nam. Di sini, ruang lingkup pencacah bermula dari titik pengisytiharan hingga akhir definisi penghitungan, dan bukan akhir blok pelampir untuk penghitungan. Kod berikut tidak akan menyusun:
sekiranya (1==1){
enum kelaslelaki{a, b, c=b+2};
kos<<ke<<''<<b<<''<<c<<' n'; // ralat: di luar ruang untuk kelas enum atau enum struct
}
Skop Kelas
Dengan scoping normal, wilayah deklaratif bermula dari satu titik, kemudian berlanjutan dan berhenti pada titik yang berbeza. Skop wujud di satu wilayah berterusan. Dengan kelas, ruang lingkup entiti boleh berada di kawasan yang berbeza yang tidak digabungkan. Peraturan untuk blok bersarang masih terpakai. Program berikut menggambarkan ini:
#sertakanmenggunakan ruang namaJam;
// Kelas asas
kelasCla
{
peribadi:
intmemP= 5;
dilindungi:
intmemPro= 9;
awam:
batalfn()
{
kos<<memP<<' n';
}
};
// Kelas Berasal
kelasDerCla: awamCla
{
awam:
intderMem=memPro;
};
intutama()
{
Cla obj;
objfn();
DerCla derObj;
kos<<derObj.derMem<<' n';
kembali 0;
}
Keluarannya adalah:
5
9
Di kelas Cla, memP pemboleh ubah, dilihat pada titik pengisytiharan. Selepas itu, bahagian pendek dilindungi dilangkau, kemudian dilihat lagi di blok fungsi anggota kelas. Kelas yang diturunkan dilangkau, kemudian dilihat semula pada skop fungsi () utama (blok).
Di kelas Cla, pemboleh ubah memPro, dilihat pada titik pengisytiharan. Bahagian fungsi awam fn () dilangkau, kemudian dilihat di blok keterangan kelas yang berasal. Ia dilihat lagi turun dalam fungsi utama ().
Pengendali Penyelesaian Skop
Pengendali resolusi skop di C ++ adalah ::. Ia digunakan untuk mengakses ahli kelas yang statik. Program berikut menggambarkan ini:
menggunakan ruang namaJam;
kelasCla
{
awam:
statik int penyambungmeme= 5;
awam:
statik batalfn()
{
kos<<meme<<' n';
}
};
intutama()
{
kos<<Cla::meme<<' n';
Cla::fn();
kembali 0;
}
Keluarannya adalah:
5
5
Anggota statik dilihat di blok fungsi utama (), diakses menggunakan operator resolusi skop.
Skop Parameter Templat
Skop normal nama parameter templat bermula dari titik deklarasi hingga akhir bloknya, seperti dalam kod berikut:
templat<nama taipT,nama taipU> strukturUmur{
T John= sebelas;
Anda Peter= 12.3;
T Mary= 13;
U Joy= 14.6;
};
U dan T dilihat di dalam blok.
Untuk prototaip fungsi templat, skop bermula dari titik deklarasi hingga akhir senarai parameter fungsi, seperti dalam pernyataan berikut:
templat<nama taipT,nama taipU> batalfungsi(Anda tidak, u cha,penyambung char *hlm);Walau bagaimanapun, ketika datang ke deskripsi kelas (definisi), ruang lingkupnya juga boleh menjadi bahagian yang berbeza seperti dalam kod berikut:
#sertakanmenggunakan ruang namaJam;
templat<kelasT,kelasU> kelasTheCla
{
awam:
t num;
statikU ch;
batalfungsi(Bapa,penyambung char *hlm)
{
kos << 'Disana ada ' <<pada satu<< 'buku bernilai' <<tidak<<hlm<< 'di kedai.' << ' n';
}
statik batalseronok(U ch)
{
sekiranya (ch== 'ke')
kos << 'Fungsi anggota statik rasmi' << ' n';
}
};
intutama()
{
TheCla<int,char>obj;
objpada satu = 12;
objfungsi('$','500');
kembali 0;
}
Menyembunyikan Nama
Contoh penyembunyian nama berlaku apabila nama jenis objek yang sama dinyatakan semula dalam blok bersarang. Program berikut menggambarkan ini:
#sertakanmenggunakan ruang namaJam;
batalfn()
{
intdi mana= 3;
sekiranya (1==1)
{
intdi mana= 4;
kos<<di mana<<' n';
}
kos<<di mana<<' n';
}
intutama()
{
fn();
kembali 0;
}
Keluarannya adalah:
4
3
Ini kerana var di blok bersarang menyembunyikan var di blok luar.
Kemungkinan untuk Mengulangi Deklarasi dalam Skop yang Sama
Titik deklarasi adalah di mana nama diperkenalkan (untuk pertama kalinya) dalam skopnya.
Prototaip Fungsi
Entiti yang berbeza, walaupun dari pelbagai jenis, biasanya tidak dapat dinyatakan dalam ruang lingkup yang sama. Namun, prototaip fungsi dapat dinyatakan lebih dari sekali dalam ruang lingkup yang sama. Program berikut dengan dua prototaip fungsi dan definisi fungsi yang sesuai menggambarkan ini:
menggunakan ruang namaJam;
batalfn(intpada satu);
batalfn(intpada satu);
batalfn(intpada satu)
{
kos<<pada satu<<' n';
}
intutama()
{
fn(5);
kembali 0;
}
Program ini berjaya.
Fungsi yang terlalu banyak
Fungsi yang terlalu banyak adalah fungsi dengan nama yang sama tetapi tandatangan fungsi yang berbeza. Sebagai pengecualian lain, fungsi yang terlalu banyak dengan nama yang sama dapat ditentukan dalam ruang lingkup yang sama. Program berikut menggambarkan ini:
menggunakan ruang namaJam;
batalfn(intpada satu)
{
kos<<pada satu<<' n';
}
batalfn(terapungtidak)
{
kos<<tidak<<' n';
}
intutama()
{
fn(5);
terapungflt= 8.7;
fn(flt);
kembali 0;
}
Keluarannya adalah:
5
8.7
Fungsi yang terlalu banyak telah ditentukan dalam ruang lingkup global.
Skop Ruang Nama
Namespace Scope layak mendapat artikelnya sendiri. Artikel tersebut telah ditulis untuk laman web ini, linuxhint.com. Cukup ketik kata carian Namespace Scope di kotak carian laman web ini (halaman) dan klik OK, dan anda akan mendapat artikelnya.
Skop dalam Bahagian Berbeza
Kelas bukan satu-satunya skema di mana ruang lingkup boleh berada dalam bahagian yang berbeza. Penentu rakan, penggunaan tertentu dari penentu jenis terperinci, dan arahan penggunaan adalah skema lain di mana ruang lingkupnya berada di tempat yang berbeza - untuk perinciannya, lihat kemudian.
Kesimpulannya
Skop adalah wilayah deklaratif. Kawasan deklaratif adalah bahagian terbesar dari teks program di mana nama entiti adalah sah. Ia dapat dibagi menjadi lebih dari satu bahagian sesuai dengan skema pengaturcaraan tertentu, seperti blok bersarang. Bahagian yang tidak mempunyai titik deklarasi membentuk ruang lingkup yang berpotensi. Skop yang berpotensi mungkin atau tidak mempunyai deklarasi.