reading

Inhaltsverzeichnis

1. Einführung
1. Konventionen
  1. Typografie
  2. Quellcode
  3. Wert versus Objekt
  4. Index
2. Danksagungen
3. C++ versus C++11
2. Die Standardbibliothek
1. Die Chronologie
2. Überblick
  1. Praktische Werkzeuge
  2. Die Standard Template Library
  3. Numerik
  4. Textverarbeitung
  5. Ein- und Ausgabe
  6. Multithreading
3. Bibliotheken verwenden
  1. Header-Dateien einbinden
  2. Namensräume verwenden
    1. Namen qualifiziert verwenden
    2. Namen unqualifiziert verwenden
      1. using-Deklaration
      2. using-Anweisung
    3. Namensraum-Alias
  3. Ein ausführbares Programm erzeugen
3. Praktische Werkzeuge
1. Praktische Funktionen
  1. std::min, std::max und std::minmax
  2. std::move
  3. std::forward
  4. std::swap
2. Adaptoren für Funktionen
  1. std::bind
  2. std::function
3. Paare
  1. std::make_pair
4. Tupel
  1. std::make_tuple
  2. std::tie und std::ignore
5. Referenz-Wrapper
  1. std::ref und std::cref
6. Smart Pointer
  1. std::unique_ptr
    1. Spezielle Löschfunktionen
    2. std::make_unique
  2. std::shared_ptr
    1. std::make_shared
    2. std::shared_ptr von this
  3. std::weak_ptr
  4. Zyklische Referenzen
7. Type-Traits
  1. Typeigenschaften abfragen
    1. Primäre Typkategorien
    2. Zusammengesetzte Typkategorien
    3. Typeigenschaften
  2. Typen vergleichen
  3. Typen modifizieren
8. Zeitbibliothek
  1. Zeitpunkt
  2. Zeitdauer
  3. Zeitgeber
4. Gemeinsamkeiten der Container
1. Erzeugen und Löschen
2. Größe bestimmen
3. Zugriff auf die Elemente
4. Zuweisen und Tauschen
5. Vergleiche
5. Sequenzielle Container
1. Arrays
2. Vektoren
  1. size <= capacity
3. Deque
4. Listen
5. Einfach verkettete Listen
6. Assoziative Container
1. Überblick
2. Geordnete assoziative Container
  1. Überblick
  2. Schlüssel und Wert
  3. Das Vergleichskriterium
  4. Besondere Suchfunktionen
  5. Einfügen und Löschen von Elementen
  6. std::map
3. Ungeordnete assoziative Container
  1. Überblick
  2. Schlüssel und Wert
  3. Performance
  4. Die Hashfunktion
  5. Die Details
7. Adaptoren für Container
1. Stack
2. Queue
3. Priority Queue
8. Iteratoren
1. Kategorien
2. Iteratoren erzeugen
3. Nützliche Funktionen
4. Adaptoren
  1. Einfügeiteratoren
  2. Stream-Iteratoren
9. Aufrufbare Einheiten
1. Funktionen
2. Funktionsobjekte
  1. Vordefinierte Funktionsobjekte
3. Lambda-Funktionen
10. Algorithmen
1. Konventionen für Algorithmen
2. Iteratoren als Bindeglied
3. for::each
4. Nicht modifizierende Algorithmen
  1. Elemente suchen
  2. Elemente zählen
  3. Bedingungen auf Bereichen testen
  4. Bereiche vergleichen
  5. Bereiche in Bereichen suchen
5. Modifizierende Algorithmen
  1. Elemente und Bereiche kopieren
  2. Elemente und Bereiche ersetzen
  3. Elemente und Bereiche entfernen
  4. Bereiche füllen und erzeugen
  5. Bereiche verschieben
  6. Bereiche vertauschen
  7. Bereiche transformieren
  8. Bereiche umdrehen
  9. Bereiche rotieren
  10. Bereiche zufällig neu ordnen
  11. Duplikate entfernen
6. Partitionierungen
7. Sortieren
8. Binäres Suchen
9. Merge-Operationen
10. Heap
11. Min und Max
12. Permutationen
13. Numerik
11. Numerik
1. Zufallszahlen
  1. Zufallszahlenerzeuger
  2. Zufallszahlenverteilung
