- C-Plusplus-Standardbibliothek
-
Die C++-Standardbibliothek ist eine standardisierte Programmierbibliothek zur allgemeinen Verwendung. Sie stellt verschiedene generische Container, Funktionen zu deren Manipulierung, Funktionsobjekte, generische Zeichenketten (auch „Strings“ genannt), Datenströme u. a. für den Dateizugriff, Unterstützung von Sprachmitteln sowie einfache Funktionen beispielsweise zur Bildung der Quadratwurzel zur Verfügung. In ihr ist auch die gesamte Standardbibliothek der Programmiersprache C enthalten.
Inhaltsverzeichnis
Entstehung
Die für C++ neuentwickelte Bibliothek hat ihren Ursprung schon in den 1980er Jahren, wurde aber im Laufe der Standardisierung durch den Einfluss einer bei Hewlett-Packard entwickelten Bibliothek namens Standard Template Library (STL) stark überarbeitet. Heute wird die C++-Standardbibliothek fälschlicherweise immer noch häufig STL genannt, obwohl es sich um zwei unabhängige Entwicklungszweige handelt und die Bestandteile der beiden Bibliotheken sich auch unterscheiden. Der Umfang der C++-Standardbibliothek wird gegenüber der STL auch mit dem nächsten C++-Standard deutlich zunehmen.
Erweiterungen
Seit April 2006 gibt es auch eine Bibliothekserweiterung [1] (Technical Report 1), die z. B. reguläre Ausdrücke, verschiedene Smartpointer, Hash Container, eine Zufallszahlbibliothek und vieles mehr spezifiziert. Die von vielen C++-Nutzern geforderten Bibliotheksfunktionen, wie Threads und Dateisystem-Operationen werden höchstwahrscheinlich in einem kommenden „Technical Report“ zu finden sein.
Bestandteile der C++-Standardbibliothek
Die C++-Standardbibliothek bietet:
- Container (Behälterklassen)
- Iteratoren
- Algorithmen
- Funktionsobjekte
- Zeichenketten
- Ein-/Ausgabe
- Lokalisierung
- Numerik
- Ausnahmen
- RTTI (Runtime Type Information)
Die meisten Komponenten der C++-Standardbibliothek liegen in Form von Templates vor. Das Template-Konzept hat den großen Vorteil der Wiederverwendbarkeit, so können zum Beispiel durch einfache Deklaration Container für beliebige Datentypen erzeugt werden; Algorithmen gelten für eine ganze Reihe von Datentypen. Weiterhin wird durch Templates schon während des Kompilierens eine Typsicherheit sichergestellt, die Laufzeitfehler minimiert. Ein nicht unerhebliches Argument für Templates ist auch die hohe Performance, da der Compiler für jedes parametrierte Template speziell auf den angegebenen Typ angepassten Code erzeugen kann. Ein Nachteil sind die überaus schwer zu lesenden Fehlermeldungen, die zum Beispiel bei Typ-Konflikten erzeugt werden.
Container
Container (Behälterklassen) sind Datenstrukturen, die aus einer Anzahl verschiedener Objekte desselben Datentyps bestehen. Die grundlegenden Container der C++-Standardbibliothek sind:
Sequenzielle Container Felder dynamischer Größe std::vector Felder fester Größe std::tr1::array doppelt verkettete Listen std::list Warteschlangen std::queue Warteschlangen mit zwei Enden std::deque Warteschlangen mit Prioritäten std::priority_queue Stapel std::stack Geordnete assoziative Container Mengen std::set und std::multi_set Assoziative Felder std::map und std::multi_map Ungeordnete assoziative Container (auch bekannt als Hashmaps/Hashsets) Mengen std::tr1::unordered_set und std::tr1::unordered_multiset Assoziative Felder std::tr1::unordered_map und std::tr1::unordered_multimap Sonstige Container Bitmengen std::bitset In sequenziellen Containern sind die Objekte linear angeordnet. In assoziativen Containern erfolgt der Zugriff mit Hilfe von Schlüsseln.
Iteratoren
Iteratoren (von lateinisch iterare: wiederholen) sind eine Art intelligente Zeiger, mit deren Hilfe über die Elemente eines Containers iteriert sowie auf einzelne Elemente des Containers zugegriffen werden kann. Die Iteratoren bilden ein zentrales und wichtiges Konzept für die Container. Bezogen auf ihre Aufgabe sind die Iteratoren reine Zugriffsobjekte. Sie entkoppeln die Algorithmen von den Containern, so dass diese typenunabhängig werden. Das nachfolgende Diagramm zeigt das Verhältnis des Iterators zu den Containern und Algorithmen:
Bei den Iteratoren gibt es folgende Kategorien:
- Eingabe-Iteratoren: lesenden Zugriff für einen einzelnen Durchlauf
- Ausgabe-Iteratoren: schreibender Zugriff für einen einzelnen Durchlauf
- Forward-Iteratoren: sequenzieller Zugriff mit relativem Bezug auf Iteratoren, in eine Richtung
- Bidirektionale Iteratoren: wie Forward-Iteratoren jedoch in beide Richtungen
- Iteratoren mit wahlfreiem Zugriff: wahlfreier Zugriff, auch mit Index-Operator ([])
Dabei stellt nicht jeder Container alle Iteratoren zur Verfügung. Der list-Container lässt z.B. keinen wahlfreien, sondern nur sequentiellen Zugriff zu. Die Ein- und Ausgabeiteratoren sind dagegen sehr allgemein und werden grundsätzlich bereitgestellt.
Algorithmen
Algorithmen sind Funktionen mit bestimmten Manipulationsvorschriften, die auf einen Container angewendet werden. Dabei sind sie unabhängig von der speziellen Implementierung der Container. Sie können nur über Iteratoren auf die Elemente in den Containern zugreifen. Sie enthalten u. a. die Standard-Algorithmen der Informatik, wie z. B. Sortieralgorithmen oder Verfahren zur Erzeugung von Zufallszahlen. Die meistbenutzten sind:
- std::for_each: wendet eine Operation auf alle Elemente eines Datensatzes an
- std::transform: transformiert einen Datensatz mit einer Funktion in einen anderen
- std::copy: kopiert den Datensatz in einen anderen
- std::sort: sortiert den Datensatz
- std::find: sucht nach einem bestimmten Element in einem Datensatz
- std::search: sucht nach einer Elementreihe in einem Datensatz
Diese und weitere Algorithmen befinden sich im Header <algorithm>.
Funktionsobjekte
Bei Funktionsobjekten oder Funktoren handelt es sich um Objekte, die genauso aufgerufen werden können wie Funktionen. Bei ihnen ist der Funktionsoperator () mit der Operatorfunktion „operator()“ überladen. Es sind Objekte, die sich wie Funktionen verhalten, aber trotzdem alle Eigenschaften von Objekten haben. Bei den Funktionsobjekten gibt es folgende Kategorien:
- Generatoren ohne Funktionsparameter „f()“
- Unäre Funktionen mit einem Funktionsparameter „f(x)“
- Binäre Funktionen mit zwei Funktionsparametern „f(x,y)“
Grundsätzlich benötigen die Algorithmen der C++-Standardbibliothek keine Funktionsobjekte mit mehr als zwei Parametern.
Zeichenketten
Die Zeichenketten-Bibliothek (im folgenden String-Bibliothek) definiert ein Klassen-Template std::basic_string zur Darstellung von Zeichenketten variabler Länge. Die Methoden des Klassen-Templates erlauben String-Manipulationen und -Operationen, wie z. B. das Einfügen, Löschen, Ersetzen und Suchen in Strings. Von diesem Klassen-Template gibt es zwei Typdefinitionen:
- std::string ist ein std::basic_string, parametrisiert mit char. char kann ein Zeichen des Basiszeichensatzes speichern.
- std::wstring ist ein std::basic_string, parametrisiert mit wchar_t (wide character). wchar_t kann alle Elemente des größten unterstützten Zeichensatzes speichern.
Beispiele
std::vector<int> daten(10); // Datenfeld mit int der Länge 10 anlegen std::vector<int>::iterator dIter(daten.begin()); // Iterator anlegen und initialisieren // Iterator zeigt auf ersten Eintrag for (int i=0; // Zähler i initialisieren, dIter != daten.end(); // for-Schleife solange durchgehen, bis dIter aufs Ende des Datenfeldes zeigt ++i, ++dIter) { // Zähler i erhöhen, Iterator auf den nächsten Eintrag zeigen lassen *dIter = i; // i dem Datenfeld zuweisen, auf das dIter zeigt } // daten: 0 1 2 3 4 5 6 7 8 9 std::vector<int> datenZwei(10); std::copy( daten.begin(), daten.end(), // welche Daten sollen kopiert werden datenZwei.begin() ); // und wohin // datenZwei: 0 1 2 3 4 5 6 7 8 9 // binärer Funktor std::multiplies<int>() braucht zwei Argumente std::transform( daten.begin(), daten.end(), // auf welchem Bereich soll Algorithmus arbeiten datenZwei.begin(), // zweite Datenquelle datenZwei.begin(), // wohin sollen Ergebnisse gehen std::multiplies<int>() ); // miteinander multiplizieren // datenZwei: 0 1 4 9 16 25 36 49 64 81 // unärer Funktor std::negate<int>() braucht ein Argument std::transform( daten.begin()+4, daten.end(), // dieses Mal nicht vom Anfang, sondern vom fünften Element an daten.begin()+4, std::negate<int>() ); // Negation // daten: 0 1 2 3 -4 -5 -6 -7 -8 -9 std::sort( daten.begin(), daten.end() ); // sortieren // daten: -9 -8 -7 -6 -5 -4 0 1 2 3
Quellen
Siehe auch
Weblinks
Wikimedia Foundation.
