Isi Artikel
- Wilayah dan Cakupan Deklaratif
- Lingkup Global
- Lingkup Blok
- Lingkup Fungsi
- Lingkup Pencacahan
- Lingkup Kelas
- Cakupan Parameter Template
- Menyembunyikan Nama
- Kemungkinan untuk Mengulang Deklarasi dalam Lingkup yang Sama
- Lingkup Namespace
- Cakupan dalam Porsi Berbeda
- Kesimpulan
Wilayah dan Cakupan Deklaratif
Wilayah deklaratif adalah bagian terbesar dari teks program di mana nama entitas valid. Ini adalah wilayah di mana nama yang tidak memenuhi syarat dapat digunakan (dilihat) untuk merujuk ke entitas yang sama. Perhatikan program singkat berikut:
#termasuk
menggunakan ruang namajam;
ruang kosongfn()
{
ke dalamdi mana= 3;
jika (1==1)
{
biaya<<di mana<<' ';
}
}
ke dalamutama()
{
fn();
kembali 0;
}
Fungsi fn() memiliki dua blok: blok dalam untuk kondisi if dan blok luar untuk badan fungsi. Pengidentifikasi, var, diperkenalkan dan terlihat di blok luar. Itu juga terlihat di blok bagian dalam, dengan pernyataan cout. Blok luar dan dalam keduanya merupakan ruang lingkup untuk nama, var.
Namun, nama, var, masih dapat digunakan untuk mendeklarasikan entitas yang berbeda seperti float di blok bagian dalam. Kode berikut menggambarkan hal ini:
#termasuk
menggunakan ruang namajam;
ruang kosongfn()
{
ke dalamdi mana= 3;
jika (1==1)
{
mengambangdi mana= 7.5;
biaya<<di mana<<' ';
}
}
ke dalamutama()
{
fn();
kembali 0;
}
Keluarannya adalah 7,5. Dalam hal ini, nama, var, tidak dapat lagi digunakan di blok dalam untuk merujuk ke bilangan bulat dari nilai 3, yang diperkenalkan (dideklarasikan) di blok luar. Blok dalam seperti itu disebut sebagai ruang lingkup potensial untuk entitas yang dideklarasikan di blok luar.
Catatan: Entitas dengan tipe yang sama, seperti blok luar, masih dapat dideklarasikan di blok dalam. Namun dalam hal ini yang valid pada inner block adalah deklarasi baru beserta artinya, sedangkan deklarasi lama dan artinya di luar inner block tetap berlaku pada outer block.
Deklarasi dengan nama yang sama di dalam blok dalam biasanya mengesampingkan deklarasi dengan nama yang sama di luar blok dalam tersebut. Blok bagian dalam dapat membuat sarang blok bagian dalam lainnya.
Lingkup Global
Ketika seorang programmer baru mulai mengetik file, itu adalah lingkup global. Program singkat berikut mengilustrasikan hal ini:
#termasukmenggunakan ruang namajam;
mengambangdi mana= 9.4;
ke dalamutama()
{
biaya <<di mana<<' ';
biaya <<::di mana<<' ';
kembali 0;
}
Outputnya adalah:
9.4
9.4
Dalam hal ini, wilayah atau ruang lingkup deklaratif untuk var dimulai dari titik deklarasi untuk var, berlanjut ke bawah hingga akhir file (unit terjemahan).
Blok fungsi main() adalah lingkup yang berbeda; itu adalah lingkup bersarang untuk lingkup global. Untuk mengakses entitas lingkup global, dari lingkup yang berbeda, pengidentifikasi digunakan secara langsung atau didahului oleh operator resolusi lingkup, :: .
Catatan: Entitas, main(), juga dideklarasikan dalam lingkup global.
Lingkup Blok
Pernyataan if, while, do, for, atau switch masing-masing dapat mendefinisikan sebuah blok. Pernyataan seperti itu adalah pernyataan majemuk. Nama variabel yang dideklarasikan dalam sebuah blok memiliki cakupan blok. Ruang lingkupnya dimulai pada titik deklarasi dan berakhir pada akhir bloknya. Program singkat berikut mengilustrasikan ini untuk variabel, ident:
#termasukmenggunakan ruang namajam;
ke dalamutama()
{
jika (1==1)
{
/*beberapa pernyataan*/
ke dalamidentitas= 5;
biaya<<identitas<<' ';
/*beberapa pernyataan*/
}
kembali 0;
}
Sebuah variabel, seperti ident, dideklarasikan pada lingkup blok adalah variabel lokal.
Variabel yang dideklarasikan di luar cakupan blok dan di atasnya dapat dilihat di header blok (misalnya, kondisi untuk blok if) dan juga di dalam blok. Program singkat berikut mengilustrasikan hal ini untuk variabel, identif:
#termasukmenggunakan ruang namajam;
ke dalamutama()
{
ke dalampengenal= 8;
jika (pengenal== 8)
{
biaya<<pengenal<<' ';
}
kembali 0;
}
Outputnya adalah 8. Ada dua cakupan blok di sini: blok untuk fungsi main() dan pernyataan if-compound bersarang. Blok bersarang adalah cakupan potensial dari blok fungsi main().
Deklarasi yang diperkenalkan dalam lingkup blok tidak dapat dilihat di luar blok. Program singkat berikut, yang tidak dikompilasi, menggambarkan hal ini dengan variabel, variab:
#termasukmenggunakan ruang namajam;
ke dalamutama()
{
jika (1 == 1)
{
ke dalamvariasi= limabelas;
}
biaya<<variasi<<' '; //error: diakses di luar cakupannya.
kembali 0;
}
Kompiler menghasilkan pesan kesalahan untuk variab.
Entitas yang diperkenalkan, dideklarasikan di header fungsi majemuk, tidak dapat dilihat di luar (di bawah) pernyataan majemuk. Kode for-loop berikut tidak akan dikompilasi, menghasilkan pesan kesalahan:
#termasukmenggunakan ruang namajam;
ke dalamutama()
{
untuk (ke dalamSaya=0;Saya<4; ++Saya)
{
biaya<<Saya<<'';
}
biaya<<Saya<<'';
kembali 0;
}
Variabel iterasi, i, terlihat di dalam blok for-loop tetapi tidak di luar blok for-loop.
Lingkup Fungsi
Parameter fungsi terlihat di blok fungsi. Entitas yang dideklarasikan dalam blok fungsi dilihat dari titik deklarasi hingga akhir blok fungsi. Program singkat berikut mengilustrasikan hal ini:
#termasuk#termasuk
menggunakan ruang namajam;
string fn(string str)
{
arangstri[] = 'pisang';
/*pernyataan lain*/
string totalStr=P+stri;
kembalitotalStr;
}
ke dalamutama()
{
string totStr=fn('makan ');
biaya<<totStr<<' ';
kembali 0;
}
Outputnya adalah:
makan pisang
Catatan: Entitas yang dideklarasikan di luar fungsi (di atasnya) dapat dilihat di daftar parameter fungsi dan juga di blok fungsi.
Label
Ruang lingkup label adalah fungsi di mana label itu muncul. Kode berikut menggambarkan hal ini:
#termasukmenggunakan ruang namajam;
ruang kosongfn()
{
pergi kelabl;
/*pernyataan lain*/
labl: ke dalambukan= 2;
biaya<<bukan<<' ';
}
ke dalamutama()
{
fn();
kembali 0;
}
Keluarannya adalah 2.
Lingkup Pencacahan
Pencacahan Tanpa Cakupan
Pertimbangkan blok if berikut:
{
enum {a, b, c=B+2};
biaya<<ke<<''<<B<<''<<C<<' ';
}
Keluarannya adalah 0 1 3.
Baris pertama dalam blok adalah pencacah, a, b, dan c adalah pencacahnya. Ruang lingkup pencacahan dimulai dari titik deklarasi sampai akhir blok penutup pencacahan.
Pernyataan berikut tidak akan dikompilasi karena titik deklarasi c adalah setelah a:
enum {ke=C+2, b, c};Segmen kode berikut tidak akan dikompilasi karena enumerator diakses setelah blok enumerasi terlampir:
jika (1==1){
enum {a, b, c=B+2};
}
biaya<<ke<<''<<B<<''<<C<<' '; //kesalahan: di luar jangkauan
Pencacahan di atas disebut pencacahan tak tercakup, dan pencacahnya disebut pencacah tak tercakup. Ini karena ini hanya dimulai dengan kata cadangan, enum. Enumerasi yang dimulai dengan enum class atau enum struct digambarkan sebagai enumerasi tercakup. Pencacah mereka digambarkan sebagai pencacah tercakup.
Cakupan enumerasi
Pernyataan berikut ini OK:
Ini adalah contoh enumerasi tercakup. Nama kelasnya adalah nam. Di sini, ruang lingkup pencacah dimulai dari titik deklarasi hingga akhir definisi pencacahan, dan bukan akhir blok penutup pencacahan. Kode berikut tidak akan dikompilasi:
jika (1==1){
enum kelaspria{a, b, c=B+2};
biaya<<ke<<''<<B<<''<<C<<' '; //error: di luar ruang lingkup untuk kelas enum atau struktur enum
}
Lingkup Kelas
Dengan pelingkupan normal, wilayah deklaratif dimulai dari suatu titik, kemudian berlanjut dan berhenti di titik yang berbeda. Ruang lingkup ada di satu wilayah kontinu. Dengan kelas, ruang lingkup suatu entitas dapat berada di wilayah berbeda yang tidak digabungkan. Aturan untuk blok bersarang masih berlaku. Program berikut menggambarkan hal ini:
#termasukmenggunakan ruang namajam;
//kelas dasar
kelasKla
{
pribadi:
ke dalammemP= 5;
terlindung:
ke dalammemPro= 9;
publik:
ruang kosongfn()
{
biaya<<memP<<' ';
}
};
//Kelas Turunan
kelasDerCla: publikKla
{
publik:
ke dalamderMem=memPro;
};
ke dalamutama()
{
Cla obj;
obj.fn();
DerCla derObj;
biaya<<derObj.derMem<<' ';
kembali 0;
}
Outputnya adalah:
5
9
Di kelas Cla, variabel memP, terlihat pada titik deklarasi. Setelah itu, bagian pendek dari protected dilewati, kemudian terlihat lagi di blok fungsi anggota kelas. Kelas turunan dilewati, lalu terlihat lagi di lingkup fungsi main() (blok).
Di kelas Cla, variabel memPro, terlihat pada titik deklarasi. Bagian dari fungsi publik fn() dilewati, kemudian terlihat di blok deskripsi kelas turunan. Itu terlihat lagi di fungsi main().
Operator Resolusi Lingkup
Operator resolusi ruang lingkup di C++ adalah :: . Ini digunakan untuk mengakses anggota statis kelas. Program berikut menggambarkan hal ini:
menggunakan ruang namajam;
kelasKla
{
publik:
statis ke dalam konstanmeme= 5;
publik:
statis ruang kosongfn()
{
biaya<<meme<<' ';
}
};
ke dalamutama()
{
biaya<<Kla::meme<<' ';
Kla::fn();
kembali 0;
}
Outputnya adalah:
5
5
Anggota statis terlihat di blok fungsi main(), diakses menggunakan operator resolusi lingkup.
Cakupan Parameter Template
Lingkup normal nama parameter template dimulai dari titik deklarasi hingga akhir bloknya, seperti pada kode berikut:
templat<ketik namaT,ketik namakamu> strukturusia{
T John= sebelas;
Anda Peter= 12.3;
T Mary= 13;
U Joy= 14.6;
};
U dan T terlihat di dalam blok.
Untuk prototipe fungsi template, cakupannya dimulai dari titik deklarasi hingga akhir daftar parameter fungsi, seperti pada pernyataan berikut:
templat<ketik namaT,ketik namakamu> ruang kosongfungsi(Anda tidak, Anda cha,konstan arang *P);Namun, ketika datang ke deskripsi kelas (definisi), ruang lingkup juga dapat menjadi bagian yang berbeda seperti pada kode berikut:
#termasukmenggunakan ruang namajam;
templat<kelasT,kelaskamu> kelasTheCla
{
publik:
t angka;
statisU ch;
ruang kosongfungsi(Ayah,konstan arang *P)
{
biaya << 'Ada ' <<pada satu<< 'buku berharga' <<tidak<<P<< ' di dalam toko.' << ' ';
}
statis ruang kosongseru(U ch)
{
jika (ch== 'ke')
biaya << 'Fungsi anggota statis resmi' << ' ';
}
};
ke dalamutama()
{
TheCla<ke dalam,arang>obj;
obj.pada satu = 12;
obj.fungsi('$','500');
kembali 0;
}
Menyembunyikan Nama
Contoh penyembunyian nama terjadi ketika nama dari tipe objek yang sama dideklarasikan ulang dalam blok bersarang. Program berikut menggambarkan hal ini:
#termasukmenggunakan ruang namajam;
ruang kosongfn()
{
ke dalamdi mana= 3;
jika (1==1)
{
ke dalamdi mana= 4;
biaya<<di mana<<' ';
}
biaya<<di mana<<' ';
}
ke dalamutama()
{
fn();
kembali 0;
}
Outputnya adalah:
4
3
Itu karena var di blok bersarang menyembunyikan var di blok luar.
Kemungkinan untuk Mengulang Deklarasi dalam Lingkup yang Sama
Inti dari deklarasi adalah di mana nama itu diperkenalkan (untuk pertama kalinya) dalam ruang lingkupnya.
Fungsi Prototipe
Entitas yang berbeda, bahkan dari tipe yang berbeda, biasanya tidak dapat dideklarasikan dalam lingkup yang sama. Namun, prototipe fungsi dapat dideklarasikan lebih dari satu kali dalam lingkup yang sama. Program berikut dengan dua prototipe fungsi dan definisi fungsi yang sesuai menggambarkan hal ini:
menggunakan ruang namajam;
ruang kosongfn(ke dalampada satu);
ruang kosongfn(ke dalampada satu);
ruang kosongfn(ke dalampada satu)
{
biaya<<pada satu<<' ';
}
ke dalamutama()
{
fn(5);
kembali 0;
}
Program ini bekerja.
Fungsi kelebihan beban
Fungsi yang kelebihan beban adalah fungsi dengan nama yang sama tetapi tanda tangan fungsi yang berbeda. Sebagai pengecualian lain, fungsi kelebihan beban dengan nama yang sama dapat didefinisikan dalam lingkup yang sama. Program berikut menggambarkan hal ini:
menggunakan ruang namajam;
ruang kosongfn(ke dalampada satu)
{
biaya<<pada satu<<' ';
}
ruang kosongfn(mengambangtidak)
{
biaya<<tidak<<' ';
}
ke dalamutama()
{
fn(5);
mengambangflt= 8.7;
fn(flt);
kembali 0;
}
Outputnya adalah:
5
8.7
Fungsi kelebihan beban telah didefinisikan dalam lingkup global.
Lingkup Namespace
Namespace Scope layak mendapatkan artikelnya sendiri. Artikel tersebut telah ditulis untuk situs web ini, linuxhint.com. Cukup ketik kata pencarian Namespace Scope di kotak pencarian situs ini (halaman) dan klik OK, dan Anda akan mendapatkan artikelnya.
Cakupan dalam Porsi Berbeda
Kelas bukan satu-satunya skema di mana ruang lingkup dapat berada di bagian yang berbeda. Penentu teman, penggunaan tertentu dari penentu tipe yang diuraikan, dan arahan penggunaan adalah skema lain di mana ruang lingkupnya berada di tempat yang berbeda – untuk detailnya, lihat nanti.
Kesimpulan
Ruang lingkup adalah wilayah deklaratif. Wilayah deklaratif adalah bagian terbesar dari teks program di mana nama entitas valid. Itu dapat dibagi menjadi lebih dari satu bagian sesuai dengan skema pemrograman tertentu, seperti blok bersarang. Bagian yang tidak memiliki titik deklarasi membentuk ruang lingkup potensial. Cakupan potensial mungkin atau mungkin tidak memiliki deklarasi.