2. Numerische Funktionen von C
12. Strings
1. Erzeugen und Löschen
2. Konvertierungen zwischen C++-Strings und C-Strings
3. size versus capacity
4. Vergleiche
5. Stringkonkatenation
6. Elementzugriff
7. Ein- und Ausgabe
8. Suchen
9. Modifizierende Operationen
10. Numerische Konvertierungen
13. Reguläre Ausdrücke
1. Zeichentypen
2. Reguläre-Ausdrücke-Objekte
3. Das Suchergebnis match_results
  1. std::sub_match
4. Exakte Treffer
5. Suchen
6. Ersetzen
7. Formatieren
8. Wiederholtes Suchen
  1. std::regex_iterator
  2. std::regex_token_iterator
14. Ein- und Ausgabestreams
1. Hierarchie
2. Ein- und Ausgabefunktionen
  1. Eingabe
    1. Formatierte Eingabe
    2. Unformatierte Eingabe
  2. Ausgabe
  3. Formatangabe
3. Streams
  1. Stringstreams
  2. Dateistreams
  3. Dateistreams: wahlfreier Zugriff
  4. Streamzustand
4. Eigene Datentypen
15. Multithreading
1. Das C++-Speichermodell
2. Atomare Datentypen
3. Threads
  1. Erzeugen eines Threads
  2. Lebenszeit eines Threads
  3. Datenübergabe an einen Thread
  4. Operationen auf Threads
4. Gemeinsam von Threads genutzte Daten
  1. Kritischer Wettlauf
  2. Schutz der Daten mit Mutexen
  3. Verklemmung
  4. Locks
    1. std::lock_guard
    2. std::unique_lock
  5. Sichere Initialisierung der Daten
    1. Konstante Ausdrücke
    2. Statische Variablen mit Blockgültigkeit
      1. std::call_once und std::once_flag
5. Thread-lokale Daten
6. Bedingungsvariablen
7. Tasks
  1. Thread versus Task
  2. std::async
  3. std::packaged_task
  4. std::promise und std::future
Stichwortverzeichnis
Copyright

Inhaltsverzeichnis

1. Einführung

Konventionen

Typografie

Quellcode

Wert versus Objekt

Index

Danksagungen

C++ versus C++11

2. Die Standardbibliothek

Die Chronologie

Überblick

Praktische Werkzeuge

Die Standard Template Library

Numerik

Textverarbeitung

Ein- und Ausgabe

Multithreading

Bibliotheken verwenden

Header-Dateien einbinden

Namensräume verwenden

Namen qualifiziert verwenden

Namen unqualifiziert verwenden

using-Deklaration

using-Anweisung

Namensraum-Alias

Ein ausführbares Programm erzeugen

3. Praktische Werkzeuge

Praktische Funktionen

std::min, std::max und std::minmax

std::move

std::forward

std::swap

Adaptoren für Funktionen

std::bind

std::function

Paare

std::make_pair

Tupel

std::make_tuple

std::tie und std::ignore

Referenz-Wrapper

std::ref und std::cref

Smart Pointer

std::unique_ptr

Spezielle Löschfunktionen

std::make_unique

std::shared_ptr

std::make_shared

std::shared_ptr von this

std::weak_ptr

Zyklische Referenzen

Type-Traits

Typeigenschaften abfragen

Primäre Typkategorien

Zusammengesetzte Typkategorien

Typeigenschaften

Typen vergleichen

Typen modifizieren

Zeitbibliothek

Zeitpunkt

Zeitdauer

Zeitgeber

4. Gemeinsamkeiten der Container

Erzeugen und Löschen

Größe bestimmen

Zugriff auf die Elemente

Zuweisen und Tauschen

Vergleiche

5. Sequenzielle Container

Arrays

Vektoren

size <= capacity

Deque

Listen

Einfach verkettete Listen

6. Assoziative Container

Überblick

Geordnete assoziative Container

Überblick

Schlüssel und Wert

Das Vergleichskriterium

Besondere Suchfunktionen

Einfügen und Löschen von Elementen

std::map

Ungeordnete assoziative Container

Überblick

Schlüssel und Wert

Performance

Die Hashfunktion

Die Details

7. Adaptoren für Container

Stack

Queue

Priority Queue

8. Iteratoren

Kategorien

Iteratoren erzeugen

Nützliche Funktionen

Adaptoren

Einfügeiteratoren

Stream-Iteratoren

9. Aufrufbare Einheiten

