Menü

Namespaces in C ++

namespaces c

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Eine vollständige Übersicht über Namespaces in C ++ mit einfachen Beispielen.

Bisher haben wir in unseren vorherigen Tutorials alles über Variablen, Deklarationen, Funktionen und andere solche Entitäten gesehen, die in C ++ verwendet werden.

Während der Entwicklung von Anwendungen in C ++ können einige besondere Situationen auftreten, z. B. die zweimalige Verwendung derselben Variablennamen oder Funktionen, die mit denselben Prototypen usw. definiert wurden. Wenn diese Szenarien auftreten, wird es für den Compiler schwierig, die richtige Variable oder den richtigen Funktionsaufruf abzuleiten, was zu Mehrdeutigkeiten führt .

=> Lesen Sie hier den perfekten C ++ - Schulungsleitfaden.

Namespaces in C ++

Was du lernen wirst:

Was ist ein Namespace?

Sehen Sie sich das folgende Beispiel an:

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

Ausgabe:

In der Funktion 'int main ()':
8:10: Fehler: widersprüchliche Deklaration 'double var'
7: 7: Hinweis: vorherige Erklärung als „int var“

Im obigen Beispiel haben wir zwei Variablen mit unterschiedlichen Typen, aber demselben Bezeichner definiert. Wenn wir dieses Beispiel kompilieren, erhalten wir einen Fehler, wie im Ausgabefenster gezeigt. Diese widersprüchlichen Deklarationen entstehen, weil derselbe Bezeichner zum Benennen von zwei Variablen verwendet wird.

Diese Art von Situationen führt zu Mehrdeutigkeiten bei Anwendungen.

C ++ führt etwas ein, das sich „ Namespaces ”, Um dieses Problem zu lösen. Der Namespace in C ++ ähnelt einem Paket, einer Region oder einer Bibliothek, mit der zwischen Variablen oder Funktionen mit denselben Bezeichnern unterschieden wird.

Ein Namespace kann Variablen, Funktionen, Klassen oder andere Objekte und sogar einen anderen Namespace enthalten. Auf jedes Mitglied des Namespace kann mithilfe eines Namespace-Bereichs verwiesen werden. Dies hilft dem Compiler, zwischen verschiedenen Programmiereinheiten zu unterscheiden, auch wenn diese denselben Namen haben.

Einen Namespace definieren

In C ++ können wir einen Namespace mit dem Schlüsselwort „ Namespace ' Wie nachfolgend dargestellt:

namespace namespace_name{ namespace_declarations; }

Wenn wir also einen Namespace mit dem Namen 'test_space' definieren müssen, können wir dies wie folgt tun:

namespace test_space{ int var=10; }

Die obige Deklaration definiert einen Namespace mit dem Namen 'test_space'. Wie gezeigt, hat es eine ganzzahlige Variable var als Mitglied.

Zugriff auf Namespace-Mitglieder

Jetzt haben wir unseren eigenen Namespace 'test_space' definiert und wie greifen wir auf den Inhalt dieses Namespace zu?

Im C ++ - Programm können wir mithilfe der folgenden Syntax auf die Mitglieder des Namespace zugreifen:

namespace_name::namespace_member;

Somit kann auf die im Namespace 'test_space' oben deklarierte Ganzzahlvariable var wie folgt zugegriffen werden:

test_space::var;

Im vollständigen Beispiel unten werden Namespaces und ihre Verwendung demonstriert.

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

Später zeigen wir beide Variablen an. Beachten Sie, dass die lokale Doppelvariable in der Hauptvariablen zwar direkt gedruckt werden kann, zum Drucken der Namespace-Variablen jedoch der Namespace-Name vorangestellt werden muss.

Dies hat auch das Problem von Konflikten zwischen den Variablen aufgrund der gleichen Namen behoben, die wir zuvor besprochen haben.

Die Verwendungsrichtlinie

In unserem vorherigen Thema haben wir gesehen, dass wir mit namespace_name :: namespace_member auf Namespace-Mitglieder zugreifen können.

Wenn wir nicht überall im Programm einen Namespace-Namen angeben möchten, können wir das “ mit Anweisung, den Namespace in das Programm aufzunehmen.

Dies geschieht wie folgt:

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

Diese sind:

using namespace std; using namespace test_space;

Die erste Anweisung verwendet die Deklaration, um auf den Namespace 'std' zuzugreifen, der ein vordefinierter Standard-Namespace in der C ++ - Bibliothek ist. Dieser Namespace wird verwendet, um auf verschiedene Funktionen wie cin, cout usw. zuzugreifen.

Die zweite Anweisung wird verwendet, um den Namespace 'test_space' in das Programm aufzunehmen.

In der Hauptfunktion können wir sehen, dass den Funktionen wie cout und variable var kein Namespace-Name vorangestellt werden muss. Wir können direkt auf sie verweisen. Da var jedoch einen Namenskonflikt mit einer lokalen Variablen in der Hauptfunktion hat, verweisen wir ihn mit dem Bereichsauflösungsoperator (: :), da Namespaces auch immer einen globalen Bereich haben.

Verschachtelte Namespaces

In C ++ können auch verschachtelte Namespaces verwendet werden, d. H. Ein Namespace, der in einem anderen Namespace definiert ist.

Die allgemeine Syntax verschachtelter Namespaces lautet wie folgt:

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

Wenn wir auf ns2_code zugreifen müssen, können wir wie folgt darauf zugreifen:

ns1::ns2::ns2_code;

Lassen Sie uns die verschachtelten Namespaces anhand des folgenden Codebeispiels demonstrieren.

#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 = '<

Wir können den Alias ​​für einen Namespace demonstrieren, indem wir das obige Beispiel ändern.

#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 = '<Externe Namespaces

Wenn wir zu viele Namespaces für unsere Anwendung haben, möchten wir manchmal alle Namespaces in einer separaten Datei platzieren. Dies kann leicht durchgeführt werden. Wenn sich die Namespaces in der separaten Datei befinden, nehmen wir diese Datei einfach in unser Programm auf und verwenden dann direkt die Namespaces und deren Inhalte in unserem Programm.

Zum Beispiel, wenn wir eine Datei mit dem Namen ns.h haben, die den folgenden Namespace enthält.

//ns.h namespace first{ int var = 25; }

Jetzt können wir in unserem Programm den Namespace 'first' wie folgt verwenden:

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

Sobald wir also die Datei mit den Namespaces in unser Programm aufgenommen haben, können wir die Namespaces so verwenden, als ob sie global im selben Programm deklariert wären.

Aneinandergrenzende Namespaces

Mit C ++ können wir auch so genannte zusammenhängende Namespaces definieren. Aneinandergrenzende Namespaces sind die Namespaces, die mehrmals mit demselben Namen definiert werden. In Wirklichkeit sind dies keine separaten Namespaces, sondern die Erweiterungen desselben Namespaces.

Zusammenhängende Namespaces sind im folgenden Beispiel ersichtlich.

#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 = '<

Fazit

Damit sind wir am Ende dieses Tutorials zu Namespaces in C ++ angelangt. Namespaces auf eine Weise, die es uns ermöglicht, unseren Code in verschiedene Bereiche oder Regionen zu unterteilen, damit wir Klarheit beim Lesen und auch bei der Verwendung seiner Mitglieder haben.

In unseren nachfolgenden Tutorials erfahren Sie mehr über die verschiedenen grundlegenden Themen von C ++ wie Ausnahmebehandlung, Dateieingabe / -ausgabe usw.

=> Hier finden Sie A-Z der C ++ - Schulungsanleitungen.

Literatur-Empfehlungen

^