Benutzer:Koschi/Kontainer der STL

Aus Spieleprogrammierer-Wiki
Wechseln zu: Navigation, Suche

In der Spieleentwicklung ist es oft nötig, ein gewisse Menge an identischen Daten zu verwalten. Um die Verwaltung der Daten nicht nicht von Grund auf selber zu programmieren bietet die Standard Template Libary eine umfangreiche Sammlung an Kontainern, die das Verwalten der Daten erheblich erleichtert. Die Arbeitsweise und wofür die Verschiedenen Kontainer sind soll in diesem Artikel näher beschrieben werden.

Inhaltsverzeichnis

Was ist ein Kontainer

Einen Kontainer kann man sich als Behältnis für Daten vorstellen, diese Daten werden auch Elemente genannt. Einen bekannter (nicht STL) Kontainer, den wohl jeder bereits kennt und benutzt hat, ist ein simples eindimenionales Array. Der Vorteil bei den STL Kontainer ist, dass die Anzahl der Elemente in den meinsten Fällen dynamisch wachsen können. Es spielt dabei keine Rolle ob diese Daten Structs, Klassen oder eines der Grunddatentypen sind. Wie das "Befüllen" mit Daten erfolgt, hängt aber vom Konatainer selber ab, da sich die Interne Datenstrukture von Kontainertyp zu Kontainertyp unterscheiden kann. Bedingt durch den Aufbau der Kontainer kann man diese in 3 Kategorien aufteilen:

Um die Verwaltung des benötigten Speichers, kümmern sich die Kontainer selber.

Sequentielle Kontainer

Die Daten in einem Sequentiellen Kontainer liegen in der Reihenfolge vor wie sie Eingefügt wurden. Das heist wurde ein Element als drittes hinzugefügt ist es auch später wieder an dieser stelle zu finden. Für Sequentielle Kontainer kann ein Iterator erstellt werde, der es ermöglicht alle Elemente des Kontainers über eine Schleife zu erreichen.

Zu den Sequentille Kontainer gehören:

Assoziative Kontainer

Die Assoziative Kontainer können weiter unterteilt werden in Map- und Set-Kontainer, sowie jeweils in eine multi Version. An welche Stelle im Kontainer die Elemente eingeordnet werden, kann über eine eigene Vergleichsfunktion bestimmt werden.

Mit C++11 wurden noch jeweils eine ungeordnete Versionen eingeführt. Ungeordnet heist in diesem Zusammenhang aber nur, dass nicht die Möglichkeit gegeben ist eine (eigene) Vergleichsfunktion einzusetzen. Intern arbeiten diese ungeordneten Kontainer mit Hashwerten, der Zugriff auf die Daten ist so wesentlich schneller. Es besteht aber die Möglichkeit einen eigenen Hash-Algorithmus einzusetzen, um die Reihenfolge der Daten festzulegen.

Der Zugriff auf ein Elemente kann bei allen Assoziative Kontainer über einen Schlüssel erfolgen. Die Map-Kontainer besitzen ein Schlüssel-Werte-Paar, Schlüssel und Wert können (müssen aber nicht) unterschiedliche Datentypen sein. Die Set-Kontainer besitzen lediglich den Schlüssel, der gleichzeitig auch den Wert darstellt. Der Schlüssel darf dabei nur einmalig im Kontainer vorkommen, es sei den es handelt sich um die multi Version, hier darf der Schlüssel mehrfach vorkommen.

Für Assoziative Kontainer kann ein Iterator erstellt werde, der es ermöglicht alle Elemente des Kontainers über eine Schleife zu erreichen.

Zu den Assoziative Kontainer gehören:

Kontaineradapter

Die Kontaineradapter sind spezielle Varianten von Sequentiellen Kontainer oder Assoziative Kontainer. Diese Kontainer sind auf besondere Aufgaben zugeschnitten, deshalb ist das Interface einfach gehalten und verzichtet auf Iteratoren.

Zu den Kontaineradapter gehören:

Allgemeines

Die Kontainer der Standard Template Libary befinden sich im Namensraum std.

