Phenquestions
Tänk på följande två skalära uttalanden i ett globalt omfång, i följande program:
#omfattaanvänder namnrymd std;
int varId = 5;
float varId = 2.3;
int main ()
returnera 0;
Ett försök att kompilera detta program leder till ett kompileringsfel. Det finns två variabler med samma namn, varId. Även om de är två olika variabler av två olika typer, int och flyta, kompilatorn avvisar de två deklarationerna eftersom de har samma namn. Följande program löser detta problem genom att deklarera variablerna med samma namn i två olika generaliserade omfattningar:
#omfattaanvänder namnrymd std;
namnområde NA
int varId = 5;
namnområde NB
float varId = 2.3;
int main ()
cout << NA::varId << '\n';
cout << NB::varId << '\n';
returnera 0;
Utgången är som följer:
52.3
Det finns två namnområden i programmet ovan: NA, som har definitionen av ett heltal och OBS!, som har definitionen av en flottör men med samma namn som heltalet för NA. Slutligen, när programmet kördes, användes samma namn för två olika variabler. Observera att för att komma åt samma namn på två olika variabler måste namnet på det specifika namnet användas, följt av den gemensamma identifieraren. Namnrumsnamnet och den gemensamma identifieraren är åtskilda av operatören för omfångsupplösning, “::.”Namnet på namnområdena kommer att skilja på objekten.
Den här artikeln täcker grundkonceptet för ett namnutrymme och dess användning på programmeringsspråket C ++. För att följa den här artikeln bör du ha en grundläggande kunskap om C ++ - språket. Du bör också ha kunskap om C ++ -omfånget, även om det förklaras kort i den här artikeln. Om du vill lära dig mer om C ++ -omfattning, sök efter frasen "Omfattning i C ++" (utan citat) i sökrutan i alla Linuxhint.com-webbsidan och tryck på Enter. Detta leder dig till den artikel som författaren skrev.
Artikelinnehåll
- Vad är ett namnområde?
- Användningsdirektivet
- Kapslade namnområden
- Standard namnområde
- Slutsats
Vad är ett namnområde?
En deklarativ region är den största delen av ett program där namnet på en enhet (variabel) är giltig. Denna region kallas ett omfång. Ett namnområde i C ++ är ett generaliserat omfång vars huvudsyfte är att lösa namnkonflikter. Ett namnområde har grundläggande deklarationer och / eller definitioner av enheter.
Globalt namnområde och dess problem
Det globala namnområdet är det globala omfånget. Tänk på följande korta program:
#omfattaanvänder namnrymd std;
int ident = 55;
float ident = 12.17;
int main ()
returnera 0;
I ovanstående program finns det två variabler, båda kallade ident. Dessa variabler är globala; de är i det globala namnområdet. Ett försök att kompilera detta program misslyckas med ett felmeddelande. Det globala omfånget accepterar inte mer än en variabel med samma namn, så det finns ett behov av ett anpassat namnområde.
Anpassat namnområde
Ett namnområde har inte bara ett namn. Istället har ett namnområde en uppsättning namn för att undvika konflikt med andra uppsättningar namn. För att undvika konflikter lägre i koden, föregå varje namn med namnet på namnområdet och :: . Följande program illustrerar detta med två anpassade namnområden:
#omfattaanvänder namnrymd std;
namnområde NA
int varInt = 6;
float flt;
namnområde NB
int varInt = 7;
float flt;
int main ()
cout << NA::varInt << '\n';
cout << NB::varInt << '\n';
NA :: flt = 2.5;
OBS :: flt = 4.8;
cout << NA::flt << '\n';
cout << NB::flt << '\n';
returnera 0;
Utgången är:
67
2.5
4.8
Observera att namnen NA :: flt och OBS :: flt har slutligen definierats i huvud () fungera. C ++ tillåter inte en sådan definition i det globala omfånget.
Observera att det anpassade namnområdet är ett kapslat namnområde för det globala namnområdet.
Användningsdirektivet
För att undvika att skriva “namepace :: name” hela tiden istället för bara “name” efter att ha förklarat namnområdet kan du använda använder sig av direktiv. Syntaxen för att använda använder sig av direktivet är följande:
med hjälp av namnområde Namnområde_namn;De använder sig av direktivet är inte ett förprocessordirektiv, så det slutar med ett semikolon (;).
Följande program illustrerar användningen av använder sig av direktiv och mer:
#omfattaanvänder namnrymd std;
namnområde NB
int varInt = 7;
int func ()
returvariant;
int fn ()
med hjälp av namnområde NB;
int myVar2 = func ();
// andra objekt och funktioner från NB följer.
returnera myVar2;
int myVar3 = NB :: func ();
int main ()
cout << fn() << " << myVar3 << '\n';
returnera 0;
Resultatet av detta program är 7 7. Termen "användning av namnområdet NB;”Har placerats i början av fn () definition. De funk () från NB-namnområdet kallas strax under det, utan att föregå med “OBS ::.”
En variabel som deklarerats i det globala omfånget (globalt namnområde) ses från deklarationspunkten till slutet av filen. Det ses också i de kapslade namnutrymmena (kapslade omfång), till exempel de kapslade fn () funktionsomfång ovan. De använder sig av direktivet ansluter sitt namnområde från den position där det placeras till slutet av det omfång där det placeras.
Namnet funk () från NB-namnområdet kan inte ses under fn () definition eftersom “använder namnområdet NB; ” placerades inom funktionsomfånget (block). Under detta villkor, att använda “funk ()”Utanför NB namnområdesblock (scope), måste det föregås av“OBS ::,”Som i följande uttalande:
int myVar3 = NB :: func ();De använder sig av direktivet förenar sitt namnutrymme med det yttre häckande namnområdet från den position där det placeras till slutet av det yttre häckande namnområdet. I följande program förenas NA-namnområdet med det globala namnområdet. Båda namnytorna sträcker sig sedan in i fn () funktionsdefinitionens namnområde, där de förenas med NB-namnområdet. NB-namnområdet slutar i slutet av fn () funktionsdefinition och de två tidigare namnytorna fortsätter till slutet av filen (läs igenom koden).
#omfattaanvänder namnrymd std;
namnområde NA
int varInt = 6;
int func ()
returvariant;
namnområde NB
int varInt = 7;
int func ()
returvariant;
med hjälp av namnområdet NA;
int myVar0 = varInt;
// andra objekt och funktioner från :: och NB följer.
int fn ()
int myVar1 = varInt;
användning av namnområdet NB;
int myVar2 = NB :: func ();
// andra objekt och funktioner från NB följer till slutet av detta omfång.
returnera myVar1 + myVar2;
// Endast objekt och funktioner från :: och NB följer.
int myVar3 = NB :: func ();
int main ()
cout << myVar0 << " << fn() << " << myVar3 << '\n';
returnera 0;
Utgången är 6, 13, 7.
Notera: Det globala namnområdet anges med :: , vilket betyder att det inte finns något före områdesupplösningsoperatören som följer.
Nedanför uttalandet,använder namnområdet NA;”Variabler från det globala och NA-namnområdet kan användas utan att ange deras källnamnområde. Nästa uttalande använder varInt av NA-namnområdet. Den globala och NA kombinerade namnområdesregionen sträcker sig in i fn () funktionsnamn. Så, den varInt av det första uttalandet i fn () funktionsomfång, är av NA-namnområdet.
Eftersom regionen för de globala och NA-namnområdena sträcker sig över hela fn () efter "int myVar2 = NB :: func ();,”Vilket namn som helst från NB-namnområdet kan bara användas i fn () utan att föregå med "OBS ::,”Bara om det inte förekommer i NA och globala namnområden (block). Annars bör det föregås av “OBS ::.”Regionen för de kombinerade namnområdena för NA och global fortsätter under fn () definition och in i huvud () funktion till slutet av filen.
Förlängningen av NB-namnområdet börjar från “int myVar2 = NB :: func ();”I fn () block och slutar i slutet av fn () definitionsblock.
Notera: Namnytor vars regioner är förenade bör inte ha samma variabelnamn i sina olika namnområdesblock, eftersom det fortfarande skulle orsaka konflikt.
Namnområdesregioner
Ett namnområde är ett omfång. Bortsett från det globala namnområdet (globalt omfång) bör alla namnområden deklareras i ett block. Det blocket är den första delen av de eventuellt distribuerade regionerna i namnområdet. Med hjälp av direktivet kan namnområdet utökas som regioner i andra omfattningar.
Enheter som deklarerats i en namnområdesdel sägs vara medlemmar i namnområdet, och namn som introduceras av dessa deklarationer i den deklarativa regionen i namnområdet sägs vara medlemsnamn i namnområdet.
Kapslade namnområden
Följande program visar kapslade namnområden:
#omfattaanvänder namnrymd std;
namnområde A
int i = 1;
namnområde B
int i = 2;
namnområde C
int i = 3;
int main ()
cout << A::i << " << A::B::i << " << A::B::C::i << '\n';
returnera 0;
Utgången är:
1 2 3Observera att de tre värdena har nåtts med operatören för upplösning av omfång.
Standard namnområde
C ++ har ett bibliotek som heter standardbiblioteket. Namnen på objekt, funktioner och andra enheter i detta bibliotek kommer från ett namnområde som kallas standardnamnsområdet, skrivet som std. Standardbiblioteket innehåller underbibliotek, och ett av dessa underbibliotek är iostream. De iostream biblioteket innehåller objektet cout, som används för att skicka resultat till konsolen (terminal).
Namnet cout måste vara i std namnområde. Att använda iostream med dess std namnområde bör programmet vara som följer:
#omfattaanvänder namnrymd std;
Notera användningen av använder sig av direktiv och std. Termen "#omfatta
Slutsats
Ett namnområde är ett omfång. Namnområdesbeskrivningen (definition) innehåller grundläggande deklarationer och / eller definitioner av C ++ - objekt, funktioner och andra enheter. Utanom definitionen för namnområdet kan namnet nås med syntaksen, "namespaceName :: namn.”Förutom det globala namnområdet (globalt omfång) bör alla namnområden deklareras i ett block. Det blocket är den första delen av de eventuellt distribuerade regionerna i namnområdet. Med använder sig av direktivet kan namnområdet utvidgas som regioner i andra omfattningar. Namnytor vars regioner är förenade bör inte ha samma variabelnamn i sina olika namnområdesblock, eftersom det fortfarande skulle orsaka namnkonflikt.
Chrys
