Cakupan dalam C++

Entitas dalam C++ memiliki nama, yang dapat dideklarasikan dan/atau didefinisikan. Deklarasi adalah definisi, tetapi definisi belum tentu deklarasi. Definisi mengalokasikan memori untuk entitas bernama, tetapi deklarasi mungkin atau mungkin tidak mengalokasikan memori untuk entitas bernama. Wilayah deklaratif adalah bagian terbesar dari sebuah program di mana nama entitas (variabel) valid. Wilayah itu disebut ruang lingkup atau ruang lingkup potensial. Artikel ini menjelaskan pelingkupan dalam C++. Selanjutnya, pengetahuan dasar dalam C++ diperlukan untuk memahami artikel ini.

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 Different
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 (terlihat) untuk merujuk ke entitas yang sama. Perhatikan program singkat berikut:

#termasuk
menggunakan namespace std;
batal fn()

int var = 3;
jika (1==1)

cout<

int utama()

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 dalam, dengan pernyataan coutout. 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 namespace std;
batal fn()

int var = 3;
jika (1==1)

float var = 7.5;
cout<

int utama()

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 outer.

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 blok bagian dalam biasanya mengesampingkan deklarasi dengan nama yang sama di luar blok bagian dalam itu. Blok bagian dalam dapat membuat sarang blok bagian dalam lainnya.

Lingkup Global

Ketika seorang programmer baru saja mulai mengetik file, itu adalah lingkup global. Program singkat berikut mengilustrasikan hal ini:

#termasuk
menggunakan namespace std;
float var = 9.4;
int utama()

cout <cout <<::var<<'\n';
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 block. Ruang lingkupnya dimulai pada titik deklarasi dan berakhir pada akhir bloknya. Program singkat berikut mengilustrasikan ini untuk variabel, ident:

#termasuk
menggunakan namespace std;
int utama()

jika (1==1)

/*beberapa pernyataan*/
int identitas = 5;
cout</*beberapa pernyataan*/

kembali 0;

Variabel, seperti ident, yang dideklarasikan pada cakupan blok adalah variabel lokal.

Variabel yang dideklarasikan di luar cakupan blok dan di atasnya dapat dilihat di header blok (mis.g., kondisi untuk blok if) dan juga di dalam blok. Program singkat berikut mengilustrasikan hal ini untuk variabel, identif:

#termasuk
menggunakan namespace std;
int utama()

int pengenal = 8;
jika (identif == 8)

cout<
kembali 0;

Outputnya adalah 8. Ada dua cakupan blok di sini: blok untuk fungsi main() dan pernyataan if-compound bersarang. Blok bersarang adalah ruang lingkup 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:

#termasuk
menggunakan namespace std;
int utama()

jika (1 == 1)

int variabel = 15;

cout<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:

#termasuk
menggunakan namespace std;
int utama()

untuk (int i=0; i<4; ++i)

cout<
cout<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 namespace std;
string fn (string str)

char stri[] = "pisang";
/*pernyataan lain*/
string totalStr = str + stri;
kembalikan totalStr;

int utama()

string totStr = fn("makan");
cout<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 ia muncul. Kode berikut menggambarkan hal ini:

#termasuk
menggunakan namespace std;
batal fn()

goto labl;
/*pernyataan lain*/
labl: int inte = 2;
cout<
int utama()

fn();
kembali 0;

Keluarannya adalah 2.

Lingkup Pencacahan

Pencacahan Tanpa Cakupan
Pertimbangkan blok if berikut:

jika (1==1)

enum a, b, c=b+2;
cout<

Outputnya 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 a=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;

cout<Pencacahan di atas disebut pencacahan tak tercakup, dan pencacahnya disebut pencacah tak tercakup. Ini karena ini hanya dimulai dengan kata yang dicadangkan, 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:

enum nama kelas a, b, c=b+2;

