- Naamruimte biedt de ruimte waar we de identificatie kunnen definiëren of declareren, dat wil zeggen variabele, methode, klassen.
- Met behulp van naamruimte kunt u de ruimte of context definiëren waarin identificatiegegevens worden gedefinieerd, d.w.z. variabele, methode, klassen. In wezen definieert een naamruimte een bereik.
Voordeel van naamruimte om botsingen tussen namen te voorkomen.
- U schrijft bijvoorbeeld code met de functie xyz() en er is een andere bibliotheek beschikbaar die ook dezelfde functie xyz() heeft. Nu kan de compiler niet weten naar welke versie van de xyz()-functie u verwijst in uw code.
- Een naamruimte is ontworpen om deze moeilijkheid te overwinnen en wordt gebruikt als aanvullende informatie om vergelijkbare functies, klassen, variabelen enz. met dezelfde naam te onderscheiden die beschikbaar zijn in verschillende bibliotheken.
- Het beste voorbeeld van naamruimtebereik is de C++ standaardbibliotheek (std) waar alle klassen, methoden en sjablonen worden gedeclareerd. Daarom nemen we bij het schrijven van een C++-programma meestal de richtlijn op met behulp van naamruimte std;
Een naamruimte definiëren:
- Een naamruimtedefinitie begint als volgt met het trefwoord naamruimte, gevolgd door de naamruimtenaam:
namespace namespace_name { // code declarations i.e. variable (int a;) method (void add();) classes ( class student{};) }> - Opgemerkt moet worden dat er geen puntkomma (;) achter de accolade sluiten staat.
- Om de naamruimteversie van een functie of variabele aan te roepen, plaatst u de naamruimte als volgt vóór:
- naamruimtenaam: :code; // code kan variabel, functie of klasse zijn.
De gebruiksrichtlijn:
- U kunt ook voorkomen dat naamruimten worden voorafgegaan door de instructie 'using namespace'. Deze richtlijn vertelt de compiler dat de volgende code gebruik maakt van namen in de opgegeven naamruimte.
- De naamruimte wordt dus geïmpliceerd voor de volgende code:
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;> }> |
>
>Uitvoer
Inside first_space>
- Namen die in een gebruiksrichtlijn worden geïntroduceerd, voldoen aan de normale reikwijdteregels. De naam is zichtbaar vanaf het punt van de gebruiksrichtlijn tot het einde van het bereik waarin de richtlijn zich bevindt. Entiteiten met dezelfde naam gedefinieerd in een buitenste bereik zijn verborgen.
Geneste naamruimten:
- Naamruimten kunnen worden genest, waarbij u als volgt een naamruimte binnen een andere naamruimte kunt definiëren:
SYNTAX: namespace namespace_name1 { // code declarations namespace namespace_name2 { // code declarations } }> U kunt als volgt toegang krijgen tot leden van een geneste naamruimte door resolutie-operatoren te gebruiken:
// om toegang te krijgen tot leden van naamruimte_naam2
naamruimte naamruimte_naam1::naamruimte_naam2 gebruiken;
// om toegang te krijgen tot leden van naamruimte_naam1
naamruimte naamruimte_naam1 gebruiken;
Als u in de bovenstaande instructies naamruimte_naam1 gebruikt, worden elementen van naamruimte_naam2 als volgt beschikbaar in het bereik:
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;> }> |
>
>Uitvoer
Inside second_space>
Laten we eens kijken hoe de naamruimte de entiteiten omvat, inclusief variabelen en functies:
C++
c booleaans
#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;> }> |
>
>Uitvoer
Inside first_space Inside second_space>
Beschouw het volgende C++-programma:
CPP
// A program to demonstrate need of namespace> int> main()> {> >int> value;> >value = 0;> >double> value;>// Error here> >value = 0.0;> }> |
>
>
Uitgang:
Compiler Error: 'value' has a previous declaration as 'int value'>
In elk bereik kan een naam slechts één entiteit vertegenwoordigen. Er kunnen dus geen twee variabelen met dezelfde naam in hetzelfde bereik voorkomen. Met behulp van naamruimten kunnen we twee variabelen of lidfuncties maken met dezelfde naam.
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;> }> |
>
>Uitvoer
500>
Definitie en creatie: Met naamruimten kunnen we benoemde entiteiten groeperen die anders wel zouden bestaan mondiale reikwijdte in smallere reikwijdten, door ze te geven bereik van de naamruimte . Dit maakt het mogelijk de elementen van programma's te organiseren in verschillende logische bereiken, waarnaar met namen wordt verwezen. Naamruimten bieden de ruimte waar we identificatiegegevens kunnen definiëren of declareren, dat wil zeggen namen van variabelen, methoden, klassen, enz.
- Een naamruimte is een functie die is toegevoegd in C++ en niet aanwezig is in C.
- Een naamruimte is een declaratief gebied dat een bereik biedt aan de identificatiegegevens (namen van functies, variabelen of andere door de gebruiker gedefinieerde gegevenstypen) daarin.
- Meerdere naamruimteblokken met dezelfde naam zijn toegestaan. Alle declaraties binnen deze blokken worden gedeclareerd in het genoemde bereik.
Een naamruimtedefinitie begint met het trefwoord naamruimte gevolgd door de naamruimtenaam als volgt:
namespace namespace_name { int x, y; // code declarations where // x and y are declared in // namespace_name's scope }> - Naamruimtedeclaraties verschijnen alleen bij globaal bereik.
- Naamruimtedeclaraties kunnen in een andere naamruimte worden genest.
- Naamruimtedeclaraties hebben geen toegangsspecificaties (openbaar of privé).
- Het is niet nodig om een puntkomma te plaatsen na de afsluitende accolade van de definitie van naamruimte.
- We kunnen de definitie van naamruimte over verschillende eenheden verdelen.
Een naamruimte definiëren:
Een naamruimtedefinitie begint als volgt met het trefwoord naamruimte, gevolgd door de naamruimtenaam:
C++
string tot datum converteren
namespace> namespace_name{> >// code declarations i.e. variable (int a;)> >method (>void> add();)> >classes (>class> student{};)> }> |
>
>
Opgemerkt moet worden dat er geen puntkomma (;) achter de accolade sluiten staat.
Om de naamruimteversie van een functie of een variabele aan te roepen, plaatst u de naamruimte als volgt vóór:
naamruimtenaam: :code; // code kan een variabele, functie of klasse zijn.
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> |
>
>Uitvoer
Inside first_space Inside second_space>
De gebruiksrichtlijn:
U kunt voorkomen dat naamruimten vooraf worden geplaatst met de instructie 'using namespace'. Deze richtlijn vertelt de compiler dat de volgende code gebruik maakt van namen in de opgegeven naamruimte. De naamruimte wordt dus geïmpliceerd voor de volgende code:
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> |
>
>Uitvoer
Inside first_space>
In plaats van toegang te krijgen tot de hele naamruimte, kan een andere optie (bekend als gebruik makend van declaratie) is om toegang te krijgen tot een bepaald item binnen een naamruimte. Als het enige deel van de std-naamruimte dat u wilt gebruiken bijvoorbeeld cout is, kunt u hier als volgt naar verwijzen:
met behulp van std::cout;
Daaropvolgende code kan verwijzen naar cout zonder de naamruimte vooraf te laten gaan, maar andere items in de std-naamruimte moeten nog steeds als volgt expliciet zijn:
C++
#include> using> std::cout;> int> main ()> {> >cout <<>'std::endl is used with std!'> << std::endl;> >return> 0;> }> |
>
>Uitvoer
std::endl is used with std!>
Namen die in een gebruiksrichtlijn worden geïntroduceerd, gehoorzamen aan de normale reikwijdteregels, dat wil zeggen dat ze zichtbaar zijn vanaf het punt waarop de gebruiksrichtlijn voorkomt tot het einde van het bereik waarin de richtlijn zich bevindt. Entiteiten met dezelfde naam gedefinieerd in een buitenste bereik zijn verborgen.
C++
alfabet en cijfers
// 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;> }> |
>
>
Uitgang:
5 200 100>
Klassen en naamruimte: Hieronder volgt een eenvoudige manier om klassen in een naamruimte te maken:
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; }> |
>
>Uitvoer
ns::geek::display()>
Een klasse kan ook binnen de naamruimte worden gedeclareerd en buiten de naamruimte worden gedefinieerd met behulp van de volgende syntaxis:
CPP
tekenreeks converteren naar int in Java
// 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;> }> |
>
>Uitvoer
ns::geek::display()>
We kunnen ook methoden definiëren buiten de naamruimte . Het volgende is een voorbeeldcode:
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;> }> |
>
>
Uitgang:
ns::display() ns::geek::display():>
Geneste naamruimten:
Naamruimten kunnen worden genest, d.w.z. u kunt als volgt een naamruimte binnen een andere naamruimte definiëren:
C++
namespace> namespace_name1 {> >// code declarations> >namespace> namespace_name2 {> >// code declarations> >}> }> |
1 t/m 100 romeins nr
>
>
U kunt als volgt toegang krijgen tot de leden van een geneste naamruimte door de resolutieoperator (::) te gebruiken:
C++
// to access members of namespace_name2> using> namespace> namespace_name1::namespace_name2;> // to access members of namespace:name1> using> namespace> namespace_name1;> |
>
>
Als u in de bovenstaande instructies naamruimte_naam1 gebruikt, worden de elementen van naamruimte_naam2 als volgt beschikbaar in het bereik:
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> |
>
>Uitvoer
Inside second_space>
Naamruimte biedt het voordeel dat naambotsingen worden vermeden: -
U schrijft bijvoorbeeld code met de functie xyz() en er is een andere bibliotheek in uw code beschikbaar die ook dezelfde functie xyz() heeft. Nu kan de compiler niet weten naar welke versie van de xyz()-functie u verwijst in uw code.
Een naamruimte is ontworpen om deze moeilijkheid te overwinnen en wordt gebruikt als aanvullende informatie om vergelijkbare functies, klassen, variabelen, enz. met dezelfde naam te onderscheiden die in verschillende bibliotheken beschikbaar zijn.
Het beste voorbeeld van naamruimtebereik is de C++ standaardbibliotheek (std), waar alle klassen, methoden en sjablonen worden gedeclareerd. Daarom nemen we bij het schrijven van een C++-programma meestal de richtlijn op
namespace std; gebruiken;
naamruimte in C++ | Set 2 (uitbreiding van naamruimte en naamruimte zonder naam) Naamruimte in C++ | Set 3 (Toegang verkrijgen, koptekst maken, nesten en aliasing) Kunnen naamruimten worden genest in C++? Referentie : http://www.cplusplus.com/doc/tutorial/namespaces/