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

Vectoren in C++

Ein Vector ist ein dynamisches Array. Vectoren haben anders als statische Arrays keine feste Größe, sondern passen sich der Anzahl der Elemente dynamisch an.

Hier mal ein Beispiel:

Datei:  Quelldateien/main.cpp
  1. #include <iostream>   // std::cout, std::endl, std::cin
  2. #include <stdlib.h>   // EXIT_SUCCESS
  3. #include <vector>     // std::vector
  4.  
  5. int main(void)
  6. {
  7. 	std::vector<int> vIMeinVector;
  8. 	vIMeinVector.push_back(12);
  9. 	vIMeinVector.push_back(51);
  10. 	std::cout << "Elemente insgesammt: " << vIMeinVector.size() << std::endl; // 2
  11. 	std::cout << "Inhalt von Element 1: " << vIMeinVector[0] << std::endl; // 12
  12. 	std::cout << "Inhalt von Element 2: " << vIMeinVector[1] << std::endl; // 51
  13.  
  14. 	std::cin.get();
  15. 	return EXIT_SUCCESS;
  16. }

Der Ausdruck std::vector<int> deklariert einen Vector, der mit Variablen vom Datentyp int umgehen kann. Da ein vector ein Template ist, steht zwischen < und > der Datentyp, der verwendet werden soll!
"std::cout << vIMeinVector.size();" ist ein Counter auf denn Index und gibt die Anzahl der definierten Elemente zurück!
Mit "vIMeinVector.push_back(12);" wird an das Ende vom Index ein neues Element angehangen mit dem Wert 12.
Mit "std::cout << vIMeinVector[0];" wird dann das erste Element mit dem Index 0 aufgerufen.

Vectoren können genau wie Array´s auch beim definieren direkt deklariert werden!

Datei:  Quelldateien/main.cpp
  1. #include <iostream>   // std::cout, std::endl, std::cin
  2. #include <stdlib.h>   // EXIT_SUCCESS
  3. #include <vector>     // std::vector
  4.  
  5. int main(void)
  6. {
  7. 	std::vector<int> vIMeinVector {3, 5, 7, 90, 9999};
  8. 	std::cout << "Insgesammte Elemente: " << vIMeinVector.size() << std::endl; // 5
  9. 	std::cout << "Inhalt von Element 3: " << vIMeinVector[3] << std::endl; // 90
  10.  
  11. 	std::cin.get();
  12. 	return EXIT_SUCCESS;
  13. }

Es ist natürlich darauf zu achten, dass nicht auf einen Index zugegriffen wird, der noch garnicht definiert und deklariert wurde!

Es kann auch direkt von vorn hinein die Größe des Vectors angegeben werden und alle Elemente mit einem Default Wert belegt werden.

Datei:  Quelldateien/main.cpp
  1. #include <iostream>   // std::cout, std::endl, std::cin
  2. #include <stdlib.h>   // EXIT_SUCCESS
  3. #include <vector>     // std::vector
  4.  
  5. int main(void)
  6. {
  7. 	std::vector<int> vIMeinVector(15, 2);
  8. 	std::cout << "Insgesammte Elemente: " << vIMeinVector.size() << std::endl;
  9. 	for (int iZaehler = 0; iZaehler < vIMeinVector.size(); ++iZaehler)
  10. 	{
  11. 		std::cout << "vIMeinVector[" << iZaehler << "] = " << vIMeinVector[iZaehler] << std::endl;
  12. 	}
  13.  
  14. 	std::cin.get();
  15. 	return EXIT_SUCCESS;
  16. }
  17.  

Das obige Beispiel legt einen Vector mit dem Index 15 an und weisst allen Elementen den Wert 2 zu!

Das nächste Beispiel zeigt, wie ein Vector dynamisch befüllt wird.

