Standard Template Library (STL) — ¨Ubersicht

Standard Template Library (STL) — Übersicht
Eine gute Online-Referenz finden Sie unter http://www.sgi.com/tech/stl/; die dort beschriebene Bibliothek enthält auch einige über den C++-Standard hinausgehende Funktionen.
Einige Standardcontainer:
• list (doppelt verkettete Liste), vector (Feld) im Unterschied zu valarray (Modell eines
mathematischen Vektors)
• Assoziative Container: map (Abbildung, Repräsentation als Baum), set (Menge)
Um den jeweiligen Container nutzen zu können, muss die entsprechende Header-Datei eingebunden werden, die in der Regel den selben Namen wie der Container selber besitzt, z.B.
#include <set>.
Gemeinsames Konzept: Iteratoren werden gebraucht, um über die Einträge des Containers
zu iterieren.
• iterator: verhält sich wie ein Zeiger auf einen Eintrag. Eintrag kann gelesen und verändert
werden.
• const_iterator: verhält sich wie ein Zeiger auf einen konstanten Eintrag. Eintrag kann
nur gelesen, aber nicht verändert werden.
Elementfunktionen, die fast alle Containerklassen besitzen: Standardkonstruktor, Kopierkonstruktor, Destruktor, Zuweisungsoperator sowie
iterator
iterator
const_iterator
const_iterator
size_t
bool
void
begin();
end();
begin()
end()
size()
empty()
swap( Cont& c);
const;
const;
const;
const;
Einige spezielle Elementfunktionen der einzelnen Container:
template<class T> class list
{
...
public:
T&
front
();
T&
back
();
void push_front( const T& x);
void push_back ( const T& x);
void pop_front ();
void pop_back ();
iterator insert( iterator pos, const T& x);
iterator erase ( iterator pos);
void
remove( const T& value);
void sort ();
void unique();
void merge ( list& L);
...
};
1
Komplexität von insert und erase: O(1)
template<class T> class vector
{
...
public:
vector( size_t n);
vector( size_t n, const T& x);
T&
operator[] (size_t i);
const T& operator[] (size_t i) const;
T&
T&
void
void
front
();
back
();
push_back( const T& x);
pop_back ()
void clear ();
void resize ( size_t n);
void reserve( size_t n);
iterator insert( iterator pos, const T& x);
iterator erase ( iterator pos);
...
};
Komplexität von insert und erase: O(n) (!), Komplexität von operator[] O(1)
template<class KeyT, class DataT> class map
{
...
public:
pair<iterator,bool> insert( const T& x);
void
erase ( iterator pos);
size_t
erase ( const key_t& key);
void
clear ();
iterator
iterator
iterator
DataT&
...
find
(
lower_bound(
upper_bound(
operator[] (
const
const
const
const
KeyT&
KeyT&
KeyT&
KeyT&
key);
key);
key);
key);
};
Beachte: Der iterator gibt ein pair<KeyT,DataT> zurück, so dass man mit first auf den Schlüssel und
mit second auf den Eintrag zurückgreifen kann.
Die Elemente einer map werden nach dem Schlüssel sortiert abgespeichert. Damit ist das Suchen nach
Elementen besonders schnell. Beachte, dass im Unterschied zu einer multi_map verschiedene Einträge
stets verschiedene Schlüssel besitzen, die Schlüssel sind also eindeutig.
Komplexität von insert, erase, find, lower_bound, upper_bound, operator[]: O(log n)
2
template<class KeyT> class set
{
...
public:
pair<iterator,bool> insert( const T& x);
void
erase ( iterator pos);
size_t
erase ( const key_t& key);
void
clear ();
iterator find
( const KeyT& key);
iterator lower_bound( const KeyT& key);
iterator upper_bound( const KeyT& key);
...
};
Ein set verhält sich also ähnlich wie eine map, mit dem Unterschied, dass unter den Schlüsseln kein
Eintrag abgespeichert wird.
Die Elemente eines set werden nach dem Schlüssel sortiert abgespeichert. Damit ist das Suchen nach
Elementen besonders schnell. Beachte, dass im Unterschied zu einem multi_set verschiedene Einträge
stets verschiedene Schlüssel besitzen, die Schlüssel sind also eindeutig.
Komplexität von insert, erase, find, lower_bound, upper_bound: O(log n)
valarray ist Element der Standard C++ Numerics Library und sofern für Numeriker von besonderem
Interesse:
template<class T> class valarray
{
...
public:
valarray( size_t n);
valarray( const T& x, size_t n);
T
operator[] (size_t i)
const;
T&
operator[] (size_t i);
valarray<T> operator[] (const valarray<size_t>& idx) const;
size_t size ()
const;
void
resize( size_t n);
T sum() const;
T min() const;
T max() const;
valarray<T> shift( int n)
const;
valarray<T> apply( T func(T)) const;
...
};
Darüberhinaus gibt es etliche andere Operatoren wie +=, -= und zahlreiche Funktionen wie sin, cos usw.
3
Algorithmen: Durch Einbinden von algorithm können verschiedene Algorithmen genutzt werden, die
auf den Containern arbeiten und dabei regen Gebrauch von dem Konzept der Iteratoren machen. Dabei
wird oft ein Paar first, last von Iteratoren verwendet, um ein Tupel von Daten als halboffenes Intervall
zu repräsentieren: first zeigt auf das erste Element des Tupels, last zeigt auf die erste Position in der
Sequenz, die nicht mehr zu dem betrachteten Tupel gehört. Hier eine kleine Auswahl:
template <class IteratorT, class T>
void fill( IteratorT first, IteratorT last, const T& value);
template <class IteratorT, class T>
IteratorT find( IteratorT first, IteratorT last, const T& value);
template <class Iterator1T, class Iterator2T>
Iterator1T find_first_of( Iterator1T first1, Iterator1T last1,
Iterator2T first2, Iterator2T last2);
template <class IteratorT>
IteratorT min_element( IteratorT first, IteratorT last);
template <class IteratorT>
IteratorT max_element( IteratorT first, IteratorT last);
template <class IteratorT, class T>
IteratorT remove( IteratorT first, IteratorT last, const T& value);
template <class IteratorT, class T>
IteratorT replace( IteratorT first, IteratorT last,
const T& old_value, const T& new_value);
template <class IteratorT>
void sort( IteratorT first, IteratorT last);
Folgende Algorithmen setzen sortierte Sequenzen voraus:
template <class Iterator1T, class Iterator2T>
bool binary_search( Iterator1T first1, Iterator1T last1,
const T& value);
template <class Iterator1T, class Iterator2T>
bool includes( Iterator1T first1, Iterator1T last1,
Iterator2T first2, Iterator2T last2);
template <class IteratorT, class T>
IteratorT lower_bound( IteratorT first, IteratorT last, const T& value);
template <class IteratorT, class T>
IteratorT upper_bound( IteratorT first, IteratorT last, const T& value);
4