Container

#include <tuple>

std::tuple<int, double, std::string> t = {42, 3.14159, "Hello!"};
std::tuple<T1, …, TN>
Konstruktion
tuple ();
explicit tuple (P1, …, PN);
tuple (const tuple &);
tuple (const std::pair &);
Modifikation
tuple & operator= (const tuple &);
tuple & operator= (const std::pair &);

Geordnete Listen

Array

Ein array ist eine Liste von Elementen mit fester Länge, effizient aber unflexibel.

#include <array>

std::array<int, 3> a = {1, 2, 3};
std::array<T, N>
Konstruktion
virtual ~vector (); Container
array (); Container
array (const array & right);Assignable
Modifikation
array & operator= (const array & right);Assignable
void assign (const T & val);
void swap (array & right); Container
Iteration
iterator begin (); Container
iterator end (); Container
reverse_iterator rbegin (); ReversibleContainer
reverse_iterator rend (); ReversibleContainer
Kapazität
bool empty () const; Container
size_type size () const; Container
size_type max_size () const; Container
Elementzugriff
T & at (size_type index);
T & operator[] (size_type index);
T & front ();
T & back ();
T * data (); Liefert die Adresse des ersten Elements.

Vektor

Ein vector bietet schnellen, indizierten Zugriff auf die Elemente. Dafür kostet Einfügen und Löschen viel Rechenzeit, sofern es nicht am Ende des Vektors stattfindet..

#include <vector>

const int x[] = { 2, 3, 5, 7, 11, 13, 17, 23 };
std::vector<int> v (x, x + sizeof (x));
std::vector<T>
Konstruktion
virtual ~vector (); Container
vector (); Container
vector (size_type n, const T & t); Sequence
vector (InputIterator first, InputIterator last); Sequence
vector (const vector & v); Assignable
Modifikation
vector & operator= (const vector & v); Assignable
vector & operator= (size_type n, const T & t);
vector & operator= (InputIterator first, InputIterator last);
iterator insert (iterator pos, const T & t); Sequence
iterator insert (iterator pos, size_type n, const T & t); Sequence
iterator insert (iterator pos, InputIterator first, InputIterator last); Sequence
iterator erase (iterator pos); Sequence
iterator erase (iterator first, iterator last);Sequence
void swap (vector & v); Container
void clear (); Sequence
void push_back (const T & t); BackInsertionSequence
void pop_back (); BackInsertionSequence
Iteration
iterator begin (); Container
iterator end (); Container
reverse_iterator rbegin (); ReversibleContainer
reverse_iterator rend (); ReversibleContainer
Kapazität
bool empty () const; Container
size_type size () const; Container
size_type max_size () const; Container
void resize (size_type n, const T & t);Sequence
size_type capacity () const; Liefert Anzahl der reservierten Elemente
void reserve (size_type n) const; Reserviert zusätzlichen Speicher
Elementzugriff
T & front (); FrontInsertionSequence
T & back (); BackInsertionSequence
T & operator[] (size_type index); RandomAccessContainer
T & at (size_type index); RandomAccessContainer

Doppelendige Schlange

