Arrays

In C++ gibt es wie in vielen anderen Sprachen Arrays. Dies sind Variablen, welche nicht einen Speicherblock, sondern X Speicherblöcke eines Typen enthalten:
int array[10];

Die Variable array enthält nun 10 int:

0 1 2 3 4 5 6 7 8 9



Der Zugriff auf ein Array erfolgt in C++ per Index, das erste Element eines Arrays hat dabei immer den Index 0. Der letzte Index in unserem int array ist also 9. Bei der Deklaration kann man ein Array auch gleich initialisieren, sofern es sich um einen Standardtypen (int, float etc.) handelt:
int array[10]={1,2,3,4,5,6,7,8,9,10};
int value = array[5];
size_t arraysize = sizeof(array)/sizeof(array[0]);



Den 10 Elementen des Arrays  werden hier die Werte 1-10 zugewiesen. In der nächsten Zeile wird der Variablen value der Wert aus dem 6. Arrayelement (Indexzugriff!) zugewiesen. Die Größe eines solchen statischen Arrays lässt sich mittels sizeof(array)/sizeof(array[0]) ermitteln. Hierbei gibt sizeof(array) die Größe des Arrays im Speicher zurück, und sizeof(array[0]) die Größe eines Arrayelementes im Speicher.

 

Dynamische Arrays

Häufig weiß man zum Zeitpunkt des compilierens noch nicht, wie groß das Array sein soll. C++ kennt dynamische Arrays. Diese lassen sich mit new auf dem Heap anlegen (dazu später mehr), direkt auf dem Stack wie in C99 geht es leider nicht:
int n;
std::cin >> n;
int array[n];


Die Variable n wird  hier mittels std::cin, der C++ Standardeingabe vom Programmbenutzer abgefragt, und danach ein Array von n Elementen angelegt. Allerdings wird dieser Code nicht von allen Compilern übersetzt, da er kein gültiges C++ darstellt. Der C99 Standard von C ist nicht Teil des C++ Standards, und dieser erlaubt genau dies nicht. Aber es gibt eine Alternative, und dies sind Arraycontainer.

Arraycontainer

 

Nun haben wir ja mit Arrays eine simple Form von Container kennen gelernt. Häufig aber möchte  man einfach eine Möglichkeit für eine Ablage von Zahlen oder anderen Daten in einem Array, was sich auch dynamisch der Größe anpassen kann. Auch möchte man vielleicht nicht die Größe des Arrays vom Benutzer abfragen. Genau für diesen Zweck gibt es Container, sie enthalten einen bestimmten Typ, und kümmern sich um die Speicherverwaltung etc. für dessen 'Lagerung'.
Die STL kennt viele solcher Containertypen, für den Anfang bleiben wir mit std::vector<T> bei den Arrays. Die Klasse vector ist ein Template, welches einen Parameter T besitzt. T ist eine art Platzhalter für den eigentlichen Typen. So kann man einen std::vector<float> oder auch einen std::vector<int> erstellen. std::vector ist im Header <vector> definiert.

Ein kurzes Beispiel:
std::vector<int> vec;//(1)
vec.push_back(0);//(2)
int x = 42;
vec.push_back(x);//(3)
std::cout <<
vec.size() << std::endl;//(4)
vec[0]=23;//(5)

 

  1. Es wird eine Variable vom Typ std::vector<int> mit Namen 'vec' erstellt. Die Variable soll also eine Sammlung an ints verwalten.
  2. Mit push_back kann mein Element in den Vector einfügen. Dieses wird immer hinten angehangen. Mit push_front lässt sich ein Element vorne einfügen.
  3. Der Wert der Variablen x wird in den Vector gepusht.
  4. Die Größe des Vector wird nach cout ausgegeben.
  5. Das erste Element des Vector wird mit dem Wert 23 belegt.

Eine Variable der Klasse std::vector verhält sich also ähnlich wie die eines Arrays, lässt sich aber zur Laufzeit in der Größe verändern.
Nun bietet std::vector viele Vorteile, aber gerade wenn man diese Dynamik in der Speicherverwaltung nicht benötigt wird, und man auch das Anlegen des Arrays nicht erst zur Laufzeit will, so kann man diese Vorteile durchaus auch als Nachteile betrachten, da man sie in diesem Usecase nicht benötigt.

Bisher blieb hier nur der Rückgriff auf statische Arrays wie oben gezeigt. Mit C++11 gibt es nun einen neuen STL Container dafür: std::array<T,N>. Das T dient hierbei als Platzhalter für den Datentypen des Arrays, und N steht für die gewünschte Arraygröße: 


std::array<int,10> array;


erstellt ein int array mit 10 Elementen. std::array ist im Header <array> definiert. Als STL Container hat array damit auch einige Vorteile gegenüber eines normalen Arrays, so kann man die Größe jederzeit mit size() abfragen.