Funktionen

Funktionsobjekte

Vordefinierte Funktionsobjekte

Lambda-Funktionen

10. Algorithmen

Konventionen für Algorithmen

Iteratoren als Bindeglied

for::each

Nicht modifizierende Algorithmen

Elemente suchen

Elemente zählen

Bedingungen auf Bereichen testen

Bereiche vergleichen

Bereiche in Bereichen suchen

Modifizierende Algorithmen

Elemente und Bereiche kopieren

Elemente und Bereiche ersetzen

Elemente und Bereiche entfernen

Bereiche füllen und erzeugen

Bereiche verschieben

Bereiche vertauschen

Bereiche transformieren

Bereiche umdrehen

Bereiche rotieren

Bereiche zufällig neu ordnen

Duplikate entfernen

Partitionierungen

Sortieren

Binäres Suchen

Merge-Operationen

Heap

Min und Max

Permutationen

Numerik

11. Numerik

Zufallszahlen

Zufallszahlenerzeuger

Zufallszahlenverteilung

Numerische Funktionen von C

12. Strings

Erzeugen und Löschen

Konvertierungen zwischen C++-Strings und C-Strings

size versus capacity

Vergleiche

Stringkonkatenation

Elementzugriff

Ein- und Ausgabe

Suchen

Modifizierende Operationen

Numerische Konvertierungen

13. Reguläre Ausdrücke

Zeichentypen

Reguläre-Ausdrücke-Objekte

Das Suchergebnis match_results

std::sub_match

Exakte Treffer

Suchen

Ersetzen

Formatieren

Wiederholtes Suchen

std::regex_iterator

std::regex_token_iterator

14. Ein- und Ausgabestreams

Hierarchie

Ein- und Ausgabefunktionen

Eingabe

Formatierte Eingabe

Unformatierte Eingabe

Ausgabe

Formatangabe

Streams

Stringstreams

Dateistreams

Dateistreams: wahlfreier Zugriff

Streamzustand

Eigene Datentypen

15. Multithreading

Das C++-Speichermodell

Atomare Datentypen

Threads

Erzeugen eines Threads

Lebenszeit eines Threads

Datenübergabe an einen Thread

Operationen auf Threads

Gemeinsam von Threads genutzte Daten

Kritischer Wettlauf

Schutz der Daten mit Mutexen

Verklemmung

Locks

std::lock_guard

std::unique_lock

Sichere Initialisierung der Daten

Konstante Ausdrücke

Statische Variablen mit Blockgültigkeit

std::call_once und std::once_flag

Thread-lokale Daten

Bedingungsvariablen

Tasks

Thread versus Task

std::async

std::packaged_task

std::promise und std::future

Stichwortverzeichnis

Kapitel 1. Einführung

C++-Standardbibliothek – kurz & gut ist eine Schnellreferenz zur Standardbibliothek des C++-Standards C++11. Der internationale Standard ISO/IEC 14882:2011 umfasst gut 1.300 Seiten und wurde 2011 veröffentlicht, also 13 Jahre nach dem bisher einzigen C++-Standard C++98. Formal betrachtet, ist zwar C++03 ein weiterer C++-Standard, der 2003 verabschiedet wurde. C++03 hat aber nur den Charakter einer technischen Korrektur.

Ziel dieser Kurzreferenz ist es, die Standardbibliothek von C++ kompakt vorzustellen. Im O'Reilly Verlag ist auch ein Buch zur C++-Kernsprache in der Reihe Taschenbibliothek erschienen. Ein Buch zur C++-Standardbibliothek setzt die Features der C++-Kernsprache voraus. Gegebenenfalls werde ich Features der Kernsprache vorstellen, um die Funktionalität der Standardbibliothek besser darstellen zu können. Beide Bücher dieser Reihe sind in Stil und Umfang sehr ähnlich und ergänzen sich ideal. 2014, beim Schreiben dieses Werks, wurde eine Ergänzung des C++11-Standards verabschiedet: C++14. In diesem Buch werde ich auf einige Neuerungen für C++ eingehen, die C++14 für die Standardbibliothek mit sich bringt.