#include <deque>
InputIterator last);
std::deque<T>
Konstruktion
virtual ~deque (); Container
deque (); Container
deque (size_type n, const T & t); Container
deque (InputIterator first, InputIterator last); Sequence
deque (const deque & d); Assignable
Modifikation
deque & operator= (const deque & d); Assignable
deque & operator= (size_type n, const T & t);
deque & operator= (InputIterator first,
void swap (deque & d); Container
iterator insert (iterator pos, const T & t); Sequence
iterator insert (iterator pos, size_type n, const T & t); Sequence
iterator insert (iterator pos, InputIterator first, InputIterator last); Sequence
iterator erase (iterator pos); Sequence
iterator erase (iterator first, iterator last);Sequence
void clear (); Sequence
void push_front (const T & t); FrontInsertionSequence
void pop_front (); FrontInsertionSequence
void push_back (const T & t); BackInsertionSequence
void pop_back (); BackInsertionSequence
Iteration
iterator begin (); Container
iterator end (); Container
reverse_iterator rbegin (); ReversibleContainer
reverse_iterator rend (); ReversibleContainer
Kapazität
bool empty () const; Container
size_type size () const; Container
size_type max_size () const; Container
void resize (size_type n, const T & t);Sequence
Elementzugriff
T & front (); FrontInsertionSequence
T & back (); BackInsertionSequence
T & operator[] (size_type index); RandomAccessContainer
T & at (size_type index); RandomAccessContainer

Doppelt verkettete Liste

Eine list erfordert langsames, lineares Suchen von Elementen. Dafür ist das Einfügen und Löschen Vorne und Hinten sowie an einer bekannten Position sehr schnell.

#include <list>
std::list<T>
Konstruktion
virtual ~list (); Container
list (); Container
list (size_type n, const T & t); Sequence
list (InputIterator first, InputIterator last); Sequence
list (const list & l); Assignable
Modifikation
list & operator= (const list & l); Assignable
list & operator= (size_type n, const T & t);
list & operator= (InputIterator first, InputIterator last);
iterator insert (iterator pos, const T & t); Sequence
iterator insert (iterator pos, size_type n, const T & t); Sequence
iterator insert (iterator pos, InputIterator first, InputIterator last); Sequence
iterator erase (iterator pos); Sequence
iterator erase (iterator first, iterator last); Sequence
void swap (list & l); Container
void clear (); Sequence
void push_front (const T & t); FrontInsertionSequence
void pop_front (); FrontInsertionSequence
void push_back (const T & t); BackInsertionSequence
void pop_back (); BackInsertionSequence
Iteration
iterator begin (); Container
iterator end (); Container
reverse_iterator rbegin (); ReversibleContainer
reverse_iterator rend (); ReversibleContainer
Kapazität
bool empty () const; Container
size_type size () const; Container
size_type max_size () const; Container
void resize (size_type n, const T & t); Sequence
Elementzugriff
T & front (); FrontInsertionSequence
T & back (); BackInsertionSequence
Listenspezifische Operationen
void splice (iterator pos, list & l);Verschiebt alle Elemente aus l an die Position pos.
void splice (iterator pos, list & l, iterator index); Verschiebt das Element index aus l an die Position pos.
void splice (iterator pos, list & l,
iterator first, iterator last); 		Verschiebt mehrere Elemente aus l an die Position pos.
void remove (const T & t); Entfernt alle mit t identischen Elemente.
void remove_if (Predicate p); Entfernt alle Elemente, für die p wahr liefert.
void unique (); Entfernt alle mehrfach vorkommenden Elemente.
void unique (BinaryPredicate p); Entfernt alle Elemente, für die p wahr liefert.
void merge (list & l); Vereinigt zwei sortierte Listen.
void merge (list & l, BinaryPredicate comp); Vereinigt zwei sortierte Listen.
void reverse (); Kehrt die Reihenfolge der Elemente um..
void sort (); Sortiert die Liste aufsteigend.
void sort (BinaryPredicate comp); Sortiert die Liste anhand des Kriteriums comp.

Adapter für Listen

Stapel (LIFO)

#include <stack>
std::stack<T>
Konstruktion
virtual ~stack (); Container
stack (); Container
Modifikation
stack & operator= (const stack & s); Assignable
void push (const T & t); Legt ein Element oben auf den Stack.
void pop (); Entfernt das oberste Element.
Kapazität
bool empty () const; Container
size_type size () const; Container
Elementzugriff
T & top (); Liefert das oberste Element.

Warteschlange (FIFO)

#include <queue>
std::queue<T>
Konstruktion
virtual ~queue (); Container
queue (); Container
Modifikation
queue & operator= (const queue & q); Assignable
void push (const T & t); Hängt ein Element hinten an die Schlange.
void pop (); Entfernt das vorderste Element.
Kapazität
bool empty () const; Container
size_type size () const; Container
Elementzugriff
T & front (); Liefert das vorderste Element.
T & back (); Liefert das hinterste Element.

Priorisierte Warteschlange

#include <priority_queue>
std::priority_queue<T>
Konstruktion
virtual ~priority_queue(); Container
priority_queue(); Container
Modifikation
priority_queue &operator=(const priority_queue & p);Assignable
void push (const T & t); Sortiert ein Element in die Schlange ein.
void pop (); Entfernt das größte Element.
Kapazität
bool empty () const; Container
size_type size () const; Container
Elementzugriff
T & top (); Liefert das größte Element.

Bitset

#include <bitset>
std::bitset<N>
Konstruktion
virtual ~bitset (); Container
bitset (); Container
bitset (const bitset & b); Assignable
bitset (unsigned long l); Umwandlung aus Zahl
Modifikation
bitset& operator= (const bitset & b); Assignable
bitset& operator= (unsigned long l); Umwandlung aus Zahl
bitset& operator= (std::string & s, size_type first = 0, size_type last = std::string::npos); Umwandlung aus String
bitset & operator&= (const bitset & b); Löscht alle Bits, die nicht in b gesetzt sind.
bitset & operator|= (const bitset & b); Setzt alle Bits, die in b gesetzt sind.
bitset & operator^= (const bitset & b); Exklusive ODER-Verknüpfung
bitset & operator<<= (size_type n); Schiebt die Bits um n Positionen nach links.
bitset & operator>>= (size_type n); Schiebt die Bits um n Positionen nach rechts.
bitset operator<< (size_type n) const; Kopie um n Positionen nach links verschobene.
bitset operator>> (size_type n) const; Kopie um n Positionen nach rechts verschobene.
bitset operator~ () const; Liefert das Komplement.
bitset & set (); Setzt alle Bits auf 1
bitset & set (size_type pos, int val = 1);Setzt das Bit an Position pos auf den Wert val.
bitset & reset (); Löscht alle Bits
bitset & reset (size_t pos); Löscht das Bit an Position pos.
bitset flip (size_t pos); Invertiert das Bit an Position pos.
Kapazität
size_type size () const; Liefert die Anzahl Bits.
Elementzugriff
bool operator[] (size_type index); Liefert den Wert eines bestimmtes Bits.
Bitset-Operationen
size_type count () const; Liefert die Anzahl gesetzter Bits.
bool test (size_t pos) const; Ist das Bit an Position pos gesetzt?
bool any () const; Ist mindestens ein Bit gesetzt?
bool none () const; Ist kein Bit gesetzt?
unsigned long to_ulong () const; Umwandlung in Zahl
std::string to_string () const; Umwandlung in String

Assoziative Container (Dictionaries)

Sortierte Menge

In einem set kommt jedes Element nur einmal vor. In einem multiset können Elemente auch mehrfach vorkommen. Die Elemente sind immer aufsteigend sortiert. Iteratoren bleiben beim Einfügen und Löschen gültig.

#include <set>
std::set<T>
bool operator== (const set & lhs, const set & rhs);ForwardContainer (Identität)
bool operator<(const set & lhs, const set & rhs);ForwardContainer (Vergleich)
typedef T value_type; Container
typedef value_type key_type; AssociativeContainer
typedef bool comp (V, V)value_compare StrictWeakOrdering
typedef value_comparekey_compare; StrictWeakOrdering
Konstruktion
virtual ~set (); Container
set (); Container
set (const key_compare & comp); SortedAssociativeContainer
set (InputIterator first, InputIterator last); UniqueSortedAssociativeContainer
set (InputIterator first, InputIterator last,
 const key_compare & comp);		 UniqueSortedAssociativeContainer
set (const set & s); Assignable (Kopier-Konstructor)
Modifikation
set & operator= (const set & s); Assignable (Kopier-Operator)
void swap (set & s); Container
iterator insert (const value_type & val); UniqueAssociativeContainer
iterator insert (iterator pos, const value_type & val); UniqueSortedAssociativeContainer
iterator insert InputIterator first, InputIterator last); UniqueSortedAssociativeContainer
iterator erase (const key_type & key);AssociativeContainer
iterator erase (iterator pos); AssociativeContainer
iterator erase (iterator first, iterator last);AssociativeContainer
void clear (); AssociativeContainer
Iteration
iterator begin (); Container
iterator end (); Container
reverse_iterator rbegin (); ReversibleContainer
reverse_iterator rend (); ReversibleContainer
Kapazität
bool empty () const; Container
size_type size () const; Container
size_type max_size () const; Container
Observation
key_compare key_comp () const; SortedAssociativeContainer
value_compare value_comp () const; SortedAssociativeContainer
Set-Operationen
iterator find (const key_type & key);AssociativeContainer
size_type count (const key_type & key);UniqueAssociativeContainer
iterator lower_bound (const key_type & key);SortedAssociativeContainer
iterator upper_bound (const key_type & key);SortedAssociativeContainer
std::pair<i,i>equal_range(const key_type & key);SortedAssociativeContainer

