logo

TechCodeview

Namespace in C++ | Set 1 (Einführung)

  • Namespaces bieten den Raum, in dem wir Bezeichner, d. h. Variablen, Methoden und Klassen, definieren oder deklarieren können.
  • Mithilfe des Namensraums können Sie den Raum oder Kontext definieren, in dem Bezeichner definiert werden, z. B. Variablen, Methoden und Klassen. Im Wesentlichen definiert ein Namespace einen Bereich.

Vorteil des Namespace zur Vermeidung von Namenskollisionen.

  • Beispielsweise schreiben Sie möglicherweise Code mit einer Funktion namens xyz() und es ist eine andere Bibliothek verfügbar, die ebenfalls über dieselbe Funktion xyz() verfügt. Jetzt kann der Compiler nicht mehr wissen, auf welche Version der Funktion xyz() Sie sich in Ihrem Code beziehen.
  • Ein Namespace soll diese Schwierigkeit überwinden und als zusätzliche Information verwendet werden, um ähnliche Funktionen, Klassen, Variablen usw. mit demselben Namen, die in verschiedenen Bibliotheken verfügbar sind, zu unterscheiden.
  • Das beste Beispiel für den Namespace-Bereich ist die C++-Standardbibliothek (std), in der alle Klassen, Methoden und Vorlagen deklariert sind. Daher schließen wir beim Schreiben eines C++-Programms normalerweise die Direktive using namespace std ein;

Definieren eines Namespace:

  • Eine Namespace-Definition beginnt mit dem Schlüsselwort namespace, gefolgt vom Namespace-Namen wie folgt:
namespace namespace_name { // code declarations i.e. variable (int a;) method (void add();) classes ( class student{};) }>
  • Es ist zu beachten, dass nach der schließenden Klammer kein Semikolon (;) steht.
  • Um die Namespace-fähige Version einer Funktion oder Variable aufzurufen, stellen Sie den Namespace-Namen wie folgt voran:
  • namespace_name: :code; // Code kann eine Variable, eine Funktion oder eine Klasse sein.

Die using-Direktive:

  • Sie können das Voranstellen von Namespaces auch mit der Direktive using namespace vermeiden. Diese Anweisung teilt dem Compiler mit, dass der nachfolgende Code Namen im angegebenen Namespace verwendet.
  • Der Namespace ist somit für den folgenden Code impliziert:

C++








#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> 

>



>

Ausgabe 

Inside first_space>
  • Namen, die in einer using-Direktive eingeführt werden, unterliegen den normalen Gültigkeitsregeln. Der Name ist vom Punkt der using-Direktive bis zum Ende des Bereichs, in dem die Direktive gefunden wird, sichtbar. Entitäten mit demselben Namen, die in einem äußeren Bereich definiert sind, werden ausgeblendet.

Verschachtelte Namespaces:

