Perhatikan dua pernyataan skalar berikut dalam lingkup global, dalam program berikut:
#termasuk
menggunakan namespace std;
ke dalamvarId= 5;
mengambangvarId= 2.3;
ke dalamutama()
{
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 mengambang , 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:
#termasuk
menggunakan namespace std;
ruang nama NA
{
ke dalamvarId= 5;
}
namespace NB
{
mengambangvarId= 2.3;
}
ke dalamutama()
{
biaya<<tidak::varId << ' ';
biaya<<catatan::varId << ' ';
kembali 0;
}
Outputnya adalah sebagai berikut:
5
2.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 dengan 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, Lingkup dalam C++ (tanpa tanda kutip) di kotak pencarian di halaman web linuxhint.com mana pun dan tekan Enter. Ini akan mengarahkan Anda ke artikel yang ditulis oleh penulis ini.
Isi Artikel
Apa itu Namespace?
Wilayah deklaratif adalah bagian terbesar dari 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. 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;
ke dalamidentitas= 55;
mengambangidentitas= 12.17;
ke dalamutama()
{
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 sekumpulan nama untuk menghindari konflik dengan kumpulan 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
{
ke dalamvarInt= 6;
mengambangflt;
}
namespace NB
{
ke dalamvarInt= 7;
mengambangflt;
}
ke dalamutama()
{
biaya<<tidak::varInt << ' ';
biaya<<catatan::varInt << ' ';
tidak::flt = 2.5;
catatan::flt = 4.8;
biaya<<tidak::flt << ' ';
biaya<<catatan::flt << ' ';
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 pengetikan namepace::name sepanjang waktu alih-alih hanya nama setelah mendeklarasikan namespace, Anda dapat menggunakan menggunakan pengarahan. Sintaks untuk menggunakan menggunakan arahannya adalah sebagai berikut:
menggunakan namespace Namespace_name;NS menggunakan direktif bukan direktif preprocessor, jadi diakhiri dengan titik koma (;).
Program berikut mengilustrasikan penggunaan menggunakan direktif dan lainnya:
#termasukmenggunakan namespace std;
namespace NB
{
ke dalamvarInt= 7;
ke dalamfungsi()
{
kembalivarInt;
}
}
ke dalamfn()
{
menggunakan namespace NB;
ke dalammyVar2=fungsi();
//objek dan fungsi lain dari NB mengikuti.
kembalimyVar2;
}
ke dalammyVar3=catatan::fungsi();
ke dalamutama()
{
biaya<<fn() << '' <<myVar3<< ' ';
kembali 0;
}
Keluaran dari program ini adalah 7 7 . Syarat menggunakan namespace NB; telah ditempatkan di awal fn() definisi. NS 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. NS 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 digunakan fungsi () di luar blok namespace NB (lingkup), itu harus didahului oleh catatan:: , seperti pada pernyataan berikut:
ke dalammyVar3=catatan::fungsi();NS 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
{
ke dalamvarInt= 6;
ke dalamfungsi()
{
kembalivarInt;
}
}
namespace NB
{
ke dalamvarInt= 7;
ke dalamfungsi()
{
kembalivarInt;
}
}
menggunakan namespace NA;
ke dalammyVar0=varInt;
//objek dan fungsi lain dari :: dan NB mengikuti.
ke dalamfn()
{
ke dalammyVar1=varInt;
menggunakan namespace NB;
ke dalammyVar2=catatan::fungsi();
//objek dan fungsi lain dari NB mengikuti, hingga akhir lingkup ini.
kembalimyVar1+myVar2;
}
//Hanya objek dan fungsi dari :: dan NB yang mengikuti.
ke dalammyVar3=catatan::fungsi();
ke dalamutama()
{
biaya<<myVar0<< '' <<fn() << '' <<myVar3<< ' ';
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 tersebut, 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() lingkup fungsi, adalah dari namespace NA.
Karena wilayah untuk ruang nama global dan NA meluas ke seluruh fn() ruang 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, itu harus didahului oleh catatan:: . Wilayah ruang nama gabungan untuk NA dan global berlanjut di bawah fn() definisi dan ke dalam utama() berfungsi 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 hal ini masih akan menyebabkan konflik.
Wilayah Namespace
Namespace adalah ruang lingkup. Terlepas dari namespace global (global scope), namespace apa pun harus dideklarasikan dalam sebuah blok. Blok itu adalah bagian pertama dari kemungkinan wilayah terdistribusi dari namespace. Dengan menggunakan direktif, namespace dapat diperluas sebagai wilayah dalam 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
{
ke dalamSaya= 1;
ruang nama B
{
ke dalamSaya= 2;
ruang nama C
{
ke dalamSaya= 3;
}
}
}
ke dalamutama()
{
biaya<<KE::Saya << '' <<KE::B::Saya << '' <<KE::B::C::Saya << ' ';
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 jam . Perpustakaan standar berisi sub-perpustakaan, dan salah satu dari sub-perpustakaan ini adalah iostream . NS iostream perpustakaan berisi objek biaya , yang digunakan untuk mengirim hasil ke konsol (terminal).
Nama biaya harus di jam ruang nama. Menggunakan iostream dengan nya jam namespace, programnya harus sebagai berikut:
#termasukmenggunakan namespace std;
Perhatikan penggunaan menggunakan direktif dan jam . Syarat #termasuk adalah direktif preprocessor dan tidak diakhiri dengan titik koma. Ini termasuk file iostream pada posisi direktifnya.
Kesimpulan
Namespace adalah ruang lingkup. Deskripsi namespace (definisi) berisi deklarasi dasar dan/atau definisi objek C++, fungsi, dan entitas lainnya. Di luar definisi namespace, nama dapat diakses dengan sintaks, namespaceNama::nama . Terlepas dari namespace global (global scope), namespace apa pun harus dideklarasikan dalam sebuah 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