C-Plusplus-Standardbibliothek

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:

Das Verhältnis der Iteratoren in der Standardbibliothek.

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

  1. TR1

Siehe auch

Weblinks


Wikimedia Foundation.

Игры ⚽ Нужно сделать НИР?

Schlagen Sie auch in anderen Wörterbüchern nach:

  • C-Standardbibliothek — Die Standard C Library ist eine genormte Bibliothek für die Programmiersprache C, die etwa 200 Funktionen enthält und in jedem hosted environment von C zu implementieren ist. Sie enthält häufig benötigte Funktionen für Ein und Ausgabe,… …   Deutsch Wikipedia

  • C-Plusplus — C++ Paradigmen: imperativ, strukturiert, objektorientiert, generisch Erscheinungsjahr: 1983 Entwickler: Bjarne Stroustrup …   Deutsch Wikipedia

  • C Standard Library — Die Standard C Library ist eine genormte Bibliothek für die Programmiersprache C, die etwa 200 Funktionen enthält und in jedem hosted environment von C zu implementieren ist. Sie enthält häufig benötigte Funktionen für Ein und Ausgabe,… …   Deutsch Wikipedia

  • Libc — Die Standard C Library ist eine genormte Bibliothek für die Programmiersprache C, die etwa 200 Funktionen enthält und in jedem hosted environment von C zu implementieren ist. Sie enthält häufig benötigte Funktionen für Ein und Ausgabe,… …   Deutsch Wikipedia

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”