Datei:  Quelldateien/main.cpp
  1. #include <iostream>   // std::cout, std::endl, std::cin
  2. #include <stdlib.h>   // EXIT_SUCCESS
  3. #include <vector>     // std::vector
  4.  
  5. int main(void)
  6. {
  7. 	std::vector<int> vIMeinVector; // Vector mit Datentyp int anlegen
  8. 	int iZaehler; // Zähler für for-Schleife
  9. 	for (iZaehler = 0; iZaehler < 100; ++iZaehler)
  10. 	{
  11. 		vIMeinVector.push_back(iZaehler); // Fügt iZaehler ans Ende von vIMeinVector an.
  12. 		vIMeinVector[iZaehler]++; // Wert incrementieren (vIMeinVector[n] muss bereits existieren)
  13. 	}
  14. 	std::cout << "Elemente insgesammt: " << vIMeinVector.size() << std::endl;
  15. 	for (iZaehler = 0; iZaehler < vIMeinVector.size(); ++iZaehler)
  16. 	{
  17.                 // Wenn vIMeinVector[iZaehler] < 10 dann eine 0 voranstellen
  18. 		(vIMeinVector[iZaehler] < 10)
  19. 			? std::cout << "0" << vIMeinVector[iZaehler]
  20. 			: std::cout << vIMeinVector[iZaehler]
  21. 		;
  22. 		std::cout << " ";	 // Leerzeichen hinter jede Zahl setzten
  23. 		if ((iZaehler + 1) % 10 == 0)	 // Nach jeder 10ten Zahl zeilenumbruch setzten
  24. 		{
  25. 			std::cout << std::endl;
  26. 		}
  27. 	}
  28.  
  29. 	std::cin.get();
  30. 	return EXIT_SUCCESS;
  31. }

Weitere Vector Funktionen im Überblick

T steht in der nachfolgenden Tabelle für Datentyp, n für einen Index-Wert und val für einen Wert!

Anwendung Beschreibung
std::vector<T> vVector Deklariert vVector als leeren Vector, der Daten vom Typ T aufnimmt
std::vector<T> vVector(n) Deklariert vVector als Vector, der bereits n default-konstruierte Elemente vom Typ T enthält
std::vector<T> vVector(n, val) Deklariert vVector als vector, der bereits n Elemente vom Typ T mit dem Wert val enthält
std::cout << vVector[n]; Repräsentiert das n. Element in vVector (ohne zu prüfen, ob n existiert)
std::cout << vVector.at(n); Repräsentiert das n. Element in vVector (prüft, ob n im erlaubten Bereich liegt)
std::cout << vVector.size(); Liefert die Anzahl aller Elemente in vVector
std::cout << vVector.capacity(); Liefert die Anzahl der Elemente die in vVector gespeichert werden können
vVector.reserve(n); Setzt die Anzahl der Elemente von vVector auf n
vVector.push_back(val); Fügt die Daten aus val ans Index-Ende von vVector an
vVector.pop_back(); Entfernt das letzte Element aus vVector
int &rIVVector = vVector.front();
std::cout << rIVVector;		 Liefert eine Referenze auf das erste Element in vVector
int &rIVVector = vVector.back();
std::cout << rIVVector;		 Liefert eine Referenze auf das letzte Element in vVector
vVector2 = vVector; Erstellt vVector2 als eine Kopie von vVector (Vorher vVector2 instanzieren!)
vVector.clear(); Entfernt alle Elemente aus vVector; leert vVector


"vVector.at(n);" gibt bei ungültigem Index einen Exeption Handler vom Typ "std::out_of_range" zurück!

Hier ein try / catch Beispiel:

Datei:  Quelldateien/main.cpp
  1. #include <iostream>   // std::cout, std::endl, std::cin
  2. #include <stdlib.h>   // EXIT_SUCCESS
  3. #include <vector>     // std::vector
  4.  
  5. int main(void)
  6. {
  7. 	std::vector<int> vIMeinVector(3, 15);
  8. 	try
  9. 	{
  10. 		std::cout << vIMeinVector.at(10);
  11. 	}
  12. 	catch (std::out_of_range e)
  13. 	{
  14. 		std::cout << "Error: " <<  e.what() << std::endl;
  15. 	}
  16.  
  17. 	std::cin.get();
  18. 	return EXIT_SUCCESS;
  19. }

Natürlich können auch Klassen oder Daten-Strukturen mit Vectoren verknüpft werden. Wie sowas geht, zeigt folgendes Beispiel:

Datei:  Quelldateien/main.cpp
  1. #include <iostream>   // std::cout, std::endl, std::cin
  2. #include <stdlib.h>   // EXIT_SUCCESS
  3. #include <vector>     // std::vector
  4.  
  5. struct geoPosition
  6. {
  7. 	float latitude;
  8. 	float longitude;
  9. };
  10.  
  11. int main(void)
  12. {
  13. 	geoPosition myPosition{ 50.29155f, 6.66935f }; // Struct deklarieren
  14. 	std::vector<geoPosition> vVector(1, myPosition); // Vector definieren und mit myPosition deklarieren
  15. 	std::cout << "vVector[0].latitude: " << vVector[0].latitude << std::endl;
  16. 	std::cout << "vVector[0].longitude: " << vVector[0].longitude << std::endl;
  17.  
  18. 	std::cin.get();
  19. 	return EXIT_SUCCESS;
  20. }

Kommentare zu diesem Beitrag

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