Namnutrymme i C ++ används för att organisera kod i logiska grupper och för att förhindra namnkollisioner som kan uppstå, särskilt när din kodbas innehåller flera bibliotek. I den här artikeln kommer följande pekare att behandlas:
- Behovet av namnområde
- Definiera ett namnområde i C ++
- Poäng att komma ihåg när du definierar ett namnområde
- Användning av namnrymd i C ++
- Diskontinuerliga namnområden
- Kapslade namnområden
Behovet av namnområde
Tänk på en situation, vi skriver lite kod som har en funktion som kallas abc () och det finns ett annat fördefinierat bibliotek tillgängligt som också har samma funktion abc (). Nu vid tidpunkten för sammanställningen har kompilatorn ingen aning om vilken version av abc () -funktionen vi hänvisar till i vår kod.
För att övervinna denna svårighet är namnområdet utformat och används som ytterligare information för att differentiera liknande funktioner, variabler, klasser etc. med samma namn tillgängligt i olika bibliotek. Med hjälp av namnområdet kan vi definiera det sammanhang där namnen definieras. I huvudsak definierar ett namnområde ett omfång.
Alla C ++ - standardbibliotektyper och -funktioner deklareras i std-namnområdet eller namnområden som är kapslade inuti std, så det används ofta i de flesta program.
Definiera ett namnområde
För att definiera namnområdet börjar vi med nyckelordets namnområde följt av namnområdet namn enligt följande:
namespace namespace_name {int a, b // koddeklarationer där // a och b deklareras i // namespace_name's scope}Poäng att komma ihåg när du definierar ett namnområde
- Namnområdesdeklarationer visas endast globalt.
- Namnutrymmesdeklarationer har inte åtkomstspecifikatorer.
- Namnområdedeklarationer kan kapslas in i ett annat namnområde.
- Inget behov av att ge semikolon efter den avslutande klammern för definitionen av namnområdet.
- Definition av namnrymden kan delas över flera enheter.
#include using namespace std namespace first_function {void func () {cout<< 'Inside first_function' << endl } } namespace second_function { void func() { cout << 'Inside second_function' << endl } } int main () { // Calls function from first name space. first_function::func() // Calls function from second name space. second_function::func() return 0 }Produktion:
I exemplet ovan för att definiera func () -funktionen två olika tider använder vi konceptet namespace. Vi definierar den första funktionen under namnområdet first_function ochandra funktionen under namnområdet second_function. För att anropa dessa funktioner använder vi operatör för upplösningsomfång på följande sätt - first_function :: func () och second_function :: func ().
Användning av namnrymd i C ++
Det finns tre sätt att använda ett namnområde i programmet,
- Användningsdirektivet
- Användningsdeklarationen
- Scope Resolution Operator (: :)
Användningsdirektivet
Vi kan undvika att förbereda namnområden med använder sig av namnområdedirektivet. använder sig av med nyckelordet kan vi importera ett helt namnområde till ditt program med ett globalt omfång. Den kan användas för att importera ett namnområde till ett annat namnområde eller vilket program som helst enligt våra krav.
Tänk på en rubrikfil Namespace_first.h:
namnområde First {int a class First_class {int i}}Inkluderar ovanstående rubrikfil för namnområdet i filen Namespace_second.h: inkludera 'Namespace_first.h'
typ av funktion i sql
namespace Second {använder namespace First First_class obj int y}Vi importerar namespace_First till namespace_Second, därför kommer klass First_class nu att finnas tillgänglig i namespace_Second. Därför kan vi skriva följande program i en separat fil, låt oss säga new_file.cpp.
#include 'Namespace_second.h' void test () {using namespace Second // skapa objekt av klass First_class First_class obj2}Därmed , gör användningsdirektivet mycket enklare att använda ett namnområde i C ++, var du än vill.
Användningsdeklarationen
I användardeklarationen importerar vi ett specifikt namn åt gången som endast är tillgängligt inom det aktuella omfånget och det kallas med hjälp av omfångsupplösning. OBS: Namnet som importeras med en användardeklaration kan åsidosätta det namn som importeras med hjälp av direktivet. Vi kan se detta i exemplet nedan.
Låt oss överväga en rubrikfil New_File.h:
namespace First {void A () {cout<< 'A of First namespacen' } } namespace Second { void A() { cout << 'A of Second namespacen' } }Låt oss nu skapa en ny programfil med namnet New_file_2.cpp med nedanstående kod:
#include 'New_file.h' ogiltigt B () {använder namnområde First // använder direktivet med Second :: A // med deklaration First :: A () // class A () of First namespace A () // calls A () i andra namnområdet}Scope resolution operator (: :)
Vi kan uttryckligen ange alla namn som deklareras i ett namnområde med hjälp av namnområdet och omfångsupplösningen ' :: ' operatören med identifieraren.
namnområde New_space {class X {static int i public: void func ()} // class name declaration class Y} // Initializing static class variable int New_space :: X :: i = 23 class New_space :: Y {int a public: int getdata () {cout<< a } // Constructor declaration Y() } // Constructor definition explicitly New_space::Y::Y() { a=0 }Diskontinuerligt namnområde i C ++
Som vi vet kan ett namnutrymme i C ++ definieras i flera delar så det består av summan av dess separat definierade delar. Så om en del av namnområdet kräver ett namn definierat i en annan fil, måste det namnet fortfarande deklareras i sitt omfång. Att skriva följande namnområde på följande sätt definierar antingen ett nytt namnområde eller lägger till nya element i ett befintligt:
namnområde namnområde_namn {// kodtext}Kapslat namnområde i C ++
Namnytor kan enkelt kapslas och vi kan definiera ett namnområde i ett annat namnområde enligt följande:
namespace namespace_name1 {// code body of namespace_name1 namespace namespace_name2 {// code body nested namamespace_name2}}Med detta kommer vi till ett slut på Namespace in C ++ - artikeln. Jag hoppas att du fick en uppfattning om vad som exakt är ett namnområde i C ++ och vad är de olika sätten att definiera det. Om du vill veta mer, kolla in av Edureka, ett pålitligt inlärningsföretag online. Edurekas Java J2EE- och SOA-utbildning och certifieringskurs är utformad för att träna dig för både grundläggande och avancerade Java-koncept tillsammans med olika Java-ramverk som Hibernate & Spring.
Har du en fråga till oss? Vänligen nämna det i kommentarsektionen på den här bloggen så kommer vi tillbaka till dig så snart som möjligt.