Meny

Namnområden i C ++

namespaces c

Prova Vårt Instrument För Att Eliminera Problem

En fullständig översikt över namnområden i C ++ med enkla exempel.

Hittills i våra tidigare handledning har vi sett allt om variabler, deklarationer, funktioner och andra sådana enheter som används i C ++.

Medan applikationer utvecklas i C ++ kan vissa märkliga situationer uppstå som samma variabla namn som används två gånger eller funktioner definierade med samma prototyper etc. När dessa scenarier uppstår blir det svårt för kompilatorn att härleda rätt variabel eller funktionsanrop som ger upphov till tvetydighet .

=> Kolla in den perfekta C ++ träningsguiden här.

Namnområden i C ++

Vad du kommer att lära dig:

Vad är namnområde?

Låt se nedanstående exempel:

#include #include int main() { int var; double var; std::cin>>var; }

Produktion:

I funktion 'int main ()':
8:10: fel: motstridande deklaration 'dubbel var'
7: 7: Obs: föregående deklaration som ”int var”

topp 10 platser att titta på anime

I exemplet ovan har vi definierat två variabler med olika typer men samma identifierare. Så när vi sammanställer detta exempel får vi ett fel som visas i Output-fönstret. Dessa motstridiga deklarationer uppstår på grund av att samma identifierare används för att nämna två variabler.

Denna typ av situationer ger upphov till tvetydighet i applikationer.

C ++ introducerar något som heter “ namnrymden ”För att lösa detta problem. Namnområdet i C ++ är precis som ett paket eller en region eller ett bibliotek som används för att skilja mellan variabeln eller funktionerna med samma identifierare.

Ett namnområde kan innehålla variabler, funktioner, klasser eller andra objekt och till och med ett annat namnområde. Varje medlem i namnområdet kan hänvisas till med hjälp av ett namnområde. Detta hjälper kompilatorn att skilja mellan olika programmeringsenheter även om de har samma namn.

Definiera ett namnområde

I C ++ kan vi definiera ett namnområde med hjälp av nyckelordet “ namnområde ' enligt nedanstående:

namespace namespace_name{ namespace_declarations; }

Så om vi behöver definiera ett namnområde med namnet “test_space” kan vi göra det enligt nedan:

namespace test_space{ int var=10; }

Ovanstående deklaration definierar ett namnområde med namnet “test_space”. Som visat har den ett heltal variabel var som dess medlem.

Åtkomst till namnområdesmedlemmar

Nu har vi definierat vårt eget namnområde 'test_space' och hur får vi tillgång till innehållet i detta namnområde?

I C ++ - programmet kan vi komma åt medlemmarna i namnområdet med syntaxen:

namespace_name::namespace_member;

Således kan heltalvariabeln var som deklareras i namnområdet 'test_space' ovan nås på följande sätt:

test_space::var;

Se hela exemplet nedan för att visa namnområden och dess användning.

#include #include namespace test_space{ int var = 10; } int main() { double var = 20.53; std::cout<<'local var = '<

Senare visar vi båda dessa variabler. Observera att även om den lokala dubbla variabeln inuti huvudmenyn kan skrivas ut direkt, måste vi föregå den med namnområdets namn för att skriva ut variabeln för namnområdet.

Detta har också tagit hand om problemet med kollisioner mellan variablerna på grund av samma namn som vi diskuterade tidigare.

Användningsdirektivet

I vårt tidigare ämne såg vi att vi kan komma åt namnrymdmedlemmar med namnrymdnamn :: namnrymd_medlem.

Om vi ​​inte vill ange namnnamn överallt i programmet kan vi använda “ använder sig av ”-Direktivet för att inkludera namnområdet i programmet.

vila api intervju frågor och svar

Detta görs enligt följande:

#include #include namespace test_space{ int var = 10; } using namespace std; using namespace test_space; int main() { double var = 20.53; cout<<'local var = '<

Det andra uttalandet används för att inkludera “test_space” namnområde i programmet.

I huvudfunktionen kan vi se att funktionerna som cout och variabel var inte behöver föregås av ett namnområdesnamn. Vi kan direkt hänvisa till dem. Men eftersom var har ett namnkollision med en lokal variabel i huvudfunktionen, hänvisar vi det med operatören för omfångsupplösning (: :) eftersom namnområden också alltid har ett globalt omfång.

Kapslade namnområden

C ++ tillåter också att ha kapslade namnrymden, dvs. ett namnområde definierat i ett annat namnområde.

Den allmänna syntaxen för kapslade namnområden är som följer:

namespace ns1{ ns1_code; namespace ns2{ ns2_code; } }

Om vi ​​behöver komma åt ns2_code kan vi komma åt det enligt följande:

ns1::ns2::ns2_code;

Låt oss demonstrera de kapslade namnytorna med hjälp av följande kodexempel.

#include #include namespace first{ int var = 10; namespace second{ int secVar = 20; } } using namespace std; using namespace first; using namespace first::second; int main() { double var = 20.53; cout<<'local var = '<

Vi kan visa aliaset för ett namnområde genom att ändra exemplet ovan.

#include #include namespace first{ int var = 10; namespace second{ int secVar = 20; } } using namespace std; using namespace first; namespace nested = first::second; int main() { double var = 20.53; cout<<'local var = '<Externa namnområden

Ibland när vi har för många namnområden att använda i vår applikation kanske vi vill placera alla namnområden i en separat fil. Detta kan enkelt göras. När namnytorna finns i den separata filen tar vi bara med den filen i vårt program och använder sedan namnområdena och dess innehåll direkt i vårt program.

Till exempel, om vi har en fil med namnet ns.h som innehåller följande namnområde.

microsoft dynamics ax handledning för nybörjare
//ns.h namespace first{ int var = 25; }

Nu i vårt program kan vi använda namnområdet 'först' enligt följande:

#include #include “ns.h” using namespace std; int main() { cout<

Så när vi har inkluderat filen som innehåller namnområden i vårt program kan vi använda namnytorna som om de förklarades globalt i samma program.

Angränsande namnområden

C ++ låter oss också definiera något som kallas angränsande namnområden. Angränsande namnområden är namnområden som definieras mer än en gång genom att ha samma namn. I själva verket är detta inte separata namnområden utan tillägg för samma namnområde.

Angränsande namnområden är uppenbara i exemplet nedan.

#include #include . namespace first{ int var = 10; } namespace first{ namespace second{ int secVar = 20; } } using namespace std; using namespace first; namespace nested = first::second; int main() { double var = 20.53; cout<<'local var = '<

Slutsats

Med detta har vi kommit till slutet av denna handledning om namnområden i C ++. Namnytor på ett sätt som gör det möjligt för oss att separera vår kod i olika utrymmen eller regioner så att vi har tydlighet i att läsa den och även att använda dess medlemmar.

I våra efterföljande handledning lär vi oss mer om de olika grundläggande ämnena i C ++ som undantagshantering, filinmatning / utdata etc.

=> Kolla här för att se A-Z av C ++ utbildningstutorialer här.

Rekommenderad läsning

^