Klassen und Structs sollten Kopierbar sein, dass heißt einen public Kopierkonstruktor haben. Sind sie nicht Kopierbar, müssen die Structs oder Klassen Moveable sein, dieses funktioniert aber nur solange die Objekte nicht Kopiert werden. Moveable bedeutet in diesem Zusammenhang, dass die Klassen oder Structs einen Movekonstruktor benötigen, dann kann die Instanz der Klasse mit der Funktion std::move(T) herumgereicht werden.

Einige Kontainer benötigen bei bestimmten Operationen ein public default Konstruktor oder ein public Gleichheits-Operator, welche bei Klassen oder Structs dann Implementiert werden muss. Geordnete Assoziative Kontainer benötigen, von den Klassen und Structs, einen öffentlichen Vergleichs-Operator.

Header

In folgender Tabelle sind die Header ersichtlich, die Includiert werden müssen, damit der entsprechende Kontainer genutzt werden kann.

Kontainer Name #include
array <array>
deque <deque>
forward_list <forward_list>
list <list>
vector <vector>
map <map>
multimap
unordered_map <unordered_map>
unordered_multimap
set <set>
multiset
unordered_set <unordered_set>
unordered_multiset
priority_queue <queue>
queue <queue>
stack <stack>

Klassenfunktionen

Funktion Deklaration Erklärung Wer
assign 1) void assign (InputIterator first, InputIterator last);

1) Übernimmt vom Iterator first bis Iterator last alle Elemente

2) Übernimmt n mal den Wert von val

3) Übernimmt Werte aus einer std::initializer_list

deque
forward_list
list
vector
2) void assign (size_type n, const T& val);
3) void assign (initializer_list<T> il);

Code-Beispiel

deque

#include <deque>
 
int main()
{
    std::deque myContainer;
    return 0;
}

forward_list

#include <forward_list>
 
int main()
{
    std::forward_list myContainer;
    return 0;
}

list

#include <list>
 
int main()
{
    std::list myContainer;
    return 0;
}

vector

#include <vector>
 
int main()
{
    std::vector myContainer;
    return 0;
}
at 1) T& at (size_type n); Git das n-te Element zurück,
bei 1) als Referenz
bei 2) als Konstante Referenz
vector
2) const T& at (size_type n) const;

Laufzeitverhalten

Diagramm Laufzeitverhalten für O(1), O(log n) und O(n)

Eine direkte Zeitangabe ist wenig sinvoll, da diese auch von der Hardware abhängig ist. Das Laufzeitverhalten beschreibt, wie sich der Zeitaufwand ändert, wenn sich die Anzahl der Elemente im Kontainer erhöt. Da es bei großen Projekten oft auch um Geschwindikeit geht, kann hier schon im Vorfeld die Richtige wahl, Refactoring vermeiden.

Bedeutung:

Kontainer Name array deque forward_list list vector
Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende
Element zugriff O(1) O(1) O(1) N/A O(1) N/A O(1) O(1)
Element einfügen N/A O(1) O(n) O(1) O(1) O(n) O(1) O(n) O(1) O(n) O(1)
Element löschen N/A O(1) O(1) O(n) O(1) O(1) O(n O(1) O(n) O(1)
Element finden N/A
Kontainer Name map multimap unordered_map unordered_multimap
Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende
Element zugriff O(log n) O(log n) O(1)+ O(1)+
Element einfügen O(log n) O(log n) O(1)+ O(1)+
Element löschen O(log n) O(log n) O(1)+ O(1)+
Element finden O(log n) O(log n) O(1)+ O(1)+
Kontainer Name set multiset unordered_set unordered_multiset
Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende Beginn Mitte Ende
Element zugriff O(log n) O(log n) O(1)+ O(1)+
Element einfügen O(log n) O(log n) O(1)+ O(1)+
Element löschen O(log n) O(log n) O(1)+ O(1)+
Element finden O(log n) O(log n) O(1)+ O(1)+
Kontainer Name priority_queue queue stack
Größter Wert nicht Größter Wert Beginn Mitte Ende Beginn Mitte Ende
Element zugriff O(1) N/A O(1) N/A O(1) O(1) N/A
Element einfügen O(log n) N/A O(1) O(1) N/A
Element löschen O(log n) N/A O(1) N/A O(1) N/A
Element finden N/A
Meine Werkzeuge
Namensräume
Varianten
Aktionen
Navigation
Werkzeuge