Skop dalam C ++

Entiti di C ++ mempunyai nama, yang dapat dinyatakan dan / atau ditakrifkan. Deklarasi adalah definisi, tetapi definisi tidak semestinya deklarasi. Definisi memperuntukkan memori untuk entiti bernama, tetapi deklarasi mungkin atau mungkin tidak mengalokasikan memori untuk entiti bernama. Kawasan deklaratif adalah bahagian terbesar dari program di mana nama entiti (pemboleh ubah) berlaku. Kawasan itu disebut ruang lingkup atau ruang lingkup yang berpotensi. Artikel ini menerangkan mengenai scoping di C++. Selanjutnya, pengetahuan asas dalam C ++ diperlukan untuk memahami artikel ini.

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 nama std;
batal fn ()

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

cout<

int utama ()

fn ();
pulangan 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 dalaman, dengan pernyataan cout. Blok luar dan dalam adalah ruang lingkup nama, var.

Walau bagaimanapun, nama, var, masih dapat digunakan untuk menyatakan entiti yang berbeza seperti pelampung di blok dalam. Kod berikut menggambarkan ini:

#sertakan
menggunakan ruang nama std;
batal fn ()

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

float var = 7.5;
cout<

int utama ()

fn ();
pulangan 0;

Keluarannya adalah 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 dalaman 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:

#sertakan
menggunakan ruang nama std;
apungan var = 9.4;
int utama ()

cout <cout <<::var<<'\n';
pulangan 0;

Keluarannya adalah:
9.4
9.4

Dalam kes ini, wilayah deklaratif 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, pengecam digunakan secara langsung atau didahului oleh pengendali 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:

#sertakan
menggunakan ruang nama std;
int utama ()

jika (1 == 1)

/ * beberapa kenyataan * /
int ident = 5;
cout</ * beberapa kenyataan * /

pulangan 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 (e.g., syarat untuk if-block) dan juga di dalam blok. Program pendek berikut menggambarkan ini untuk pemboleh ubah, identif:

#sertakan
menggunakan ruang nama std;
int utama ()

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

cout<
pulangan 0;

Keluarannya adalah 8. Terdapat dua ruang lingkup blok di sini: blok untuk fungsi utama () dan penyataan jika-kompaun bersarang. Blok bersarang adalah skop 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:

#sertakan
menggunakan ruang nama std;
int utama ()

jika (1 == 1)

pemboleh ubah int = 15;

cout<pulangan 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 for-loop berikut tidak akan disusun, menghasilkan mesej ralat:

#sertakan
menggunakan ruang nama std;
int utama ()

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

cout<
cout<pulangan 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 nama std;
tali fn (tali str)

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

int utama ()

tali totStr = fn ("makan");
cout<pulangan 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:

#sertakan
menggunakan ruang nama std;
batal fn ()

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

fn ();
pulangan 0;

Keluarannya adalah 2.

Skop Penghitungan

Penghitungan Tidak Terkawal
Pertimbangkan if-block berikut:

jika (1 == 1)

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

Keluarannya adalah 0 1 3.

Baris pertama dalam blok adalah penghitungan, a, b, dan c adalah penghitungnya. Skop pembilang bermula dari titik pengisytiharan hingga akhir blok enumerasi.

Pernyataan berikut tidak akan disusun kerana titik pengisytiharan c adalah selepas dari:

enum a = c + 2, b, c;

Segmen kod berikut tidak akan disusun kerana pencacah diakses setelah blok enumerasi yang dilampirkan:

jika (1 == 1)

enum a, b, c = b + 2;

cout<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 bermula dengan kelas enum atau enum struct digambarkan sebagai penghitungan skop. Pencacah mereka digambarkan sebagai pencacah skop.

Penghitungan Skop
Pernyataan berikut adalah OK:

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

Ini adalah contoh penghitungan skop. Nama kelas adalah nam. Di sini, ruang lingkup pencacah bermula dari titik perisytiharan hingga akhir definisi penghitungan, dan bukan akhir bongkah untuk penghitungan. Kod berikut tidak akan menyusun:

jika (1 == 1)

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

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:

#sertakan
menggunakan ruang nama std;
// Kelas asas
kelas Cla

peribadi:
int memP = 5;
dilindungi:
int memPro = 9;
awam:
batal fn ()

cout<
;
// Kelas Berasal
kelas DerCla: awam Cla

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

Cla obj;
obj.fn ();
DerCla derObj;
cout<pulangan 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 lagi 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 diturunkan. Ia dilihat kembali turun dalam fungsi utama ().

Pengendali Penyelesaian Skop
Operator resolusi skop dalam C ++ adalah: . Ia digunakan untuk mengakses ahli kelas yang statik. Program berikut menggambarkan ini:

#sertakan
menggunakan ruang nama std;
kelas Cla

awam:
stat stat int mem = 5;
awam:
kekosongan statik fn ()

cout<
;
int utama ()

cout<Cla :: fn ();
pulangan 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 Stres Berumur

T John = 11;
U 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 void func (T no, U cha, const char * str);

Namun, ketika datang ke deskripsi kelas (definisi), ruang lingkupnya juga boleh menjadi bahagian yang berbeza seperti dalam kod berikut:

#sertakan
menggunakan ruang nama std;
templat kelas TheCla

awam:
T num;
U ch statik;
void func (U cha, const char * str)

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

keseronokan kekosongan statik (U ch)

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

;
int utama ()

TheCla obj;
obj.angka = 12;
obj.func ('$', "500");
pulangan 0;

Menyembunyikan Nama

Contoh penyembunyian nama berlaku apabila nama jenis objek yang sama dinyatakan semula dalam blok bersarang. Program berikut menggambarkan ini:

#sertakan
menggunakan ruang nama std;
batal fn ()

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

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

fn ();
pulangan 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:

#sertakan
menggunakan ruang nama std;
kekosongan fn (int num);
kekosongan fn (int num);
kekosongan fn (int num)

cout<
int utama ()

fn (5);
pulangan 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:

#sertakan
menggunakan ruang nama std;
kekosongan fn (int num)

cout<
batal fn (apungan no)

cout<
int utama ()

fn (5);
float flt = 8.7;
fn (flt);
pulangan 0;

Keluarannya adalah:
5
8.7

Fungsi yang berlebihan 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 artikel.

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.