Dieses Buch wurde für den Leser geschrieben, der eine gewisse Vertrautheit mit C++ besitzt. Dieser C++-Programmierer wird aus der konzentrierten Referenz der Standardbibliothek von C++ den größten Nutzen ziehen. Wenn C++ für Sie hingegen noch neu ist, sollten Sie im ersten Schritt ein Lehrbuch über C++ dieser Kurzreferenz vorziehen. Haben Sie das Lehrbuch aber gemeistert, hilft Ihnen dieses Werk mit den vielen kurzen Codebeispielen, die Komponenten der Standardbibliothek von C++ in einem weiteren Schritt sicher anzuwenden.

Konventionen

Mit diesen wenigen Konventionen sollte das Buch leichter lesbar sein.

Typografie

In dem Buch werden die folgenden typografischen Konventionen verwendet:

Kursiv: Diese Schrift wird für Dateinamen und Hervorhebungen verwendet.
Nichtproportionalschrift: Diese Schrift wird für Code, Befehle, Schlüsselwörter und Namen von Typen, Variablen, Funktionen und Klassen verwendet.

Quellcode

Obwohl ich kein Freund von using-Anweisungen und using-Deklarationen bin, da sie die Herkunft einer Bibliotheksfunktion verschleiern, werde ich gegebenenfalls in den Codebeispielen davon Gebrauch machen, und zwar einfach, weil die Länge einer Seitenzeile beschränkt ist. Es wird aber immer aus dem Codebeispiel hervorgehen, ob ich eine using-Deklaration (using std::cout;) oder eine using-Anweisung (using namespace std;) verwendet habe.

In den Codebeispielen werde ich nur die Header-Datei verwenden, dessen Funktionalität in dem Kapitel dargestellt wird.

Wahrheitswerte werde ich in den Ausgaben der Codebeispiele immer als true oder false darstellen, auch wenn das std::boolalpha-Flag (siehe „Formatangabe“) in dem Beispiel nicht verwendet wird.

Wert versus Objekt

Built-in-Datentypen, die C++ von C geerbt hat, nenne ich der Einfachheit halber Werte. Anspruchsvollere Datentypen, die oft Built-in-Datentypen enthalten, nenne ich Objekte. Dies sind in der Regel benutzerdefinierte Datentypen oder auch Container.

Index

Da die Namen der Standardbibliothek mit dem Namensraum std beginnen, verwende ich diesen im Index der Einfachheit halber nicht, sodass zum Beispiel die Information zum Vektor std::vector im Index unter vector zu finden ist.

Danksagungen

Ich möchte Alexandra Follenius, meiner Lektorin bei O'Reilly, für ihre Unterstützung und Anleitung bei der Arbeit mit diesem Buch danken. Danke vor allem aber auch an Karsten Ahnert, Guntram Berti, Dmitry Ganyushin, Sven Johannsen, Torsten Robitzki und Bart Vandewoestyne, die sich die Zeit genommen haben, das Manuskript auf sprachliche und insbesondere inhaltliche Fehler zu durchleuchten.

C++ versus C++11

Wer könnte C++11 besser charakterisieren als Bjarne Stroustrup, Erfinder von C++:

Surprisingly, C++11 feels like a new language: The pieces just fit together better than they used to and I find a higher-level style of programming more natural than before and as efficient as ever.
—Bjarne Stroustrup, http://www.stroustrup.com/C++11FAQ.html

Bjarne Stroustrup hat recht. C++11 fühlt sich wie eine neue Sprache an, denn C++11 hat einiges gegenüber klassischem C++ zu bieten. Dies trifft nicht nur auf die Kernsprache, dies triff vor allem auch auf die verbesserte und deutlich erweiterte Standardbibliothek zu. Die Bibliothek mit den regulären Ausdrücken für die mächtigere Verarbeitung von Texten, die Type-Traits-Bibliothek, um Typinformationen zu erhalten, zu vergleichen oder zu modifizieren, sowie die neue Zufallszahlen- oder Zeitbibliothek sind nun genauso auf der Habenseite von C++ wie die erweiterten Smart Pointer für die explizite Speicherverwaltung oder die neuen Container std::array und std::tuple. Neu ist vor allem aber auch, dass sich C++ zum ersten Mal mit der Multithreading-Bibliothek der Existenz von mehreren Threads bewusst ist.

C++-Standardbibliothek

C++-Standardbibliothek

kurz & gut

Rainer Grimm

Inhaltsverzeichnis

Kapitel 1. Einführung

Konventionen

Typografie

Quellcode

Wert versus Objekt

Index

Danksagungen

C++ versus C++11