, overveje en situation, hvor vi har to personer med samme navn, zara, i samme klasse.når vi skal differentiere dem helt klart, vil vi være nødt til at bruge nogle supplerende oplysninger sammen med deres navn, som enten det område, hvis de bor i forskellige område eller deres mor eller far navn osv. samme situation kan opstå i din c + + ansøgninger.f.eks. kan du skrive en kode, som har en funktion, kaldet xyz(), og der er et bibliotek, der er til rådighed, hvilket også har samme funktion xyz().- de har ingen chance for at vide, hvilken version af xyz() funktion, de henviser til i deres kode.,, namespace, har til formål at overvinde denne vanskelighed, og som anvendes som supplerende oplysninger til at differentiere lignende funktioner, klasser, variabler osv. med samme navn, der er til rådighed i forskellige biblioteker.ved hjælp af namespace, kan du definere de rammer, inden for hvilke navne er defineret.i grunden en namespace definerer anvendelsesområdet. fastlæggelse af en namespace: en namespace definition begynder med nøgleord namespace, efterfulgt af namespace navn som følger:, namespace namespace_name (//kode erklæringer}, til at opfordre de namespace mulighed for version af enten funktion eller variabel, prepend attributterne namespace navn som følger: navn:: kode; //kode kan være variabel eller funktion.lad os se, hvordan namespace anvendelsesområde de enheder, herunder variable og funktioner:,&#omfatter < iostream > anvendelse af namespace std; //fornavn rum namespace first_space {tomrum func() {cout < < "i first_space" < < endl.;}} //andet navn rummet namespace second_space {tomrum func() {cout < < "i second_space" < < endl.;}} int vigtigste () (//calls funktion fra første navn rum.first_space: func(); //calls funktion fra andet navn rum.second_space: func(); tilbage 0}, hvis vi samler og løber over kode, vil det føre til følgende resultat: i first_space i second_space, ved hjælp af direktiv: kan man også undgå prepending af namespaces med, ved hjælp af namespace direktiv.dette direktiv viser de, at den efterfølgende kode gør brug af betegnelser i den angivne namespace.attributterne namespace er således indebar for følgende kode:,&#omfatter < iostream > anvendelse af namespace std; //fornavn rum namespace first_space {tomrum func() {cout < < "i first_space" < < endl.;}} //andet navn rum namespace second_space {ugyldige func() {cout < < "i second_space" < < endl.;}} med namespace first_space; int vigtigste () (//dette opkald funktion fra første navn rum.func(); tilbage 0}, hvis vi samler og løber over kode, vil det føre til følgende resultat: i first_space, ved hjælp af direktiv kan også anvendes til at referere til et bestemt punkt i en namespace.for eksempel, hvis kun en del af std namespace, at de agter at anvende, er cout, du kan henvise til det som følger: ved hjælp af std: cout; efterfølgende kode kan henvise til cout uden prepending attributterne namespace, men andre poster i, std, namespace skal være eksplicitte som følger:,&#omfatter < iostream > anvendelse af std: cout; int vigtigste () (cout < < "std: endl. anvendes med std."< < std: endl., tilbagevenden 0}, hvis vi samler og løber over kode, vil det føre til følgende resultat:, std: endl. anvendes med std.navn, der blev indført i en anvendelse af direktiv overholde normale anvendelsesområde regler.navnet er synlige på grund af den ved direktiv til udgangen af anvendelsesområdet, som direktivet er fundet.enheder med samme navn som defineret i en ydre anvendelsesområde er skjult. discontiguous namespaces: en namespace kan defineres i flere dele, og så en namespace består af summen af dets særskilt defineret dele.de forskellige dele af en namespace kan spredes over flere filer, så hvis en del af namespace kræver et navn som defineret i en anden sag, at navn skal angives.at skrive følgende namespace definition hverken definerer en ny namespace og tilføjer nye elementer til en eksisterende:, namespace namespace_name (//kode erklæringer}, indlejrede namespaces:, namespaces kan indføjes, hvor man kan definere en namespace i et andet navn rum som følger:, namespace namespace_name1 (//kode erklæringer namespace namespace_name2 (//kode erklæringer), kan du få medlemmer af indlejrede namespace ved hjælp af resultion operatører som følger: //adgang til medlemmer af namespace_name2 ved hjælp af namespace namespace_name1: namespace_name2; //adgang til medlemmer af namespace: name1 ved hjælp af namespace namespace_name1; i ovennævnte udtalelser, hvis du bruger namespace_name1, så vil det få elementer af namespace_name2 til rådighed i anvendelsesområdet som følger:,&#omfatter < iostream > anvendelse af namespace std; //fornavn rum namespace first_space {tomrum func() {cout < < "i first_space" < < endl.;} //andet navn rum namespace second_space {tomrum func() {cout < < "i second_space" < < endl.;}}} med namespace first_space: second_space; int vigtigste () (//dette opkald funktion fra andet navn rum.func(); tilbage 0}, hvis vi samler og løber over kode, vil det føre til følgende resultat: i second_space,