  • Namespaces können verschachtelt sein, wobei Sie wie folgt einen Namespace innerhalb eines anderen Namespace definieren können:
SYNTAX: namespace namespace_name1 { // code declarations namespace namespace_name2 { // code declarations } }>

Sie können auf Mitglieder eines verschachtelten Namespace zugreifen, indem Sie Auflösungsoperatoren wie folgt verwenden:
// um auf Mitglieder von namespace_name2 zuzugreifen
Verwenden des Namensraums namespace_name1::namespace_name2;
// um auf Mitglieder von namespace_name1 zuzugreifen
Verwenden des Namensraums namespace_name1;

Wenn Sie in den obigen Anweisungen namespace_name1 verwenden, werden Elemente von namespace_name2 wie folgt im Bereich verfügbar gemacht:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> >// This calls function from second name space.> >func();> > >return> 0;> }> 

>

>

Ausgabe 

Inside second_space>

Lassen Sie uns sehen, wie der Namespace die Entitäten einschließlich Variablen und Funktionen abdeckt:

Java-Array zum Auflisten

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space :: func();> >// Calls function from second name space.> >second_space :: func();> >return> 0;> }> 

>

>

Ausgabe 

Inside first_space Inside second_space>

Betrachten Sie das folgende C++-Programm:

CPP




// A program to demonstrate need of namespace> int> main()> {> >int> value;> >value = 0;> >double> value;>// Error here> >value = 0.0;> }> 

>

>

Ausgabe :

Compiler Error: 'value' has a previous declaration as 'int value'>

In jedem Bereich kann ein Name nur eine Entität darstellen. Es können also nicht zwei Variablen mit demselben Namen im selben Bereich vorhanden sein. Mithilfe von Namespaces können wir zwei Variablen oder Mitgliedsfunktionen mit demselben Namen erstellen.

CPP




// Here we can see that more than one variables> // are being used without reporting any error.> // That is because they are declared in the> // different namespaces and scopes.> #include> using> namespace> std;> // Variable created inside namespace> namespace> first {> int> val = 500;> }> // Global variable> int> val = 100;> int> main()> {> >// Local variable> >int> val = 200;> >// These variables can be accessed from> >// outside the namespace using the scope> >// operator ::> >cout << first::val <<>' '>;> >return> 0;> }> 

>

>

Ausgabe 

500>

Definition und Erstellung: Namespaces ermöglichen es uns, benannte Entitäten zu gruppieren, die dies sonst getan hätten globalen Geltungsbereich in engere Bereiche und geben sie Namespace-Bereich . Dies ermöglicht die Organisation der Programmelemente in verschiedenen logischen Bereichen, auf die durch Namen verwiesen wird. Namespaces bieten den Raum, in dem wir Bezeichner definieren oder deklarieren können, d. h. Namen von Variablen, Methoden, Klassen usw.

  • Ein Namespace ist eine in C++ hinzugefügte Funktion und ist in C nicht vorhanden.
  • Ein Namespace ist ein deklarativer Bereich, der den darin enthaltenen Bezeichnern (Namen von Funktionen, Variablen oder anderen benutzerdefinierten Datentypen) einen Gültigkeitsbereich bietet.
  • Es sind mehrere Namespace-Blöcke mit demselben Namen zulässig. Alle Deklarationen innerhalb dieser Blöcke werden im benannten Bereich deklariert.

Eine Namespace-Definition beginnt mit dem Schlüsselwort Namensraum gefolgt vom Namespace-Namen wie folgt:

namespace namespace_name { int x, y; // code declarations where // x and y are declared in // namespace_name's scope }>
  • Namespace-Deklarationen erscheinen nur im globalen Bereich.
  • Namespace-Deklarationen können in einem anderen Namespace verschachtelt werden.
  • Namespace-Deklarationen haben keine Zugriffsspezifizierer (öffentlich oder privat).
  • Es ist nicht erforderlich, nach der schließenden Klammer der Namespace-Definition ein Semikolon anzugeben.
  • Wir können die Definition des Namespace auf mehrere Einheiten aufteilen.

Definieren eines Namespace:

Eine Namespace-Definition beginnt mit dem Schlüsselwort namespace, gefolgt vom Namespace-Namen wie folgt:

C++




namespace> namespace_name{> >// code declarations i.e. variable (int a;)> >method (>void> add();)> >classes (>class> student{};)> }> 

>

>

.net-Tutorial

Es ist zu beachten, dass nach der schließenden Klammer kein Semikolon (;) steht.
Um die Namespace-fähige Version einer Funktion oder einer Variablen aufzurufen, stellen Sie den Namespace-Namen wie folgt voran:

namespace_name: :code; // Code kann eine Variable, eine Funktion oder eine Klasse sein.

C++




// Let us see how namespace scope the entities including variable and functions:> #include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space::func();> >// Calls function from second name space.> >second_space::func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> // Inside second_space> 

>

>

Ausgabe 

Inside first_space Inside second_space>

Die using-Direktive:

Sie können das Voranstellen von Namespaces mit der Direktive using namespace vermeiden. Diese Anweisung teilt dem Compiler mit, dass der nachfolgende Code Namen im angegebenen Namespace verwendet. Der Namespace ist somit für den folgenden Code impliziert:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> 

>

>

Ausgabe 

Inside first_space>

Anstatt auf den gesamten Namespace zuzugreifen, gibt es eine andere Option (bekannt als verwenden Deklaration) dient dem Zugriff auf ein bestimmtes Element innerhalb eines Namespace. Wenn der einzige Teil des std-Namespace, den Sie beispielsweise verwenden möchten, cout ist, können Sie wie folgt darauf verweisen:
mit std::cout;
Nachfolgender Code kann auf cout verweisen, ohne den Namespace voranzustellen, aber andere Elemente im std-Namespace müssen weiterhin wie folgt explizit sein:

C++




#include> using> std::cout;> int> main ()> {> >cout <<>'std::endl is used with std!'> << std::endl;> >return> 0;> }> 

>

>

Ausgabe 

std::endl is used with std!>

Namen, die in einer using-Direktive eingeführt werden, unterliegen den normalen Gültigkeitsbereichsregeln, d. h. sie sind von dem Zeitpunkt an sichtbar, an dem die using-Direktive auftritt, bis zum Ende des Gültigkeitsbereichs, in dem die Direktive gefunden wird. Entitäten mit demselben Namen, die in einem äußeren Bereich definiert sind, werden ausgeblendet.

C++




// Creating namespaces> #include> using> namespace> std;> namespace> ns1 {> int> value() {>return> 5; }> }>// namespace ns1> namespace> ns2 {> const> double> x = 100;> double> value() {>return> 2 * x; }> }>// namespace ns2> int> main()> {> >// Access value function within ns1> >cout << ns1::value() <<>' '>;> >// Access value function within ns2> >cout << ns2::value() <<>' '>;> >// Access variable x directly> >cout << ns2::x <<>' '>;> >return> 0;> }> 

>

>

Ausgabe: 

5 200 100>

Klassen und Namespace: Im Folgenden finden Sie eine einfache Möglichkeit, Klassen in einem Namespace zu erstellen:

C++




// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns> {> >// A Class in a namespace> >class> geek> >{> >public>:> >void> display()> >{> >cout<<>'ns::geek::display()'>< } }; } int main() { // Creating Object of geek Class ns::geek obj; obj.display(); return 0; }> 

>

>

Alphabet und Zahlen
Ausgabe 

ns::geek::display()>

Eine Klasse kann auch innerhalb des Namespace deklariert und außerhalb des Namespace definiert werden unter Verwendung der folgenden Syntax:

CPP




// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns {> // Only declaring class here> class> geek;> }>// namespace ns> // Defining class outside> class> ns::geek {> public>:> >void> display() { cout <<>'ns::geek::display() '>; }> };> int> main()> {> >// Creating Object of geek Class> >ns::geek obj;> >obj.display();> >return> 0;> }> 

>

>

Ausgabe 

ns::geek::display()>

Wir können Methoden auch außerhalb des Namespace definieren . Das Folgende ist ein Beispielcode:

C++




Java aktualisieren
// A C++ code to demonstrate that we can define> // methods outside namespace.> #include> using> namespace> std;> // Creating a namespace> namespace> ns {> void> display();> class> geek {> public>:> >void> display();> };> }>// namespace ns> // Defining methods of namespace> void> ns::geek::display()> {> >cout <<>'ns::geek::display() '>;> }> void> ns::display() { cout <<>'ns::display() '>; }> // Driver code> int> main()> {> >ns::geek obj;> >ns::display();> >obj.display();> >return> 0;> }> 

>

>

Ausgabe: 

ns::display() ns::geek::display():>

Verschachtelte Namespaces:

Namensräume können verschachtelt sein, d. h. Sie können einen Namensraum wie folgt innerhalb eines anderen Namensraums definieren:

C++




namespace> namespace_name1 {> >// code declarations> >namespace> namespace_name2 {> >// code declarations> >}> }> 

>

>

Sie können auf die Mitglieder eines verschachtelten Namespace zugreifen, indem Sie den Auflösungsoperator (::) wie folgt verwenden:

C++




// to access members of namespace_name2> using> namespace> namespace_name1::namespace_name2;> // to access members of namespace:name1> using> namespace> namespace_name1;> 

>

>

Wenn Sie in den obigen Anweisungen namespace_name1 verwenden, werden die Elemente von namespace_name2 wie folgt im Bereich verfügbar gemacht:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> > >// This calls function from second name space.> >func();> > >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside second_space> 

>

>

Ausgabe 

Inside second_space>

Namespace bietet den Vorteil, dass Namenskollisionen vermieden werden:

Beispielsweise schreiben Sie möglicherweise Code mit einer Funktion namens xyz() und in Ihrem Code ist eine andere Bibliothek verfügbar, die ebenfalls über dieselbe Funktion xyz() verfügt. Jetzt kann der Compiler nicht mehr wissen, auf welche Version der Funktion xyz() Sie sich in Ihrem Code beziehen.
Ein Namespace soll diese Schwierigkeit überwinden und als zusätzliche Information verwendet werden, um ähnliche Funktionen, Klassen, Variablen usw. mit demselben Namen, die in verschiedenen Bibliotheken verfügbar sind, zu unterscheiden.
Das beste Beispiel für den Namespace-Bereich ist die C++-Standardbibliothek (std), in der alle Klassen, Methoden und Vorlagen deklariert sind. Daher fügen wir beim Schreiben eines C++-Programms normalerweise die Direktive ein
Verwenden des Namensraums std;

Namespace in C++ | Set 2 (Erweiternder Namespace und Unbenannter Namespace) Namespace in C++ | Satz 3 (Zugriff, Header erstellen, Verschachtelung und Aliasing) Können Namespaces in C++ verschachtelt werden? Referenz : http://www.cplusplus.com/doc/tutorial/namespaces/