Phenquestions
Perhatikan dua pernyataan skalar berikut dalam lingkup global, dalam program berikut:
#termasukmenggunakan namespace std;
int varId = 5;
float varId = 2.3;
int utama()
kembali 0;
Upaya untuk mengkompilasi program ini menyebabkan kesalahan kompilasi. Ada dua variabel dengan nama yang sama, varId. Meskipun mereka adalah dua variabel yang berbeda dari dua jenis yang berbeda, ke dalam dan mengapung, kompiler menolak dua deklarasi karena mereka memiliki nama yang sama. Program berikut memecahkan masalah ini dengan mendeklarasikan variabel dengan nama yang sama dalam dua lingkup umum yang berbeda:
#termasukmenggunakan namespace std;
ruang nama NA
int varId = 5;
namespace NB
float varId = 2.3;
int utama()
cout << NA::varId << '\n';
cout << NB::varId << '\n';
kembali 0;
Outputnya adalah sebagai berikut:
52.3
Ada dua ruang nama dalam program di atas: tidak, yang memiliki definisi bilangan bulat, dan catatan, yang memiliki definisi float tetapi dengan nama yang sama dengan bilangan bulat untuk NA. Akhirnya, ketika program dijalankan, nama yang sama untuk dua variabel yang berbeda digunakan. Perhatikan bahwa untuk mengakses nama yang sama dari dua variabel yang berbeda, nama khusus untuk namespace harus digunakan, diikuti oleh pengenal umum. Nama namespace dan pengenal umum dipisahkan oleh operator resolusi lingkup, “::.Nama ruang nama akan membedakan objek.
Artikel ini membahas konsep dasar namespace dan penggunaannya dalam bahasa pemrograman C++. Untuk mengikuti artikel ini, Anda harus memiliki pengetahuan dasar tentang bahasa C++. Anda juga harus memiliki pengetahuan tentang ruang lingkup C++, meskipun dijelaskan secara singkat dalam artikel ini. Untuk mempelajari lebih lanjut tentang cakupan C++, cari frasa, "Cakupan dalam C++" (tanpa tanda kutip) di kotak pencarian linuxhint apa pun.com halaman web dan tekan Enter. Ini akan mengarahkan Anda ke artikel yang ditulis oleh penulis ini.
Isi Artikel
- Apa itu Namespace??
- Petunjuk penggunaan
- Ruang Nama Bersarang
- Ruang Nama Standar
- Kesimpulan
Apa itu Namespace??
Wilayah deklaratif adalah bagian terbesar dari sebuah program di mana nama entitas (variabel) valid. Wilayah ini disebut ruang lingkup. Namespace di C++ adalah lingkup umum yang tujuan utamanya adalah untuk menyelesaikan konflik nama name. Namespace memiliki deklarasi dasar dan/atau definisi entitas.
Namespace Global dan Masalahnya
Ruang nama global adalah ruang lingkup global. Perhatikan program singkat berikut:
#termasukmenggunakan namespace std;
int identitas = 55;
identitas mengambang = 12.17;
int utama()
kembali 0;
Dalam program di atas, ada dua variabel, keduanya disebut identitas. Variabel-variabel ini berada dalam lingkup global; yaitu, mereka berada di namespace global. Upaya untuk mengkompilasi program ini akan gagal dengan pesan kesalahan. Lingkup global tidak menerima lebih dari satu variabel dengan nama yang sama, jadi ada kebutuhan untuk ruang nama khusus.
Ruang Nama Kustom
Namespace tidak hanya memiliki satu nama. Sebagai gantinya, namespace memiliki serangkaian nama untuk menghindari konflik dengan set nama lainnya. Untuk menghindari konflik yang lebih rendah dalam kode, awali setiap nama dengan nama namespace dan :: . Program berikut mengilustrasikan ini menggunakan dua ruang nama khusus:
#termasukmenggunakan namespace std;
ruang nama NA
int varInt = 6;
mengapung flt;
namespace NB
int varInt = 7;
mengapung flt;
int utama()
cout << NA::varInt << '\n';
cout << NB::varInt << '\n';
NA::flt = 2.5;
NB::flt = 4.8;
cout << NA::flt << '\n';
cout << NB::flt << '\n';
kembali 0;
Outputnya adalah:
67
2.5
4.8
Perhatikan bahwa nama-nama NA::flt dan NB::flt akhirnya telah didefinisikan dalam utama() fungsi. C++ tidak mengizinkan definisi seperti itu dalam lingkup global.
Perhatikan bahwa namespace kustom adalah namespace bersarang untuk namespace global.
Petunjuk penggunaan
Untuk menghindari mengetik "namepace::name" sepanjang waktu alih-alih hanya "name" setelah mendeklarasikan namespace, Anda dapat menggunakan menggunakan pengarahan. Sintaks untuk menggunakan menggunakan arahannya adalah sebagai berikut:
menggunakan namespace Namespace_name;Itu menggunakan direktif bukan direktif preprocessor, jadi diakhiri dengan titik koma (;).
Program berikut mengilustrasikan penggunaan menggunakan direktif dan lainnya:
#termasukmenggunakan namespace std;
namespace NB
int varInt = 7;
fungsi int ()
kembali varInt;
int fn()
menggunakan namespace NB;
int myVar2 = fungsi();
//objek dan fungsi lain dari NB ikuti.
kembalikan myVar2;
int myVar3 = NB::func();
int utama()
cout << fn() << " << myVar3 << '\n';
kembali 0;
Keluaran dari program ini adalah 7 7. Syarat "menggunakan namespace NB;” telah ditempatkan di awal fn() definisi. Itu fungsi() dari namespace NB disebut tepat di bawahnya, tanpa diawali dengan “catatan::.”
Variabel yang dideklarasikan dalam lingkup global (global namespace) dilihat dari titik deklarasi hingga akhir file. Itu juga terlihat di ruang nama bersarang (cakupan bersarang), seperti ruang bersarang fn() lingkup fungsi di atas. Itu menggunakan direktif bergabung dengan namespace dari posisi di mana ia ditempatkan ke akhir lingkup di mana ia ditempatkan.
Nama fungsi() dari namespace NB tidak dapat dilihat di bawah fn() definisi karena “menggunakan namespace NB;” ditempatkan dalam lingkup fungsi (blok). Dalam kondisi ini, untuk menggunakan “fungsi()” di luar blok namespace NB (lingkup), harus didahului dengan “catatan::,” seperti pada pernyataan berikut:
int myVar3 = NB::func();Itu menggunakan direktif menggabungkan namespace dengan namespace bersarang luar dari posisi di mana ia ditempatkan ke ujung namespace bersarang luar. Dalam program berikut, namespace NA digabungkan dengan namespace global. Kedua ruang nama kemudian diperluas ke fn() namespace definisi fungsi, di mana mereka bergabung dengan namespace NB. Namespace NB berakhir di akhir fn() definisi fungsi, dan dua ruang nama sebelumnya berlanjut hingga akhir file (baca kodenya).
#termasukmenggunakan namespace std;
ruang nama NA
int varInt = 6;
fungsi int ()
kembali varInt;
namespace NB
int varInt = 7;
fungsi int ()
kembali varInt;
menggunakan namespace NA;
int myVar0 = varInt;
//objek dan fungsi lain dari :: dan NB ikuti.
int fn()
int myVar1 = varInt;
menggunakan namespace NB;
int myVar2 = NB::func();
//objek dan fungsi lain dari NB mengikuti, hingga akhir lingkup ini.
kembalikan myVar1 + myVar2;
//Hanya objek dan fungsi dari :: dan NB yang mengikuti.
int myVar3 = NB::func();
int utama()
cout << myVar0 << " << fn() << " << myVar3 << '\n';
kembali 0;
Keluarannya adalah 6, 13, 7.
catatan: Ruang nama global ditunjukkan dengan :: , artinya tidak ada apa pun sebelum operator resolusi ruang lingkup yang mengikuti.
Di bawah pernyataan, “menggunakan namespace NA;” variabel dari ruang nama global dan NA dapat digunakan tanpa indikasi ruang nama sumbernya. Pernyataan selanjutnya menggunakan varInt dari ruang nama NA. Wilayah namespace gabungan global dan NA meluas ke fn() ruang nama fungsi. Sehingga varInt dari pernyataan pertama dalam fn() ruang lingkup fungsi, adalah dari namespace NA.
Karena wilayah untuk ruang nama global dan NA meluas ke seluruh fn() lingkup, setelah “int myVar2 = NB::func();,” nama apa pun dari namespace NB hanya dapat digunakan di fn() lingkup tanpa mendahuluinya dengan “catatan::,” hanya jika itu tidak terjadi di NA dan ruang nama global (blok). Jika tidak, harus didahului dengan “catatan::.” Wilayah dari ruang nama gabungan untuk NA dan global berlanjut di bawah fn() definisi dan ke dalam utama() fungsi sampai akhir file.
Perpanjangan namespace NB dimulai dari “int myVar2 = NB::func();" dalam fn() blok dan berakhir di ujung fn() blok definisi.
catatan: Namespace yang regionnya digabungkan tidak boleh memiliki nama variabel yang sama di blok namespace yang berbeda, karena ini masih akan menyebabkan konflik.
Wilayah Namespace
Ruang nama adalah ruang lingkup. Terlepas dari namespace global (lingkup global), namespace apa pun harus dideklarasikan dalam satu blok. Blok itu adalah bagian pertama dari kemungkinan wilayah terdistribusi dari namespace. Dengan menggunakan direktif, namespace dapat diperluas sebagai wilayah di lingkup lain.
Entitas yang dideklarasikan dalam badan namespace dikatakan sebagai anggota namespace, dan nama yang diperkenalkan oleh deklarasi ini ke dalam wilayah deklaratif namespace dikatakan sebagai nama anggota namespace.
Ruang Nama Bersarang
Program berikut menunjukkan ruang nama bersarang:
#termasukmenggunakan namespace std;
ruang nama A
int saya = 1;
ruang nama B
int saya = 2;
ruang nama C
int saya = 3;
int utama()
cout << A::i << " << A::B::i << " << A::B::C::i << '\n';
kembali 0;
Outputnya adalah:
1 2 3Perhatikan bahwa ketiga nilai telah diakses menggunakan operator resolusi lingkup.
Ruang Nama Standar
C++ memiliki perpustakaan yang disebut perpustakaan standar. Nama-nama objek, fungsi, dan entitas lain di perpustakaan ini berasal dari namespace yang disebut namespace standar, ditulis sebagai std. Perpustakaan standar berisi sub-perpustakaan, dan salah satu dari sub-perpustakaan ini adalah iostream. Itu iostream perpustakaan berisi objek cout, yang digunakan untuk mengirim hasil ke konsol (terminal).
Nama cout harus di std ruang nama. Menggunakan iostream dengan itu std namespace, programnya harus sebagai berikut:
#termasukmenggunakan namespace std;
Perhatikan penggunaan menggunakan direktif dan std. Syarat "#termasuk
Kesimpulan
Ruang nama adalah ruang lingkup. Deskripsi namespace (definisi) berisi deklarasi dasar dan/atau definisi objek C++, fungsi, dan entitas lain. Di luar definisi namespace, nama tersebut dapat diakses dengan sintaks, “namespaceNama::nama.Terlepas dari namespace global (global scope), namespace apa pun harus dideklarasikan dalam satu blok. Blok itu adalah bagian pertama dari kemungkinan wilayah terdistribusi dari namespace. Dengan menggunakan direktif, namespace dapat diperluas sebagai wilayah dalam cakupan lain. Namespace yang regionnya digabungkan tidak boleh memiliki nama variabel yang sama di blok namespace yang berbeda, karena ini masih akan menyebabkan konflik nama.
Chrys
