Stichwortverzeichnis

Symbole

#error, Variadic Templates
$
Metazeichen, Syntax der regulären Ausdrücke
$$
Format-Escape-Sequenz, Formatieren mit regex_replace und match_results.format
$&
Format-Escape-Sequenz, Ersetzen mit regex_replace, Formatieren mit regex_replace und match_results.format
$i
Format-Escape-Sequenz, Formatieren mit regex_replace und match_results.format, Formatieren mit regex_replace und match_results.format
$ii
Format-Escape-Sequenz, Formatieren mit regex_replace und match_results.format
$‘
Format-Escape-Sequenz, Formatieren mit regex_replace und match_results.format
$’
Format-Escape-Sequenz, Formatieren mit regex_replace und match_results.format
&, Rvalue-Referenzen
Lvalue-Referenz, Rvalue-Referenzen
Operator, Implizit erzeugte Methoden und Operatoren
&&, Rvalue-Referenzen
Rvalue-Referenz, Rvalue-Referenzen
(, Syntax der regulären Ausdrücke
Metazeichen, Syntax der regulären Ausdrücke
( )
Lambda-Funktionen, Bindung an den lokalen Bereich: [ ]
)
Metazeichen, Syntax der regulären Ausdrücke
*
Metazeichen, Syntax der regulären Ausdrücke
Operator, Implizit erzeugte Methoden und Operatoren
+
Metazeichen, Syntax der regulären Ausdrücke
->, Alternative Funktionssyntax
Lambda-Funktionen, Bindung an den lokalen Bereich: [ ]
Operator, Implizit erzeugte Methoden und Operatoren
shared_ptr, shared_ptr
unique_ptr, unique_ptr
->*
Operator, Implizit erzeugte Methoden und Operatoren
.
Metazeichen, Syntax der regulären Ausdrücke
0
Mehrdeutigkeit, Benutzerdefinierte Literale
>>, nullptr
Verteilung, Zufallszahlenverteilung
?
Metazeichen, Syntax der regulären Ausdrücke
[
Metazeichen, Syntax der regulären Ausdrücke
[&]
Lambda-Funktionen, Lambda-Funktionen als temporäre Funktionsobjekte, Bindung an den lokalen Bereich: [ ]
[=]
Lambda-Funktionen, Lambda-Funktionen als temporäre Funktionsobjekte, Bindung an den lokalen Bereich: [ ]
^
Metazeichen, Syntax der regulären Ausdrücke
_1
Platzhalter, function
_2
Platzhalter, function
{
Metazeichen, Syntax der regulären Ausdrücke
{ }
Lambda-Funktionen, Funktionskörper: { }
{{
Aggregat, Array
{}-Initialisiererlisten, Funktionskörper: { }
|
Metazeichen, Syntax der regulären Ausdrücke
}
Metazeichen, Syntax der regulären Ausdrücke
}}
Aggregat, Array
–
Metazeichen, Syntax der regulären Ausdrücke

A

Abrahams, David, Lvalue- versus Rvalue-Referenzen
accumulate, Variadic Templates, Funktionen höherer Ordnung, Funktionen höherer Ordnung
ACID, Multithreading
add_const, Typen transformieren, Typen transformieren
add_cv, Typen transformieren
add_lvalue_reference, Typen transformieren
add_pointer, Typen transformieren
add_rvalue_reference, Typen transformieren
add_volatile, Typen transformieren
Alexander, Christopher, Explizite Klassendefinitionen
Alexandrescu, Andrei, Variadic Templates, Konstante Ausdrücke, Hilfsfunktionen
Aliase Templates, Variadic Templates, Zusicherungen zur Compile-Zeit
alignas, Unbeschränkte Unions
alignment_of, Typeigenschaften
alignof, Unbeschränkte Unions
all_of, Neue Algorithmen, Neue Algorithmen, Neue Algorithmen
alternative Funktionssyntax, decltype
anonyme Funktionen, Lambda-Funktionen
any_of, Neue Algorithmen, Neue Algorithmen, Neue Algorithmen
array, Tupel, Vereinheitlichte Initialisierung, Hilfsfunktionen, Hilfsfunktionen
assert, Variadic Templates
assoziatives Array, Einfach verkettete Liste, Einfach verkettete Liste
async, Synchronisation von Threads, Asynchrone Aufgaben, future und promise
launch, async
at
array, Array, Array
atomare Operationen, Das C++11-Speichermodell
atomic, Atomare Datentypen, Atomare Datentypen
Ausnahmespezifikation, Deprecated
Austern, Matt, Technical Report 2
auto, Die Range-basierte For-Schleife, Die Range-basierte For-Schleife, Removed und Deprecated
auto_ptr, Smart Pointer, Deprecated, Verbesserte Bibliotheken, Konvertierung in Ableitungshierarchien
awk, Reguläre Ausdrücke

B

back_inserter, Neue Algorithmen
basic, Reguläre Ausdrücke
basic_regex, Gruppierungen
Becker, Pete, Vereinheitlichte Initialisierung, Mutexe, Objekte vom Typ regulärer Ausdruck, Exakte Treffer mit regex_match, Konvertierung in Ableitungshierarchien
Bedarfsauswertung, async, Verarbeitung von Listen
Bedingungsvariablen, Synchronisation der Threads
before_begin
forward_list, Einfach verkettete Liste
Beman, Dawes, Signale und Slots
benutzerdefinierte Literale, Unicode-Unterstützung
bernoulli_distribution, Zufallszahlenverteilung, Zufallszahlenverteilung
binäre Literale, Binäre Literale
bind, bind und function, Lebenszeit der Daten, bind und function, bind
bind1st, bind und function, Deprecated, bind
bind2nd, bind und function, Deprecated, bind
binomial_distribution, Zufallszahlenverteilung
Boehm, Hans, Das C++11-Speichermodell
Boost, Download der Codebeispiele, GCC, Die Standardisierung, Die Standardbibliothek, Smart Pointer, Atomare Datentypen, Type-Traits, Technical Report 2
Any, Signale und Slots
Asio, Erweiterte Thread-Funktionalität
signals, Erweiterte Thread-Funktionalität
Bucket, Hashfunktion, Hashfunktion
bucket_size
Hashtabelle, Hashfunktion
busy waiting, Zeitbibliothek

C

C++-Standard
ARM C++, Die Standardisierung
C++03, Die Standardisierung
C++11, Die Standardisierung
C++14, Die Standardisierung, Die nächsten C++-Standards
C++17, Die Standardisierung, Die nächsten C++-Standards
C++98, Die Standardisierung
C99, Die Standardisierung
ISO-Standardisierungskomitee, Die Standardisierung
TR1, Die Standardisierung
C++0x, Einführung
C-Array, Hilfsfunktionen
C99, nullptr
callable object, Funktionsobjekte
call_once, Sichere Initialisierung der Daten, Konstante Ausdrücke
capture group, Reguläre Ausdrücke
cauchy_distribution, Zufallszahlenverteilung
cbegin
Container, Praktische Helferlein
cend
Container, Praktische Helferlein
char16_t, Raw-String-Literale
char32_t, Raw-String-Literale
chi_squared_distribution, Zufallszahlenverteilung
clear
Hashtabelle, Hashtabellen
Clojure, Multithreading
codecvt, Unicode-Unterstützung
Compile-Zeitkonstante, Variadic Templates
Compiler
aktuelle Compiler, Download der Codebeispiele
GCC, GCC
Visual C++ 10.0, Microsoft Visual C++
Concepts, Module
condition_variable, Synchronisation der Threads
condition_variable_any, Synchronisation der Threads
constexpr, Konstante Ausdrücke, Benutzerdefinierte Literale, Statische Variablen in einem Blockbereich
const_pointer_cast, shared_ptr von this
cooked, Benutzerdefinierte Literale
copy, Plain Old Data (POD), Type-Traits, Typen transformieren
Copy-Semantik, Rvalue-Referenzen, future und promise
auto_ptr, unique_ptr
copy_if, Neue Algorithmen, Neue Algorithmen, Neue Algorithmen
copy_n, Neue Algorithmen, Neue Algorithmen, Neue Algorithmen
count
Hashtabelle, Hashtabellen
crbegin
Container, Praktische Helferlein
cref, Referenz-Wrapper, Referenz-Wrapper, Hilfsfunktionen
cregex_token_iterator, regex_token_iterator
crend
Container, Praktische Helferlein
Crowl, Lawrence, Unbeschränkte Unions
CRTP (Siehe Curiously Recurring Template Pattern)
Curiously Recurring Template Pattern, Löschfunktion
current_exception, future und promise
Curry, Haskell, function
Currying, function

D

Daemon, Operationen auf Threads
dangling reference, Bindung an den lokalen Bereich: [ ]
data race, Schutz der Daten
Dauer, Zufallszahlen
Dawes, Beman, Technical Report 2
Deadlock, Mutexe
decltype, Die Range-basierte For-Schleife, auto, bind und function, Promotion Trait
default, Mächtigere Initialisierung, Direktes Initialisieren von Klassenelementen, default und delete
default_random_engine, Zufallszahlenerzeuger
deferred
launch, async, future und promise
defer_lock, Locks
Definition
Atomare Operation, Atomare Datentypen
Aufrufbare Einheit, Lambda-Funktionen
Closures, Bindung an den lokalen Bereich: [ ]
Deadlock, Locks
Domain-Specific-Embedded-Language, Benutzerdefinierte Literale
Funktionale Programmierung, Programmieren mit mathematischen Funktionen
Hashtabelle, Einfach verkettete Liste
Perfect Forwarding, Move-Semantik
Race Condition, Schutz der Daten
Regulärer Ausdruck, Neue Bibliotheken
Sequenzielle Konsistenz, Das C++11-Speichermodell
Smart Pointer, Smart Pointer
Syntactic sugar, Das automatische Ableiten von Typen
Template-Metaprogrammierung, Reguläre Ausdrücke
Typumwandlung, Alternative Funktionssyntax
Usability, Kernsprache
Zeitdauer, Zeitpunkt und Zeitgeber, Zeitbibliothek
Dekker, Theodorus, Das C++11-Speichermodell
delete, Mächtigere Initialisierung, Direktes Initialisieren von Klassenelementen, default und delete
Operator, Implizit erzeugte Methoden und Operatoren
unique_ptr, unique_ptr
deque, Array, Praktische Helferlein
detach
thread, Erzeugung von Threads, Lebenszeit der Daten, Operationen auf Threads
/dev/urandom, Zufallszahlenerzeuger
Dictionary, Einfach verkettete Liste, Einfach verkettete Liste
Dijkstra, Edsger W., Das automatische Ableiten von Typen
direktes Initialisieren von Klassenelementen, Mächtigere Initialisierung, Vererbung von Konstruktoren
discard_block_engine, Zufallszahlenerzeuger
discrete_distribution, Zufallszahlenverteilung
Domain-Specific-Embedded-Language, Benutzerdefinierte Literale
Domain-Specific-Language, Benutzerdefinierte Literale
Double-Checked Locking, Konstante Ausdrücke
Double-Checked Locking Pattern, Konstante Ausdrücke
Droba, Pavol, Neue String-Algorithmen
DSEL (Siehe Domain-Specific-Embedded-Language)
duration, Zufallszahlenverteilung
chrono, Zufallszahlen
duration_cast
chrono, Zeitdauer
dynamic_pointer_cast, shared_ptr von this
dynarray, Binäre Literale

E

Eager Evaluation, Verarbeitung von Listen
ECMAScript, Syntax der regulären Ausdrücke
egrep, Syntax der regulären Ausdrücke
einfach verkettete Liste, Array, Array
Ellipse, Generische Programmierung
emplace
Container, Praktische Helferlein
emplace_back
Container, Praktische Helferlein
emplace_front
Container, Praktische Helferlein
enable_shared_from_this, Löschfunktion, Konvertierung in Ableitungshierarchien
enum, Streng typisierte Aufzählungstypen
erase
Hashtabelle, Hashtabellen
Erfassungsgruppe, Reguläre Ausdrücke, Analyse des Suchergebnisses mit match_results
expired
weak_ptr, weak_ptr
explicit, Expliziter Konvertierungsoperator, Expliziter Konvertierungsoperator
explicit operator bool, Expliziter Konvertierungsoperator
expliziter Konvertierungsoperator, override und final
exponential_distribution, Zufallszahlenverteilung
export, Removed und Deprecated
extended, Reguläre Ausdrücke
externT, Unicode-Unterstützung
extreme_value_distribution, Zufallszahlenverteilung

F

Farkas, Attila, Unbeschränkte Unions
Fassette, Unicode-Unterstützung
fill, Typen transformieren
filter, Funktionen höherer Ordnung, Funktionen höherer Ordnung, Funktionen höherer Ordnung
final, Explizite Klassendefinitionen, default und delete
find
Hashtabelle, Hashtabellen, Hashtabellen
first
Hashtabelle, Hashtabellen
First-class functions, Charakteristiken funktionaler Programmierung
fisher_f_distribution, Zufallszahlenverteilung
flags
regex, Objekte vom Typ regulärer Ausdruck
fold, Variadic Templates, Funktionen höherer Ordnung, Funktionen höherer Ordnung
format_first_only
regex_constants, Ersetzen mit regex_replace
format_not_copy
regex_constants, Ersetzen mit regex_replace
format_no_copy
regex_constants, Ersetzen mit regex_replace
forward, Perfect Forwarding, Perfect Forwarding
forward_list, Array, Array
for_each, Die Range-basierte For-Schleife, function
string, Lambda-Funktionen
vector, Welche Vorteile bietet ein Funktionsobjekt?
__func__, nullptr
function, bind und function, Die Hilfsfunktionen ref und cref, bind und function, bind, First-class functions
funktionale Programmierung, Funktionale Programmierung
funktionaler Stil, Funktionale Programmierung
Funktionen höherer Ordnung, First-class functions
Funktionsabschluss, Bindung an den lokalen Bereich: [ ]
Funktionsobjekt, Funktionsobjekte
Funktor, Funktionsobjekte
future, Synchronisation von Threads, Asynchrone Aufgaben, Asynchrone Aufgaben, future und promise, future und promise

G

Gamma, Erich, Explizite Klassendefinitionen, Konstante Ausdrücke
Gammaverteilung, Zufallszahlen
gamma_distribution, Zufallszahlenverteilung
Gang of Four, Explizite Klassendefinitionen
Gaußverteilung, Zufallszahlen
geometric_distribution, Zufallszahlenverteilung
get
array, unique_ptr, Hilfsfunktionen
future, Asynchrone Aufgaben, future und promise
Referenz-Wrapper, Referenz-Wrapper
shared_ptr, shared_ptr
this_thread, Operationen auf Threads
tuple, Tupel, Tupel
unique_ptr, unique_ptr
getloc
regex, Objekte vom Typ regulärer Ausdruck
get_deleter
shared_ptr, Löschfunktion
get_future
package_task, packaged_task
promise, Asynchrone Aufgaben, future und promise
get_id
thread, Operationen auf Threads
Goerzen, John, Funktionen höherer Ordnung
greater, bind
Gregor, Douglas, Lvalue- versus Rvalue-Referenzen, Erweiterte Thread-Funktionalität
grep, Syntax der regulären Ausdrücke

H

hardware_concurrency
thread, Operationen auf Threads, Operationen auf Threads, async, packaged_task
hash
Hashfunktion, Hashfunktion
Hashfunktion, Hashfunktion, Hashfunktion
Hashtabellen, Einfach verkettete Liste, regex_iterator, Einfach verkettete Liste
Hashwert, Hashfunktion
Haskell, Die Range-basierte For-Schleife, Multithreading, Alternative Funktionssyntax, Vererbung von Konstruktoren, Variadic Templates, function, Module, Funktionale Programmierung, Funktionen höherer Ordnung, Funktionen höherer Ordnung, Rekursion, Verarbeitung von Listen, Verarbeitung von Listen
has_virtual_destructor, Typeigenschaften
Heap, Praktische Helferlein
Heinzen, Hans-Werner, Unicode-Unterstützung
Helm, Richard, Explizite Klassendefinitionen, Konstante Ausdrücke
Henneberg, Jens, Gruppierungen
Henney, Kevlin, Technical Report 2, Signale und Slots, Bibliothek zur lexikalischen Konvertierung
high_resolution_clock, Zufallszahlenverteilung, Zeitgeber
Hinnant, Howard E., Move-Semantik, Technical Report 2

I

icase
regex_constants, Gruppierungen
ignore, Hilfsfunktionen
imbue
regex, Objekte vom Typ regulärer Ausdruck
implizite Verengung, Vereinheitlichte Initialisierung
in
codecvt, Unicode-Unterstützung
independent_bits_engine, Zufallszahlenerzeuger
Initialisiererlisten, Lambda-Funktionen
initializer_list, Entwurf von Klassen, Initialisiererlisten für Konstruktoren
inline, Benutzerdefinierte Literale
internT, Unicode-Unterstützung
iota, Neue Algorithmen, Neue Algorithmen, Neue Algorithmen
isupper, Die Range-basierte For-Schleife
is_abstract, Typeigenschaften
is_arithmetic, Zusicherungen zur Compile-Zeit, Primäre Typkategorien
is_array, Type-Traits
is_assignable, Typeigenschaften
is_base_of, Typen vergleichen
is_class, Type-Traits
is_compound, Primäre Typkategorien
value, Zusammengesetzte Typkategorien
is_const, Typeigenschaften, Typen transformieren, Typen transformieren
is_constructible, Typeigenschaften
is_convertible, Typen vergleichen
is_copy_assignable, Typeigenschaften
is_copy_constructible, Typeigenschaften
is_default_constructible, Typeigenschaften
is_destructible, Typeigenschaften
is_empty, Typeigenschaften
is_enum, Type-Traits
is_explicitly_convertible, Typen vergleichen
is_floating_point, Type-Traits
is_function, Type-Traits
is_fundamental, Primäre Typkategorien, Zusammengesetzte Typkategorien
is_heap, Neue Algorithmen, Praktische Helferlein
is_heap_until, Neue Algorithmen, Praktische Helferlein, Praktische Helferlein
is_integral, Type-Traits, Zusammengesetzte Typkategorien
is_literal_type, Typeigenschaften
is_member_function_pointer, Type-Traits
is_member_object_pointer, Type-Traits
is_move_assignable, Typeigenschaften
is_move_constructible, Typeigenschaften
is_nothrow_assignable, Typeigenschaften
is_nothrow_constructible, Typeigenschaften
is_nothrow_copy_assignable, Typeigenschaften
is_nothrow_copy_constructible, Typeigenschaften
is_nothrow_default_constructible, Typeigenschaften
is_nothrow_destructible, Typeigenschaften
is_nothrow_move_assignable, Typeigenschaften
is_nothrow_move_constructible, Typeigenschaften
is_object, Primäre Typkategorien
is_partitioned, Neue Algorithmen, Neue Algorithmen
is_pod, Plain Old Data (POD), Typeigenschaften
is_pointer, Type-Traits
is_polymorphic, Typeigenschaften
is_reference, Type-Traits, Type-Traits
is_same, Typen vergleichen, Typen transformieren
is_scalar, Primäre Typkategorien
is_signed, Typeigenschaften
is_sorted, Neue Algorithmen, Neue Algorithmen
is_sorted_until, Neue Algorithmen
is_standard_layout, Typeigenschaften
is_steady
Zeitgeber, Zeitgeber
is_trivial, Typeigenschaften
is_trivially_assignable, Typeigenschaften
is_trivially_constructible, Typeigenschaften
is_trivially_copyable, Typeigenschaften
is_trivially_copy_assignable, Type-Traits, Type-Traits, Typeigenschaften
is_trivially_copy_constructible, Typeigenschaften
is_trivially_default_constructible, Typeigenschaften
is_trivially_destructible, Type-Traits
is_trivially_move_assignable, Typeigenschaften
is_trivially_move_constructible, Typeigenschaften
is_union, Type-Traits
is_unsigned, Typeigenschaften
is_void, Type-Traits
is_volatile, Typeigenschaften
iter_swap, Type-Traits, Typen transformieren

J

Java, Die Standardisierung, Kernsprache, Das C++11-Speichermodell, Das C++11-Speichermodell, Atomare Datentypen
Johnson, Ralph, Explizite Klassendefinitionen, Vererbung von Konstruktoren
join
Container, Funktionen höherer Ordnung
thread, Erzeugung von Threads, Lebenszeit der Daten, Operationen auf Threads
joinable
thread, Lebenszeit der Daten, Lebenszeit der Daten
Josuttis, Nicolai, shared_ptr von this

K

Kalev, Danny, Unbeschränkte Unions
Kapazität, Hashfunktion
Kohloff, Christopher, Erweiterte Thread-Funktionalität
konstanter Ausdruck, Konstante Ausdrücke, Erweiterte Datenkonzepte und Literale, Sichere Initialisierung der Daten
benutzerdefinierte Typen, Konstante Ausdrücke
Funktion, Konstante Ausdrücke
Variable, Konstante Ausdrücke
Konstruktor
constant expression constructor, Konstante Ausdrücke
Delegation, Mächtigere Initialisierung, Initialisiererlisten für Konstruktoren
Initialisiererliste, Mächtigere Initialisierung, Entwurf von Klassen
Konvertierungskonstruktor, override und final
Sequenzkonstruktor, Entwurf von Klassen
Vererbung, Mächtigere Initialisierung, Delegation von Konstruktoren
Konvertierungsoperator, override und final
Kozicki, Bronek, Move-Semantik
Kreft, Klaus, Unicode-Unterstützung
Krügler, Daniel, Konstante Ausdrücke
Kurzschlussauswertung, Verarbeitung von Listen, Bedarfsauswertung

L

L
Unicode, Raw-String-Literale
Ladefaktor, Hashfunktion
Lambda-Funktionen, Lambda-Funktionen, Alternative Funktionssyntax
Argumente, Bindung an den lokalen Bereich: [ ]
Bindung an den lokalen Bereich, Lambda-Funktionen als temporäre Funktionsobjekte
Funktionskörper, Funktionskörper: { }
Klassenelemente, Bindung an den lokalen Bereich: [ ]
Rückgabewert, Bindung an den lokalen Bereich: [ ]
temporäre Funktionsobjekte, Lambda-Funktionen als temporäre Funktionsobjekte
Lamport, Leslie, Das C++11-Speichermodell
Landin, Peter J., Das automatische Ableiten von Typen
Langer, Angelika, Unicode-Unterstützung
lassen, Array
Lavavej, Stephan T., Microsoft Visual C++
Lazy Evaluation, async, Verarbeitung von Listen
linear_congruential_engine, Zufallszahlenerzeuger
Lisp, Benutzerdefinierte Literale, Verarbeitung von Listen
list, Die Range-basierte For-Schleife, Array
List Comprehension, Funktionen höherer Ordnung
Literal-Operator, Benutzerdefinierte Literale
Literale, Aliase Templates, Konstante Ausdrücke
benutzerdefinierte Literale, Streng typisierte Aufzählungstypen
nullptr, nullptr
Raw-String-Literale, Streng typisierte Aufzählungstypen
Unicode-String-Literale, Streng typisierte Aufzählungstypen
lock, Locks
mutex, Mutexe, Mutexe
weak_ptr, weak_ptr, Zyklische Referenzen
lock_guard, Schutz der Daten, Atomare Datentypen, Mutexe, Thread-lokale Daten, Synchronisation der Threads
lognormal_distribution, Zufallszahlenverteilung
long long int, nullptr

M

make_heap, Praktische Helferlein
make_signed, Typen transformieren
make_tuple, Smart Pointer, Tupel
make_unsigned, Typen transformieren
Manson, Jeremy, Das C++11-Speichermodell
map, Einfach verkettete Liste, Hashtabellen, Hashfunktion, Funktionen höherer Ordnung, Funktionen höherer Ordnung, Funktionen höherer Ordnung
mark_count
regex, Objekte vom Typ regulärer Ausdruck
match_results, Analyse des Suchergebnisses mit match_results, Analyse des Suchergebnisses mit match_results
regex, regex_iterator
match_results.format, Ersetzen mit regex_replace
mathematische Funktionen, Module
max
Generator, Zufallszahlenerzeuger
max_load_factor
Hash, Hashfunktion
memcmp, Atomare Datentypen
memcpy, Konstante Ausdrücke, Plain Old Data (POD), Plain Old Data (POD), Atomare Datentypen, Type-Traits
memmove, Konstante Ausdrücke, Plain Old Data (POD), Plain Old Data (POD), Type-Traits
memset, Konstante Ausdrücke, Plain Old Data (POD), Plain Old Data (POD)
Mersenne-Twister, Zufallszahlen
mersenne_twister_engine, Zufallszahlenerzeuger
Metafunktion, regex_token_iterator, Typen transformieren
Meyers, Scott, Konstante Ausdrücke, Statische Variablen in einem Blockbereich
Microsoft, Download der Codebeispiele, Einfach verkettete Liste, function
Milewskis, Bartosz, Das C++11-Speichermodell
milliseconds
chrono, Synchronisation von Threads, Synchronisation der Threads
min
Generator, Zufallszahlenerzeuger
minmax, Neue Algorithmen
minmax_element, Neue Algorithmen, Praktische Helferlein
minutes
chrono, Zeitdauer
Module, dynarray
Monaden, Reine Funktionen
move, Rvalue-Referenzen, Smart Pointer, default und delete, Lvalue- versus Rvalue-Referenzen, Move-Semantik, Move-Semantik, Perfect Forwarding, Plain Old Data (POD)
unique_ptr, unique_ptr, Konvertierung in Ableitungshierarchien
Move-Semantik, Rvalue-Referenzen, Rvalue-Referenzen, Lvalue- versus Rvalue-Referenzen, Lebenszeit der Daten, future und promise, Praktische Helferlein
auto_ptr, unique_ptr
multimap, Einfach verkettete Liste
multiset, Einfach verkettete Liste
mutable, Lambda-Funktionen als temporäre Funktionsobjekte
mutex, Erzeugung von Threads, Atomare Datentypen, Gemeinsam von Threads genutzte Daten
mutual exclusion, Erzeugung von Threads

N

narrowing, Vereinheitlichte Initialisierung
native_handle
mutex, Mutexe
thread, Operationen auf Threads
negative_binomial_distribution, Zufallszahlenverteilung
new
Operator, Implizit erzeugte Methoden und Operatoren
noexcept, Deprecated
none_of, Neue Algorithmen, Neue Algorithmen, Neue Algorithmen
Normalverteilung, Zufallszahlen
normal_distribution, Zufallszahlenverteilung
nothrow, Typeigenschaften
notify_all
condition_variable, Synchronisation von Threads, Synchronisation der Threads
notify_one
condition_variable, Synchronisation von Threads, Synchronisation der Threads, Synchronisation der Threads
now
Zeitgeber, Zeitbibliothek, Zeitgeber
NULL
Mehrdeutigkeit, Benutzerdefinierte Literale
nullptr, nullptr, Benutzerdefinierte Literale
Nullzeigerkonstante, nullptr

O

once_flag, Sichere Initialisierung der Daten, Konstante Ausdrücke
Opdyke, William, Vererbung von Konstruktoren
Operator
Literal-Operatoren, Streng typisierte Aufzählungstypen, Benutzerdefinierte Literale
operator +, Move-Semantik
placement-new, Unbeschränkte Unions
operator()
Funktionsobjekt, Wie funktioniert ein Funktionsobjekt?
Hashfunktion, Hashfunktion
optional, Binäre Literale
Oracle, Die Standardisierung
out
codecvt, Unicode-Unterstützung
override, Explizite Klassendefinitionen, default und delete
O’Sullivan, Bryan, Funktionen höherer Ordnung

P

packaged_task, async, future und promise
pair, Zyklische Referenzen
Parameter Pack, Variadic Templates
partielle Ordnung von Operationen, Das C++11-Speichermodell
partition_copy, Neue Algorithmen, Neue Algorithmen
partition_point, Neue Algorithmen, Neue Algorithmen
Perfect Forwarding, Rvalue-Referenzen, Rvalue-Referenzen, Move-Semantik
Perl, Neue String-Algorithmen
Peters, Tim, Mächtigere Initialisierung
piecewise_constant_distribution, Zufallszahlenverteilung
piecewise_linear_distribution, Zufallszahlenverteilung
Plain Old Data, Konstante Ausdrücke, Plain Old Data (POD)
Platzhalter, function
POD (Siehe Plain Old Data)
Poisson-Verteilung, Zufallszahlen
poisson_distribution, Zufallszahlenverteilung
Prädikat, Neue Algorithmen, function, function
prefix
smatch, Reguläre Ausdrücke
printf
Variadic Templates, Variadic Templates
promise, Synchronisation von Threads, future und promise, future und promise
Promotion Traits, Alternative Funktionssyntax, Promotion Trait
pthread, Operationen auf Threads
Python, Die Standardisierung, Kernsprache, Lambda-Funktionen, Mächtigere Initialisierung, Streng typisierte Aufzählungstypen, Funktionskörper: { }, Perfect Forwarding, Variadic Templates, Formatieren mit regex_replace und match_results.format, regex_token_iterator, Hilfsfunktionen, Neue String-Algorithmen, Funktionsobjekte, Funktionen höherer Ordnung, Funktionen höherer Ordnung

R

R
Raw-String, Raw-String-Literale
RAII (Siehe Resource Acquisition Is Initialization)
Ralph, Johnson, Konstante Ausdrücke
random_device, Zufallszahlenerzeuger
Range-basierte For-Schleife, Kernsprache, Usability
rank, Typeigenschaften
raw, Benutzerdefinierte Literale
Raw-String-Literal, Streng typisierte Aufzählungstypen, Reguläre Ausdrücke, Gruppierungen
recursive_mutex, Gemeinsam von Threads genutzte Daten
recursive_timed_mutex, Gemeinsam von Threads genutzte Daten
reduce, Variadic Templates
ref, Referenz-Wrapper, Referenz-Wrapper, Hilfsfunktionen
reference_wrapper, Referenz-Wrapper
Referenz-Wrapper, Zeitbibliothek
Referenzielle Transparenz, Programmieren mit mathematischen Funktionen
regex, Gruppierungen, Objekte vom Typ regulärer Ausdruck
regex_constants, Exakte Treffer mit regex_match
regex_iterator, Formatieren mit regex_replace und match_results.format
regex_match, Reguläre Ausdrücke, Analyse des Suchergebnisses mit match_results, Analyse des Suchergebnisses mit match_results
regex_replace, Reguläre Ausdrücke, Suchen mit regex_search, Ersetzen mit regex_replace
regex_search, Reguläre Ausdrücke, Analyse des Suchergebnisses mit match_results, Exakte Treffer mit regex_match
regex_token_iterator, regex_iterator
register, Removed und Deprecated
reguläre Ausdrücke, Die Standardbibliothek
Alternative, Wiederholungen
capture groups, Wiederholungen
Erfassungsgruppen, Wiederholungen
Gruppierungen, Wiederholungen
Metazeichen, Syntax der regulären Ausdrücke
Rückwärtsreferenzen, Gruppierungen
Wiederholungen, Zeichenklassen
Zeichen, Syntax der regulären Ausdrücke
Zeichenauswahl, Metazeichen
Zeichenklassen, Metazeichen
rehash
Hash, Hashfunktion
Reine Funktionen, Funktionen höherer Ordnung
Rekursion, Rekursion
release
unique_ptr, unique_ptr, shared_ptr
remove, Funktionen höherer Ordnung
forward_list, Einfach verkettete Liste
remove_all_extents, Typen transformieren
remove_cv, Typen transformieren
remove_extent, Typen transformieren
remove_if, Funktionen höherer Ordnung
forward_list, Einfach verkettete Liste
remove_pointer, Typen transformieren
remove_reference, Move-Semantik, Typen transformieren
remove_volatile, Typen transformieren
reset
packaged_task, packaged_task
shared_ptr, shared_ptr, Löschfunktion, shared_ptr von this
unique_ptr, unique_ptr
Verteilung, Zufallszahlenverteilung
Resource Acquisition Is Initialization, Schutz der Daten, Resource Acquisition Is Initialization
result_of, bind und function
result_type
Generator, Zufallszahlenerzeuger
Return-Value-Optimierung, Move-Semantik
Riley, James Whitcomb, Lambda-Funktionen
Rossum, Guido van, Die Standardisierung
runtime_error, future und promise
Rvalue
Version 1, Lvalue- versus Rvalue-Referenzen
Version 2, Lvalue- versus Rvalue-Referenzen
Rvalue-Referenzen, Rvalue-Referenzen, Rvalue-Referenzen, Rvalue-Referenzen
RVO, Move-Semantik

S

Scala, Die Range-basierte For-Schleife, Module
Schablonenmethode, override und final
Schönfinkel, Moses, function
Schönfinkeln, function
second
Hashtabelle, Hashtabellen
seed, Zufallszahlen
random_device, Wie funktioniert Template-Metaprogrammierung?
sequenzielle Konsistenz, Das C++11-Speichermodell
set, Einfach verkettete Liste, Vereinheitlichte Initialisierung, Aliase Templates
set_exception
future, Asynchrone Aufgaben
promise, future und promise
set_value
future, Asynchrone Aufgaben
promise, future und promise, future und promise
share
future, future und promise
shared_from_this, Löschfunktion
shared_future, Asynchrone Aufgaben, future und promise
shared_ptr, Smart Pointer, shared_ptr, weak_ptr
shrink-to-fit
Container, Praktische Helferlein
shrink_to_fit
Container, Praktische Helferlein
shuffle_order_engine, Zufallszahlenerzeuger
Singleton Pattern, default und delete
Sink and Source-Idiom, unique_ptr
sizeof, Variadic Templates, Generische Programmierung
sleep
thread, Mutexe
sleep_for
this_thread, Synchronisation von Threads, Synchronisation der Threads
thread, Atomare Datentypen, Operationen auf Threads
sleep_until
thread, Operationen auf Threads
Smart Pointer, Smart Pointer
Software Transactional Memory, Multithreading
sort
vector, Funktionsobjekte
sort_heap, Praktische Helferlein
Speichermodell, Das C++11-Speichermodell, Das C++11-Speichermodell
Speichersichtbarkeit, Das C++11-Speichermodell
splice_after
forward_list, Einfach verkettete Liste
split
Python, regex_token_iterator
Spolsky, Joel, Unicode-Unterstützung
sregex_token_iterator, regex_iterator, regex_token_iterator
stack frame, Rekursion
Standard
TR2, Technical Report 2
Standardlayout, Plain Old Data (POD)
stateT, Unicode-Unterstützung
static template metaprogramming, Reguläre Ausdrücke
static_assert, Variadic Templates, Variadic Templates, Konstante Ausdrücke
static_pointer_cast, shared_ptr von this
steady_clock, Zufallszahlenverteilung, Zeitgeber
Stewart, Don, Funktionen höherer Ordnung
STM (Siehe Software Transactional Memory)
Strachey, Christopher, Lvalue- versus Rvalue-Referenzen
streng typisierte Aufzählungstypen, Streng typisierte Aufzählungstypen, Unbeschränkte Unions
string, Array
typedef, Unicode-Unterstützung
Stroustrup, Bjarne, Einführung, Einführung, Die Standardisierung, Die Standardisierung, Move-Semantik, Suchen mit regex_search, Formatieren mit regex_replace und match_results.format
student_t_distribution, Zufallszahlenverteilung
subtract_with_carry_engine, Zufallszahlenerzeuger
sub_match, Analyse des Suchergebnisses mit match_results, Analyse des Suchergebnisses mit match_results
Sun, Die Standardisierung
Sutter, Herb, Variadic Templates, Deprecated
swap, Lvalue- versus Rvalue-Referenzen
packaged_task, packaged_task
regex, Objekte vom Typ regulärer Ausdruck
thread, Operationen auf Threads
unique_ptr, unique_ptr
weak_ptr, weak_ptr
syntactic sugar, Lambda-Funktionen, Funktionen höherer Ordnung
system_clock, Zufallszahlenverteilung, Zeitgeber
chrono, Zeitgeber

T

T&
Referenz-Wrapper, Referenz-Wrapper
tail recursive, Rekursion
Takt, Zufallszahlen
Technical Report 1, Die Standardbibliothek
Template Aliases, Zusicherungen zur Compile-Zeit
Template Parameter Pack, Generische Programmierung
Template Typedef, Zusicherungen zur Compile-Zeit
Template-Metaprogramming, regex_token_iterator
terminate, Deprecated, Operationen auf Threads
this
Lambda-Funktionen, Bindung an den lokalen Bereich: [ ]
thread, Threads, Generische Programmierung, Threads
Thread-lokaler Speicher, Thread-lokale Daten
thread_local, Sichere Initialisierung der Daten, Thread-lokale Daten
tick period, Zeitbibliothek
tie, Tupel
timed_mutex, Gemeinsam von Threads genutzte Daten
time_point, Zufallszahlenverteilung
time_since_epoch
Zeitpunkt, Zeitgeber
TR1, bind und function, dynarray
TR2, dynarray, Technical Report 2
transfer of ownership, Lebenszeit der Daten
transform, Funktionen höherer Ordnung
trivial, Plain Old Data (POD)
true_type, Type-Traits
try_lock, Locks
mutex, Mutexe
try_lock_for
mutex, Mutexe
thread, Mutexe
try_lock_until
mutex, Mutexe
tuple, Rvalue-Referenzen, Smart Pointer, Generische Programmierung, Variadic Templates, Zyklische Referenzen, Hilfsfunktionen, dynarray
tuple_element, Hilfsfunktionen
tuple_size, Hilfsfunktionen
type
Metatyp, Move-Semantik, Typen transformieren, Typen transformieren, Hilfsfunktionen
type inference, Das automatische Ableiten von Typen
Type-Traits, Reguläre Ausdrücke
typedef, Aliase Templates
atto, Zeitdauer
centi, Zeitdauer
cmatch, Analyse des Suchergebnisses mit match_results
cregex_iterator, regex_iterator
csub_match, Analyse des Suchergebnisses mit match_results
deca, Zeitdauer
deci, Zeitdauer
default_random_engine, Zufallszahlenerzeuger
duration, Zeitgeber
exa, Zeitdauer
femto, Zeitdauer
giga, Zeitdauer
hecto, Zeitdauer
hours, Zeitdauer
kilo, Zeitdauer
knuth_b, Zufallszahlenerzeuger
mega, Zeitdauer
micro, Zeitdauer
microseconds, Zeitdauer
milli, Zeitdauer
milliseconds, Zeitdauer
minstd_rand, Zufallszahlenerzeuger
minstd_rand0, Zufallszahlenerzeuger
minutes, Zeitdauer
mt19937, Zufallszahlenerzeuger
mt19937_64, Zufallszahlenerzeuger
nano, Zeitdauer
nanoseconds, Zeitbibliothek
period, Zeitgeber
peta, Zeitdauer
pico, Zeitdauer
ranlux24, Zufallszahlenerzeuger
ranlux24_base, Zufallszahlenerzeuger
ranlux48, Zufallszahlenerzeuger
ranlux48_base, Zufallszahlenerzeuger
regex, Gruppierungen
rep, Zeitgeber
seconds, Zeitdauer
smatch, Analyse des Suchergebnisses mit match_results
sregex_iterator, regex_iterator
ssub_match, Analyse des Suchergebnisses mit match_results
string, Unicode-Unterstützung
tera, Zeitdauer
time_point, Zeitgeber
u16string, Unicode-Unterstützung
u32string, Unicode-Unterstützung
wcmatch, Analyse des Suchergebnisses mit match_results
wcregex_iterator, regex_iterator
wcsub_match, Analyse des Suchergebnisses mit match_results
wregex, Gruppierungen
wsmatch, Analyse des Suchergebnisses mit match_results
wsregex_iterator, regex_iterator
wssub_match, Analyse des Suchergebnisses mit match_results
wstring, Unicode-Unterstützung
typeid, Alternative Funktionssyntax
Typklassen, Module

U

U
Unicode, Raw-String-Literale
u
Unicode, Raw-String-Literale
u8
Unicode, Raw-String-Literale
unbeschränkte Unions, Konstante Ausdrücke, Plain Old Data (POD)
uncooked, Benutzerdefinierte Literale
Unicode-Unterstützung, Raw-String-Literale
uniform_int_distribution, Zufallszahlenverteilung
uniform_real_distribution, Zufallszahlenverteilung
unique
forward_list, Einfach verkettete Liste
shared_ptr, shared_ptr
unique_lock, Schutz der Daten, Synchronisation von Threads, Locks, Locks, Synchronisation der Threads
unique_ptr, Smart Pointer, Move-Semantik, Verbesserte Bibliotheken
vector, unique_ptr
unlock
mutex, Mutexe
unordered_map, Hashtabellen, Hashtabellen
unordered_multimap, Hashtabellen, Hashtabellen
unordered_multiset, Hashtabellen, Vereinheitlichte Initialisierung, Hashtabellen
unordered_set, Hashtabellen, Hashtabellen, Hashfunktion
Unruh, Erwin, Konstante Ausdrücke
unterstützt, unique_ptr
use_count
shared_ptr, shared_ptr
weak_ptr, weak_ptr, Zyklische Referenzen
using, Variadic Templates, Delegation von Konstruktoren, Zusicherungen zur Compile-Zeit
UTF-16, Raw-String-Literale
UTF-32, Raw-String-Literale
UTF-8, Raw-String-Literale

V

valid
packaged_task, packaged_task
value
Metawert, Variadic Templates, Typen transformieren, Hilfsfunktionen
Van Eerd, Tony, Atomare Datentypen
Vandevoorde, David, shared_ptr von this, dynarray
Variablen-Templates, Lambda-Funktionen
Variadic Templates, Rvalue-Referenzen, Perfect Forwarding, Generische Programmierung, Threads
vector, Vereinheitlichte Initialisierung, Hilfsfunktionen, Array
Verarbeiten von Listen, Verarbeitung von Listen
vereinheitlichte Initialisierung, Funktionskörper: { }
Virtualisierung, GCC bauen
Vlissides, John, Explizite Klassendefinitionen, Konstante Ausdrücke
volatile, Atomare Datentypen

W

wait
condition_variable, Synchronisation von Threads, Synchronisation der Threads
wbuffer_convert, Unicode-Unterstützung
wchar_t, Analyse des Suchergebnisses mit match_results
wcout, Suchen mit regex_search
wcregex_token_iterator, regex_token_iterator
weak_ptr, Smart Pointer, weak_ptr
weibull_distribution, Zufallszahlenverteilung
Wide-Strings, Raw-String-Literale
Williams, Anthony, Atomare Datentypen, Lebenszeit der Daten
wregex, Gruppierungen, Objekte vom Typ regulärer Ausdruck
wrgx, Suchen mit regex_search
wsmatch, Suchen mit regex_search
wsregex_token_iterator, regex_token_iterator
wstring, Suchen mit regex_search
typedef, Unicode-Unterstützung
wstring_convert, Unicode-Unterstützung

Y

yield
thread, Operationen auf Threads

Z

Zeitbibliothek, Zufallszahlen
Zeitpunkt, Zufallszahlen
Zufallszahlen, Wie funktioniert Template-Metaprogrammierung?
Zusicherungen zur Compile-Zeit, Variadic Templates
zyklische Referenz, Smart Pointer
zyklische Referenzen, weak_ptr