Das Kefk Network Wiki befindet sich im Testbetrieb.

Aus Kefk.

Die C++-Standardbibliothek ist die zur Programmiersprache C++ gehörende Programmierbibliothek, also eine Zusammenstellung von Algorithmen, die in der Programmiersprache C++ geschrieben sind und fest zur Programmiersprache C++ gehören, so dass sie bei der Lösung von Programmierproblemen immer als vorhanden vorausgesetzt und angewendet werden können.

Die C++-Standardbibliothek 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.

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 fälschlicherweise die C++-Standardbibliothek im Volksmund immer noch 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), welche z. B. reguläre Ausdrücke, diverse Smartpointer, Hash Container, eine Zufallszahlbibliothek und vieles mehr spezifiziert. Die von vielen C++-Nutzern geforderten Bibliotheksfunktionen, wie Threads, Dateisystem-Operationen u. a., 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 unerheblich wichtiges Kriterium für Templates ist auch die optimale Performance, da der Compiler für jedes parametresierte Template einen speziell auf den angegebenen Typ erzeugten Code erstellen kann.

Container

Container (Behälterklassen) sind Datenstrukturen, die aus einer Anzahl verschiedener Objekte des selben Datentyps bestehen. Die grundlegenden Container der C++-Standardbibliothek sind:

In sequenziellen Containern sind die Objekte linear angeordnet und werden über ihre Position angesprochen. In assoziativen Containern werden die Objekte in einer Baumstruktur unterhalten. Der Zugriff erfolgt hier 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 ist nicht jeder Iteratortyp für jeden Containertyp geeignet. Z.B. kann der sehr spezielle Iterator für wahlfreien Zugriff nicht auf einen list-Container angewendet werden, aber auf einen vector-Container. Der Eingabe-Iterator ist dagegen sehr allgemein und lässt sich somit auf jeden Containertyp anwenden.

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 eine Parametrisierung vom Typ char. Mit dieser lassen sich jedoch nur 7 Bit große ASCII-Zeichen plattformübergreifend verarbeiten.
• std::wstring ist eine Parametrisierung vom Typ wchar_t (wide character). Damit lassen sich UCS2-Zeichen plattformübergreifend verarbeiten.

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

Siehe auch

• C++
• Die Standard-C-Bibliothek
• Standard Template Library
• Boost – freie C++-Bibliothek

Weblinks

• C++-Referenz (engl.)

Quellen

1. ↑ TR1

Dieses Dokument entstammt in seiner ersten oder einer späteren Version der deutschsprachigen Wikipedia. Es ist dort zu finden unter dem Stichwort C%2B%2B-Standardbibliothek, die Liste der bisherigen Autoren befindet sich in der Versionsliste; die Originalfassung kann dort auch bearbeitet werden. Alle Texte der Wikipedia und ihre Derivate stehen unter der GNU-Lizenz für freie Dokumentation.