Sortierte Zuordnung

In einer map kommt jeder Schlüssel nur einmal vor. In einer multimap können Schlüssel auch mehrfach vorkommen. Die Elemente sind immer aufsteigend nach Schlüsseln sortiert. Iteratoren bleiben auch beim Einfügen und Löschen gültig.

#include <map>
std::map<K, D>
bool operator== (const map & lhs, const map & rhs);ForwardContainer (Identität)
bool operator<(const map & lhs, const map & rhs);ForwardContainer (Vergleich)
typedef K key_type; AssociativeContainer
typedef D data_type; PairAssociativeContainer
typedef std::pair<K,D> value_type; Container
typedef bool comp (K, K)key_compare; StrictWeakOrdering
typedef bool comp (V, V)value_compare; StrictWeakOrdering
Konstruktion
virtual ~map (); Container
map (); Container
map (const key_compare & comp); SortedAssociativeContainer
map (InputIterator first, InputIterator last); UniqueSortedAssociativeContainer
map (InputIterator first, InputIterator last,
 const key_compare & comp);		 UniqueSortedAssociativeContainer
map (const map & m); Assignable (Kopier-Konstructor)
Modifikation
map & operator= (const map & m); Assignable (Kopier-Operator)
void swap (map & m); Container
iterator insert (const value_type & pair); UniqueAssociativeContainer
iterator insert (iterator pos, const value_type & pair); UniqueSortedAssociativeContainer
iterator insert InputIterator first, InputIterator last); UniqueSortedAssociativeContainer
iterator erase (const key_type & key);AssociativeContainer
iterator erase (iterator pos); AssociativeContainer
iterator erase (iterator first, iterator last);AssociativeContainer
void clear (); AssociativeContainer
Iteration
iterator begin (); Container
iterator end (); Container
reverse_iterator rbegin (); ReversibleContainer
reverse_iterator rend (); ReversibleContainer
Kapazität
bool empty () const; Container
size_type size () const; Container
size_type max_size () const; Container
Elementzugriff
D & operator[] (size_type index); Fügt den Schlüssel ein, falls er nicht existiert.
Observation
key_compare key_comp () const; SortedAssociativeContainer
value_compare value_comp () const; SortedAssociativeContainer
Map-Operationen
iterator find (const key_type & key);AssociativeContainer
size_type count (const key_type & key);UniqueAssociativeContainer
iterator lower_bound (const key_type & key);SortedAssociativeContainer
iterator upper_bound (const key_type & key);SortedAssociativeContainer
std::pair<i,i>equal_range(const key_type & key);SortedAssociativeContainer