Du bist hier: Startseite > Entwicklung (C/C++) > C++ Grundlagen > Namespaces in C++

Namespaces in C++

Namensräume wurden erschaffen, um Namenskonflikte zu unterbinden. In fast allen Tutorials hast du auf einen Namespace zugegriffen! Die Befehle cout und endl liegen im Namensraum std. Der Zugriff sieht folgendermassen aus: namensraum::element. Die 2 Doppelpunkte sind dabei der Scope Operator, mit dem man in denn Namensraum rein gehen kann. Ein Element was in einem Namensraum liegt, und auf ein anderes Element im gleichen Namensraum zugreifen will, muss denn Namensraum und denn Scope Operator nicht angeben. Ein Element kann z. B. eine Funktion, Klasse, Datenstruktur, Variable, Konstante oder ein weiterer Namensraum sein.

Der Zugriff auf einen Namespace

Ein Namensraum kann auch mit dem Schlüsselwort "using" als Standart gesetzt werden.
Das bedeutet, dass bei einem Aufruf nicht der Name vom Namensraum mit dem Scope Operator (::) vor den Befehl notiert werden müssen.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. using namespace std;
  5.  
  6. int main(void)
  7. {
  8. 	cout << "count Aufruf aus dem Namensraum std" << endl;
  9.  
  10. 	cin.get();
  11. 	return EXIT_SUCCESS;
  12. }

Es können auch nur bestimmte Elemente aus einem Namespace als Standart gesetzt werden.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. using std::cout;
  5. using std::endl;
  6.  
  7. int main(void)
  8. {
  9. 	cout << "cout und endl Aufruf aus dem Namespace std" << endl;
  10.  
  11. 	std::cin.get(); // Wurde nicht mit using angegeben, daher "std::"
  12.         return EXIT_SUCCESS;
  13. }

Definieren von einem Namespace

Im folgenden Beispiel werden wir einen Namensraum erstellen, denn wir dann separat in eine Datei auslagern. Nachdem ein neues Projekt mit der nötigen main.cpp Datei erstellt worden ist, erstellen wir nun eine neue Headerdatei Namens "namensraum.h".

Datei:  Headerdateien/namensraum.h
  1. #ifndef NAMENSRAUM_H
  2. 	#define NAMENSRAUM_H
  3. 	namespace namensraum
  4. 	{
  5. 		class klassenname
  6. 		{
  7. 			public:
  8. 				void methodenname(void); // Methode für Klasse im Namespace deklarieren
  9. 		};
  10.  
  11. 		void funktionsname(void); // Funktion im Namespace deklarieren
  12.  
  13. 		namespace  weiterer_namensraum
  14. 		{
  15. 			void funktionsname(void); // Funktion im Namespace::Namespace deklarieren
  16. 		}
  17. 	}
  18. #endif

Da die Headerdatei mehrmals eingebunden werden kann, stellen wir mit #ifndef zuerst sicher, dass sie nicht schon eingebunden worden ist und deklarieren die Symbolische Konstante NAMENSRAUM_H. Ein Namensraum wird mit dem Schlüselwort namespace eingeleitet. Danach wird der Name für den Namensraum (hier namensraum) festgelegt und die geschweiften Klammern umschliessen alles was darin alles enthalten ist. Im Beispiel wird im Namensraum eine Klasse deklariert mit einer Methode. Danach kommt eine einzelne Funktion und zum Schluss wird im Namensraum ein weiterer Namensraum (hier weiterer_namensraum) erstellt. Dieser Namensraum hat ebenfalls nur eine Funktion.
Als nächstes muss noch die Quelldatei namensraum.cpp unter Quelldateien erstellt werden, in der der Namensraum mit seinem Inhalt noch definiert wird.

Datei:  Quelldateien/namensraum.cpp
  1. #include "namensraum.h"
  2. namespace namensraum
  3. {
  4. 	void klassenname::methodenname(void) // Methode für Klasse im Namespace definieren
  5. 	{
  6. 		std::cout << "\"klassenname::methodenname()\" aus dem Namespace \"namensraum\" aufgerufen!\n";
  7. 	}
  8.  
  9. 	void funktionsname(void) //Funktion im Namespace definieren
  10. 	{
  11. 		std::cout << "Funktion \"funktionsname()\" aus dem Namespace \"namensraum\" aufgerufen!\n";
  12. 	}
  13.  
  14. 	namespace weiterer_namensraum // Namespace im Namespace definieren
  15. 	{
  16. 		void funktionsname(void)
  17. 		{
  18. 			std::cout << "Funktion \"funktionsname()\" aus dem Namespace \"namensraum::weiterer_namensraum\" aufgerufen!\n";
  19. 		}
  20. 	}
  21. }

Hiermit ist der Namensraum fertig definiert und deklariert. Jetzt müssen wir die main.cpp etwas anpassen.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3. #include "namensraum.h"
  4.  
  5. int main(void)
  6. {
  7. 	namensraum::klassenname *cls = (new namensraum::klassenname);//Instanz in Pointer laden
  8. 	cls->methodenname();
  9.  
  10. 	namensraum::funktionsname(); // Direkter Funktionsaufruf im Namespace
  11.  
  12. 	namensraum::weiterer_namensraum::funktionsname(); // Direkter Funktionsaufruf im Namespace::Namespace
  13.  
  14. 	std::cin.get();
  15. 	return EXIT_SUCCESS;
  16. }

Wie das Beispiel zeigt, werden 2 identische Funktionen mit dem gleichen Namen aufgerufen. Der Namespace hat in diesem Fall eine Namenskollision verhindert, indem er beide Funktionen in verschiedene "Ebenen" verfrachtet hat.

Kommentare zu diesem Beitrag

Sie müssen angemeldet sein, um eine Nachricht zu erstellen. Anmelden »