Tänk på följande två skaläruttalanden i en global omfattning, i följande program:
#omfatta
med namnutrymme std;
intvarId= 5;
flytavarId= 2.3;
inthuvud()
{
lämna tillbaka 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 kompileraren 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:
#omfatta
med namnutrymme std;
namnområde NA
{
intvarId= 5;
}
namnrymd OBS
{
flytavarId= 2.3;
}
inthuvud()
{
kosta<<NA::varId << ' n';
kosta<<OBS::varId << ' n';
lämna tillbaka 0;
}
Utgången är följande:
5
2.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 det specifika namnet för namnutrymmet användas, följt av den gemensamma identifieraren. Namnutrymmesnamnet och den gemensamma identifieraren separeras av operatören för omfattningsupplösning, :: . Namnen på namnområdena kommer att skilja objekten åt.
Den här artikeln behandlar det grundläggande konceptet för ett namnområde och dess användning i programmeringsspråket C ++. För att följa den här artikeln bör du ha grundläggande kunskaper i språket C ++. Du bör också ha kunskap om C ++ - omfattningen, även om det förklaras kortfattat i den här artikeln. För att lära dig mer om C ++ - omfattning, sök efter frasen, Omfattning i C ++ (utan citattecken) i sökrutan på någon linuxhint.com -webbsida och tryck på Retur. Detta leder dig till artikeln som denna författare skrev.
Artikelinnehåll
Vad är ett namnområde?
En deklarativ region är den största delen av ett program där namnet på en enhet (variabel) är giltigt. Denna region kallas ett omfång. Ett namnutrymme i C ++ är en generaliserad omfattning vars huvudsakliga syfte ä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:
#omfattamed namnutrymme std;
intident= 55;
flytaident= 12.17;
inthuvud()
{
lämna tillbaka 0;
}
I programmet ovan finns det två variabler, båda kallade ident . Dessa variabler är i det globala omfånget; det vill säga att de finns 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 behövs ett anpassat namnutrymme.
Anpassat namnområde
Ett namnområde har inte bara ett namn. I stället har ett namnutrymme 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å namnutrymmet och :: . Följande program illustrerar detta med två anpassade namnområden:
#omfattamed namnutrymme std;
namnområde NA
{
intvarInt= 6;
flytaflt;
}
namnrymd OBS
{
intvarInt= 7;
flytaflt;
}
inthuvud()
{
kosta<<NA::varInt << ' n';
kosta<<OBS::varInt << ' n';
NA::flt = 2.5;
OBS::flt = 4.8;
kosta<<NA::flt << ' n';
kosta<<OBS::flt << ' n';
lämna tillbaka 0;
}
Utgången är:
67
2.5
4.8
Observera att namnen NA :: flt och OBS :: flt har slutligen definierats i main () fungera. C ++ tillåter inte en sådan definition i den globala omfattningen.
Observera att det anpassade namnutrymmet är ett kapslat namnutrymme för det globala namnområdet.
Det användande direktivet
För att undvika att skriva nampace :: name hela tiden istället för bara namn efter att deklarerat namnutrymmet kan du använda använder sig av direktiv. Syntaxen för att använda använder sig av direktivet är följande:
med namnområde Namespace_name;De använder sig av direktivet är inte ett förbehandlingsdirektiv, så det slutar med ett semikolon (;).
Följande program illustrerar användningen av använder sig av direktiv och mer:
#omfattamed namnutrymme std;
namnrymd OBS
{
intvarInt= 7;
intfungera()
{
lämna tillbakavarInt;
}
}
intfn()
{
med namnrymd NB;
intmyVar2=fungera();
// andra objekt och funktioner från NB följer.
lämna tillbakamyVar2;
}
intmyVar3=OBS::fungera();
inthuvud()
{
kosta<<fn() << '' <<myVar3<< ' n';
lämna tillbaka 0;
}
Utmatningen av detta program är 7 7 . Termen med namnrymd NB; har placerats i början av fn () definition. De func () från NB -namnutrymmet kallas strax under det, utan att föregå med OBS :: .
En variabel som deklareras i det globala omfånget (globalt namnområde) ses från deklarationspunkten till slutet av filen. Det ses också i de kapslade namnområdena (kapslade omfattningar), till exempel de kapslade fn () funktionsomfång ovan. De använder sig av direktivet ansluter till sitt namnutrymme från positionen där det placeras till slutet av omfattningen där det placeras.
Namnet func () från NB -namnutrymmet kan inte ses under fn () definition eftersom med namnrymd NB; placerades inom funktionsomfånget (block). Under detta villkor, att använda func () utanför NB -namnrymdsblocket (scope) måste det föregås av OBS :: , som i följande uttalande:
intmyVar3=OBS::fungera();De använder sig av direktivet förenar sitt namnutrymme med det yttre häckande namnutrymmet från den position där det är placerat till slutet av det yttre häckande namnutrymmet. I följande program är NA -namnutrymmet förenat med det globala namnområdet. Båda namnområdena sträcker sig sedan in i fn () funktionsdefinition namnrymd, där de är förenade med NB -namnutrymmet. NB -namnutrymmet slutar i slutet av fn () funktionsdefinition, och de två tidigare namnområdena fortsätter till slutet av filen (läs igenom koden).
#omfattamed namnutrymme std;
namnområde NA
{
intvarInt= 6;
intfungera()
{
lämna tillbakavarInt;
}
}
namnrymd OBS
{
intvarInt= 7;
intfungera()
{
lämna tillbakavarInt;
}
}
med namnutrymme NA;
intmyVar0=varInt;
// andra objekt och funktioner från :: och NB följer.
intfn()
{
intmyVar1=varInt;
med namnrymd NB;
intmyVar2=OBS::fungera();
// andra objekt och funktioner från NB följer, till slutet av denna omfattning.
lämna tillbakamyVar1+myVar2;
}
// Endast objekt och funktioner från :: och NB följer.
intmyVar3=OBS::fungera();
inthuvud()
{
kosta<<myVar0<< '' <<fn() << '' <<myVar3<< ' n';
lämna tillbaka 0;
}
Utgången är 6, 13, 7 .
Notera: Det globala namnområdet indikeras med :: , vilket betyder att det inte finns något före operatören för omfattningsupplösning som följer.
Under uttalandet visas med namnutrymme NA; variabler från de globala och NA -namnutrymmena kan användas utan att deras källnamnutrymme anges. Nästa uttalande använder varInt i NA -namnområdet. Den globala och NA -kombinerade namnrymdregionen 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 () omfattning, efter int myVar2 = NB :: func (); , alla namn från NB -namnutrymmet kan endast användas i fn () omfattning utan att föregå den med OBS :: , bara om det inte förekom 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 main () funktion till slutet av filen.
Förlängningen av NB -namnutrymmet börjar från int myVar2 = NB :: func (); i fn () block och slutar i slutet av fn () definitionsblock.
Notera: Namnområden vars regioner är sammanfogade bör inte ha samma variabelnamn i sina olika namnrymdsblock, eftersom detta 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 möjligen distribuerade regionerna i namnområdet. Med användningsdirektivet kan namnutrymmet utökas som regioner i andra omfattningar.
Entiteter som deklareras i en namnrymdkropp sägs vara medlemmar i namnrymden, och namn som införs av dessa deklarationer i namnområdets deklarativa region sägs vara medlemsnamn i namnrymden.
Kapslade namnområden
Följande program visar kapslade namnutrymmen:
#omfattamed namnutrymme std;
namnområde A
{
inti= 1;
namnområde B
{
inti= 2;
namnutrymme C
{
inti= 3;
}
}
}
inthuvud()
{
kosta<<TILL::i << '' <<TILL::B::i << '' <<TILL::B::C::i << ' n';
lämna tillbaka 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 kallas standardbiblioteket. Namnen på objekt, funktioner och andra enheter i det här biblioteket kommer från ett namnområde som kallas standardnamnutrymmet, skrivet som timmar . Standardbiblioteket innehåller underbibliotek, och ett av dessa delbibliotek är iostream . De iostream biblioteket innehåller objektet kosta , som används för att skicka resultat till konsolen (terminal).
Namnet kosta måste vara i timmar namnrymd. Att använda iostream med dess timmar namnutrymme bör programmet vara enligt följande:
#omfattamed namnutrymme std;
Notera användningen av använder sig av direktiv och timmar . Termen #omfatta är ett förbehandlingsdirektiv och slutar inte med ett semikolon. Den innehåller iostream -filen i dess position.
Slutsats
Ett namnområde är ett omfång. Namnrymdbeskrivningen (definition) innehåller grundläggande deklarationer och/eller definitioner av C ++ - objekt, funktioner och andra enheter. Utanför namnrymdsdefinitionen kan namnet nås med syntaxen, namespaceName :: name . 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 möjligen distribuerade regionerna i namnområdet. Med använder sig av direktivet kan namnutrymmet utökas som regioner i andra omfattningar. Namnområden vars regioner är sammanfogade bör inte ha samma variabelnamn i sina olika namnrymdblock, eftersom detta fortfarande skulle orsaka namnkonflikter.
Chrys