Ini adalah contoh enumerasi cakupan. Nama kelasnya adalah nam. Di sini, ruang lingkup pencacah dimulai dari titik deklarasi sampai akhir definisi pencacahan, dan bukan akhir blok penutup pencacahan. Kode berikut tidak akan dikompilasi:

jika (1==1)

enum nama kelas a, b, c=b+2;
cout<

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 berkelanjutan continuous. 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:

#termasuk
menggunakan namespace std;
//kelas dasar
kelas Cla

pribadi:
int memP = 5;
terlindung:
int memPro = 9;
publik:
batal fn()

cout<
;
//Kelas Turunan
kelas DerCla: Cla publik

publik:
int derMem = memPro;
;
int utama()

Kla obj;
obj.fn();
DerCla derObj;
cout<kembali 0;

Outputnya adalah:
5
9

Di kelas Cla, variabel memP, terlihat pada titik deklarasi. Setelah itu, bagian pendek dari "dilindungi" dilewati, lalu terlihat lagi di blok fungsi anggota kelas. Kelas turunan dilewati, lalu terlihat lagi di ruang 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:

#termasuk
menggunakan namespace std;
kelas Cla

publik:
static int const mem = 5;
publik:
fn kosong statis ()

cout<
;
int utama()

cout<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 usia struktur

T Yohanes = 11;
U Petrus = 12.3;
T Maria = 13;
U Sukacita = 14.6;
;

U dan T terlihat di dalam balok.

Untuk prototipe fungsi template, cakupannya dimulai dari titik deklarasi hingga akhir daftar parameter fungsi, seperti pada pernyataan berikut:

templat void func (T tidak, U cha, const char *str );

Namun, ketika datang ke deskripsi kelas (definisi), ruang lingkup juga dapat menjadi bagian yang berbeda seperti pada kode berikut:

#termasuk
menggunakan namespace std;
templat kelas TheCla

publik:
T nomor;
statis U ch;
void func (U cha, const char *str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

kesenangan kekosongan statis (U ch)

jika (ch == 'a')
cout << "Official static member function" << '\n';

;
int utama()

TheCla obj;
obj.jumlah = 12;
obj.func('$', "500");
kembali 0;

Menyembunyikan Nama

Contoh penyembunyian nama terjadi ketika nama dari tipe objek yang sama dideklarasikan ulang di blok bersarang. Program berikut menggambarkan hal ini:

#termasuk
menggunakan namespace std;
batal fn()

int var = 3;
jika (1==1)

int var = 4;
cout<
cout<
int utama()

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.

Prototipe Fungsi
Entitas yang berbeda, bahkan dari tipe yang berbeda, biasanya tidak dapat dideklarasikan dalam lingkup yang sama. Namun, prototipe fungsi dapat dideklarasikan lebih dari sekali dalam lingkup yang sama. Program berikut dengan dua prototipe fungsi dan definisi fungsi yang sesuai menggambarkan hal ini:

#termasuk
menggunakan namespace std;
batal fn(int angka);
batal fn(int angka);
batal fn(int angka)

cout<
int utama()

fn(5);
kembali 0;

Program bekerja.

Fungsi kelebihan beban
Fungsi yang kelebihan beban adalah fungsi dengan nama yang sama tetapi tanda tangan fungsi yang berbeda. Sebagai pengecualian lain, fungsi yang kelebihan beban dengan nama yang sama dapat didefinisikan dalam lingkup yang sama. Program berikut menggambarkan hal ini:

#termasuk
menggunakan namespace std;
batal fn(int angka)

cout<
batal fn (tidak mengambang)

cout<
int utama()

fn(5);
mengapung flt = 8.7;
fn(flt);
kembali 0;

Outputnya adalah:
5
8.7

Fungsi kelebihan beban telah didefinisikan dalam lingkup global.

Lingkup Namespace

Lingkup Namespace 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 artikel.

Cakupan dalam Porsi Berbeda Different

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

Lingkup adalah daerah 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.