- Nimiavaruus tarjoaa tilan, jossa voimme määritellä tai ilmoittaa tunnisteen eli muuttujan, menetelmän, luokat.
- Nimiavaruuden avulla voit määrittää tilan tai kontekstin, jossa tunnisteet määritellään, eli muuttuja, menetelmä, luokat. Pohjimmiltaan nimiavaruus määrittelee laajuuden.
Nimiavaruuden etu nimien törmäysten välttämiseksi.
- Esimerkiksi, saatat kirjoittaa jotain koodia, jossa on funktio nimeltä xyz(), ja saatavilla on toinen kirjasto, jolla on myös sama funktio xyz(). Nyt kääntäjä ei voi tietää, mihin xyz()-funktion versioon viittaat koodissasi.
- Nimiavaruus on suunniteltu tämän vaikeuden voittamiseksi, ja sitä käytetään lisätietona eri kirjastoissa saatavilla olevien samanlaisten funktioiden, luokkien, muuttujien jne. erottamiseen samalla nimellä.
- Paras esimerkki nimitilan laajuudesta on C++-standardikirjasto (std), jossa kaikki luokat, menetelmät ja mallit on ilmoitettu. Siksi kirjoitettaessa C++-ohjelmaa sisällytämme yleensä direktiivin nimiavaruuden std;
Nimiavaruuden määrittäminen:
- Nimiavaruuden määritelmä alkaa avainsanalla nimiavaruudella, jota seuraa nimiavaruuden nimi seuraavasti:
namespace namespace_name { // code declarations i.e. variable (int a;) method (void add();) classes ( class student{};) }> - On huomattava, että sulkevan aaltosulkeen jälkeen ei ole puolipistettä (;).
- Jos haluat kutsua funktion tai muuttujan nimiavaruutta tukevaa versiota, lisää nimitilan nimi seuraavasti:
- nimitilan_nimi: :koodi; // koodi voi olla muuttuja , funktio tai luokka.
Käyttöohje:
- Voit myös välttää nimiavaruuksien lisäämistä käyttämällä nimiavaruuskäskyä. Tämä käsky kertoo kääntäjälle, että myöhempi koodi käyttää nimiä määritetyssä nimiavaruudessa.
- Nimiavaruus on siis oletettu seuraavalle koodille:
C++
#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> |
>
>Lähtö
Inside first_space>
- Käyttödirektiiviin lisätyt nimet noudattavat normaaleja laajuussääntöjä. Nimi näkyy käyttödirektiivin kohdasta sen alueen loppuun, jossa direktiivi sijaitsee. Ulkoisessa laajuudessa määritellyt entiteetit, joilla on sama nimi, piilotetaan.
Sisäkkäiset nimiavaruudet:
- Nimiavaruudet voidaan sijoittaa sisäkkäin, jolloin voit määrittää yhden nimiavaruuden toisen nimiavaruuden sisällä seuraavasti:
SYNTAX: namespace namespace_name1 { // code declarations namespace namespace_name2 { // code declarations } }> Voit käyttää sisäkkäisen nimitilan jäseniä käyttämällä resoluutiooperaattoreita seuraavasti:
// päästäksesi nimitilan_nimi2 jäseniin
käyttäen nimiavaruutta nimitilan_nimi1::nimiavaruuden_nimi2;
// päästäksesi nimitilan_nimi1 jäseniin
käyttäen nimiavaruutta nimiavaruuden_nimi1;
Yllä olevissa lausekkeissa, jos käytät nimiavaruuden_nimi1, se asettaa nimitilan_nimi2 elementit saataville laajuudessa seuraavasti:
C++
#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> >// This calls function from second name space.> >func();> > >return> 0;> }> |
>
>Lähtö
Inside second_space>
Katsotaanpa, kuinka nimiavaruus kattaa entiteetit mukaan lukien muuttujan ja funktiot:
C++
negatiivinen diskreetti matematiikka
#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space :: func();> >// Calls function from second name space.> >second_space :: func();> >return> 0;> }> |
>
>Lähtö
Inside first_space Inside second_space>
Harkitse seuraavaa C++-ohjelmaa:
CPP
// A program to demonstrate need of namespace> int> main()> {> >int> value;> >value = 0;> >double> value;>// Error here> >value = 0.0;> }> |
>
>
Lähtö:
Compiler Error: 'value' has a previous declaration as 'int value'>
Kussakin laajuudessa nimi voi edustaa vain yhtä kokonaisuutta. Joten samassa laajuudessa ei voi olla kahta samannimistä muuttujaa. Nimiavaruuksien avulla voimme luoda kaksi muuttujaa tai jäsenfunktiota, joilla on sama nimi.
CPP
// Here we can see that more than one variables> // are being used without reporting any error.> // That is because they are declared in the> // different namespaces and scopes.> #include> using> namespace> std;> // Variable created inside namespace> namespace> first {> int> val = 500;> }> // Global variable> int> val = 100;> int> main()> {> >// Local variable> >int> val = 200;> >// These variables can be accessed from> >// outside the namespace using the scope> >// operator ::> >cout << first::val <<>'
'>;> >return> 0;> }> |
>
>Lähtö
500>
Määritelmä ja luominen: Nimiavaruuksien avulla voimme ryhmitellä nimetyt entiteetit, joilla muuten olisi maailmanlaajuisesti kapeampiin ulottuvuuksiin ja antaa niitä nimitilan laajuus . Tämä mahdollistaa ohjelmien elementtien järjestämisen erilaisiin loogisiin ulottuvuuksiin, joihin viitataan nimillä. Nimiavaruudet tarjoavat tilan, jossa voimme määritellä tai ilmoittaa tunnisteita eli muuttujien nimiä, menetelmiä, luokkia jne.
- Nimiavaruus on C++:ssa lisätty ominaisuus, jota ei ole C:ssä.
- Nimiavaruus on deklaratiivinen alue, joka tarjoaa laajuuden sen sisällä oleville tunnisteille (funktioiden nimille, muuttujille tai muille käyttäjän määrittämille tietotyypeille).
- Useat samannimiset nimiavaruuslohkot ovat sallittuja. Kaikki näiden lohkojen ilmoitukset ilmoitetaan nimetyssä laajuudessa.
Nimiavaruuden määritelmä alkaa avainsanalla nimiavaruus ja sen jälkeen nimitilan nimi seuraavasti:
namespace namespace_name { int x, y; // code declarations where // x and y are declared in // namespace_name's scope }> - Nimiavaruuden määritykset näkyvät vain globaalissa laajuudessa.
- Nimiavaruuden määritykset voidaan upottaa toiseen nimiavaruuteen.
- Nimiavaruusmäärittelyillä ei ole käyttöoikeusmäärityksiä (julkinen tai yksityinen).
- Nimiavaruuden määritelmän sulkevan aaltosulkeen jälkeen ei tarvitse antaa puolipistettä.
- Voimme jakaa nimiavaruuden määritelmän useille yksiköille.
Nimiavaruuden määrittäminen:
Nimiavaruuden määritelmä alkaa avainsanalla nimiavaruudella, jota seuraa nimiavaruuden nimi seuraavasti:
C++
namespace> namespace_name{> >// code declarations i.e. variable (int a;)> >method (>void> add();)> >classes (>class> student{};)> }> |
>
>
On huomattava, että sulkevan aaltosulkeen jälkeen ei ole puolipistettä (;).
Jos haluat kutsua joko funktion tai muuttujan nimiavaruutta tukevaa versiota, lisää nimitilan nimi seuraavasti:
nimitilan_nimi: :koodi; // koodi voi olla muuttuja, funktio tai luokka.
C++
// Let us see how namespace scope the entities including variable and functions:> #include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space::func();> >// Calls function from second name space.> >second_space::func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> // Inside second_space> |
>
>Lähtö
Inside first_space Inside second_space>
Käyttöohje:
Voit välttää nimiavaruuksien lisäämisen käyttämällä nimiavaruuskäskyä. Tämä käsky kertoo kääntäjälle, että myöhempi koodi käyttää nimiä määritetyssä nimiavaruudessa. Nimiavaruus on siis oletettu seuraavalle koodille:
C++
#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> |
>
>Lähtö
Inside first_space>
Koko nimiavaruuden käyttämisen sijaan toinen vaihtoehto (tunnetaan nimellä käyttämällä ilmoitus) on käyttää tiettyä kohdetta nimiavaruudessa. Jos esimerkiksi std-nimiavaruuden ainoa osa, jota aiot käyttää, on cout, voit viitata siihen seuraavasti:
käyttäen std::cout;
Myöhempi koodi voi viitata koodiin cout ilman nimiavaruuden lisäämistä, mutta muiden std-nimiavaruuden kohteiden on silti oltava eksplisiittisiä seuraavasti:
C++
#include> using> std::cout;> int> main ()> {> >cout <<>'std::endl is used with std!'> << std::endl;> >return> 0;> }> |
>
>Lähtö
std::endl is used with std!>
Käyttödirektiiviin lisätyt nimet noudattavat normaaleja laajuussääntöjä, eli ne näkyvät käyttödirektiivin esiintymispisteestä sen soveltamisalan loppuun, jossa direktiivi sijaitsee. Ulkoisessa laajuudessa määritellyt entiteetit, joilla on sama nimi, piilotetaan.
C++
// Creating namespaces> #include> using> namespace> std;> namespace> ns1 {> int> value() {>return> 5; }> }>// namespace ns1> namespace> ns2 {> const> double> x = 100;> double> value() {>return> 2 * x; }> }>// namespace ns2> int> main()> {> >// Access value function within ns1> >cout << ns1::value() <<>'
'>;> >// Access value function within ns2> >cout << ns2::value() <<>'
'>;> >// Access variable x directly> >cout << ns2::x <<>'
'>;> >return> 0;> }> |
>
>
Lähtö:
5 200 100>
Luokat ja nimiavaruus: Seuraava on yksinkertainen tapa luoda luokkia nimiavaruudessa:
C++
// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns> {> >// A Class in a namespace> >class> geek> >{> >public>:> >void> display()> >{> >cout<<>'ns::geek::display()'>< } }; } int main() { // Creating Object of geek Class ns::geek obj; obj.display(); return 0; }> |
>
>Lähtö
ns::geek::display()>
Luokka voidaan myös ilmoittaa nimiavaruudessa ja määritellä nimiavaruuden ulkopuolella käyttämällä seuraavaa syntaksia:
CPP
// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns {> // Only declaring class here> class> geek;> }>// namespace ns> // Defining class outside> class> ns::geek {> public>:> >void> display() { cout <<>'ns::geek::display()
'>; }> };> int> main()> {> >// Creating Object of geek Class> >ns::geek obj;> >obj.display();> >return> 0;> }> |
>
>Lähtö
ns::geek::display()>
Voimme määritellä menetelmiä myös nimiavaruuden ulkopuolella . Seuraava on esimerkkikoodi:
C++
// A C++ code to demonstrate that we can define> // methods outside namespace.> #include> using> namespace> std;> // Creating a namespace> namespace> ns {> void> display();> class> geek {> public>:> >void> display();> };> }>// namespace ns> // Defining methods of namespace> void> ns::geek::display()> {> >cout <<>'ns::geek::display()
'>;> }> void> ns::display() { cout <<>'ns::display()
'>; }> // Driver code> int> main()> {> >ns::geek obj;> >ns::display();> >obj.display();> >return> 0;> }> |
>
>
Lähtö:
ns::display() ns::geek::display():>
Sisäkkäiset nimiavaruudet:
Nimiavaruudet voivat olla sisäkkäisiä, eli voit määrittää yhden nimiavaruuden toisen nimiavaruuden sisällä seuraavasti:
C++
namespace> namespace_name1 {> >// code declarations> >namespace> namespace_name2 {> >// code declarations> >}> }> |
>
>
Voit käyttää sisäkkäisen nimitilan jäseniä käyttämällä resoluutio-operaattoria (::) seuraavasti:
C++
// to access members of namespace_name2> using> namespace> namespace_name1::namespace_name2;> // to access members of namespace:name1> using> namespace> namespace_name1;> |
>
>
Yllä olevissa lauseissa, jos käytät nimiavaruuden_nimi1, se asettaa nimitilan_nimi2 elementit saataville laajuudessa seuraavasti:
C++
#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> > >// This calls function from second name space.> >func();> > >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside second_space> |
>
>Lähtö
Inside second_space>
Nimiavaruus tarjoaa etuna nimien törmäyksen välttämisen: -
Saatat esimerkiksi kirjoittaa jotain koodia, jossa on funktio nimeltä xyz(), ja koodissasi on toinen kirjasto, jolla on myös sama funktio xyz(). Nyt kääntäjä ei voi tietää, mihin xyz()-funktion versioon viittaat koodissasi.
Nimiavaruus on suunniteltu tämän vaikeuden voittamiseksi, ja sitä käytetään lisätietona eri kirjastoissa saatavilla olevien samanlaisten funktioiden, luokkien, muuttujien jne. erottamiseen samalla nimellä.
Paras esimerkki nimitilan laajuudesta on C++-standardikirjasto (std), jossa kaikki luokat, menetelmät ja mallit on ilmoitettu. Siksi, kun kirjoitamme C++-ohjelmaa, sisällytämme yleensä direktiivin
käyttäen nimiavaruutta std;
nimiavaruus C++:ssa | Joukko 2 (nimiavaruuden laajentaminen ja nimeämätön nimiavaruus) nimiavaruus C++:ssa | Joukko 3 (Pääsy, otsikon luominen, sisäkkäisyys ja aliasointi) Voiko nimiavaruuksia sisäkkäin C++:ssa? Viite : http://www.cplusplus.com/doc/tutorial/namespaces/