C++ Kurzreferenz
Ablaufsteuerung
Programmstruktur
Abschluss Anweisung
Anweisungsblock
Rücksprung aus Funktion
aus void-Funktion
Sprung
aus Schleife / switch
ans Schleifenblock-Ende
innerhalb einer Funktion
Sprungziel
Kommentare
bis Zeilenende
Deklarationen
Hauptprogramm
auch:
/* Kommentar */
// Kommentar
typen, konstanten, funktionen
int main()
{anweisungen}
int main(int argc,
char* argv[])
optimierbar
LambdaAusdruck
Parameterliste
Vorgabewert
aufrufen
typ f (parameter );
typ f (parameter )
{anweisungen}
inline typ f (parameter )
{anweisungen}
auto f =
[capturelist](parameter )
{anweisungen};
typ name, ...
typ name=wert
f (argumente);
#ifndef name
#define name
deklarationen
#endif
#include "headername"
includes
Funktionen
namespace name {...}
namespace name = {...}
using ...
Präprozessoranweisungen
Einbinden
Bibliothek
eigene Datei
Makro
-”-Funktion
Beispiel:
\ mit Folgezeile
löschen
Zeichenkette
Verschmelzen
bedingte
Übersetzung
(optional)
(zwingend)
#ifdef x für
#ifndef x
einfach
optional
mehrfach
jeder Fall
mit Abschluss
sonst-Zweig
#include <datei >
#include "datei "
#define name text
#define name(var ) text
#define abs(x) \
(-(x)<(x))?(x):-(x))
#undef name
#x
a##b
#if bedingung
#elif
#else
#endif
#if defined(x )
#if !defined(x )
if(bedingung) anweisung
else anweisung
switch(ausdruck ) {
case wert: anweisungen
break;
default: anweisungen
}
Wiederholungen
kopfgesteuert
fußgesteuert
Module
Headerdatei *.h
mit Wächter
gegen doppelte
Deklaration
Implementierung
*.cpp / *.cc
Programmteil
Namensraum
Alias
importieren
break;
continue;
goto marke;
marke:
Entscheidungen
Funktionen
anmelden
festlegen
;
{anweisungen}
return wert;
return;
Zählschleife
über Bereich
while(bedingung)
anweisung
do anweisung
while(bedingung);
for(start;bedingung;schritt)
anweisung
for(auto i:{1,2,3})...
Zusicherungen / Ausnahmebehandlung
bei Übersetzung
prüfen, sonst
Ausnahme
möglich
fangen
behandeln
alle Typen
werfen
weiterwerfen
static assert(bedingung,
Meldung opt );
try {anweisungen}
catch(typ ausnahme)
{anweisungen}
catch(...){anweisungen}
throw ausdruck ;
throw;
(in catch-Block)
Konstanten (Literale)
Wahrheitswerte
Ganzzahlen
binär / oktal
hexadezimal
Gleitkommazahl
einfach genau
Einzelzeichen
oktal / hex
Zeile, Tab, ...
Zeichenkette
false true
0 1 -1234 1’234 12L 12U
0b10’1010 0377
0xFFFF
1.0 -0.9 3e8 1.6e-19
3.14f
’A’ ’z’ ’0’
’\101’ ’\xFF’
\n \t \r \’ \"
"nullterminiert"
Variablen
Variable
mit Anfangswert
Referenz
Zeiger
Feld (Reihe, array)
mit n Werten
mehrdimensional
Zeichenkette
Aggregatvariable structopt
mit Attributwerten
nur lesender Zugriff
trotzdem änderbar
beim Übersetzen berechenbar
statisch / lokale Bindung
flüchtig, nicht optimieren
Typen
typ name
=wert
typ& ref =alias
typ* p=adresse
typ name[n]
={wert0 , ...}
name[m][n]...
char s[]="az"
typ name
={wert, ...}
const ...
mutable ...
constexpr ...
static ...
volatile ...
Operatoren (nach Rang geordnet)
Namensbereich-Auflösung
Funktionsaufruf
Feldzugriff
Struktur-Komponente
Zugriff über Zeiger
Erhöhen, Absenken nach /
vor Auswertung
Vorzeichen
logisches / bitweises NICHT
Zeigerinhalt, Adresse
Speicher anfordern
freigeben (einzeln / Feld)
Speicherbedarf in Byte
Typecast
Komponentenauswahl
über Objektzeiger
mal, durch, Divisionsrest
addieren, subtrahieren
Bits um n schieben
kleiner (oder gleich)
größer (oder gleich)
gleich / ungleich
bitweises UND
bitweises Exklusiv-ODER
bitweises ODER
logisches UND
logisches ODER
bedingter Ausdruck
Zuweisung und Kurzschrift
für + - * / % << >> & | ^
Ausnahme auslösen
Liste von Ausdrücken
bereich::name
funktion()
feld [index ]
objekt.teil
zeiger ->teil
x ++ x -++x --x
+x -x
!x ~x
*zeiger &objekt
new typ [n]opt
delete[]opt zeiger
sizeof(name)
(typ)ausdruck
objekt.*kzeiger
zeiger ->*kzeiger
x *y x /y m%n
x +y x -y
m<<n m>>n
x <y x <=y
x >y x >=y
x ==y x !=y
x &y
x ^y
x |y
x &&y
x ||y
bed ?dann:sonst
x =wert
x +=y für x =x +y
throw ausdruck
,
Einstellige Operatoren, Zuweisungen von rechts,
alle anderen von links bindend.
hergeleitet
kein Typ
logisch, Zeichen
ganzzahlig
Modifizierer
nichtganzzahlig
Umbenennung
Aufzählung
Überlagerung
auto
void
bool char wchar t
short int long
signed unsigned
float double
typedef typ neuername;
using neuername=typ;
enum Typ {name=wert,...};
union Typ {komponenten};
Klassen, Strukturen
Ankündigung
Definition
Zugriffsrechte
Folge beliebig
struct Typ; class Typ;
class Typ {
public:/ private:/ protected:
methoden, attribute
};
Zugriff erlaubt
friend funktion / klasse
klassenbezogen
static methode / variable
Attribut
typ name;
Methodenkopf
typ f (parameter )
Modifizierer
constopt / overloadopt / finalopt
polymorph
virtual virtuelleMethode
virtual abstrakteMethode=0
Destruktor
virtualopt ~Typ()
Konstruktor
explicitopt Typ(parameter )
Kopierkonstruktor Typ(Typ& x)
Zuweisung
Typ& operator=(Typ& x)
Vererbung
class Abgeleitet
abgeleitet von :art Basis, ... {
überschreiben
zu ändernde methoden
ergänzen
zusatzkomponenten
};
Vererbungsart
public/ protected/ private
bei Rhombus
virtual Basis
Implementierung typ Typ::f (parameter )
Methode
{anweisungen}
Konstruktor
Typ::Typ(parameter )
Initialisiererliste :Basis(wert),attribut(wert)
{anweisungen}
Destruktor
Typ::~Typ(){anweisungen}
Objektzeiger
this
(in Methode)
Objekt anlegen
Typ objekt(startwerte);
Methodenruf
objekt.f (werte);
Schablonen
Funktion
Klasse
spezialisiert
template<class T >
funktionsdefinition
template<class T >
klassendefinition
Typ<T >
(c) René Richter 2004–2017 namespace-cpp.de
Standard-Bibliothek (Auswahl) Zeichenarten <cctype>
Zeichenketten <string view>
Literal
ab Zeiger p
n Zeichen
Zuweisungen
Vergleiche
Suchen liefert
von vorn
von hinten
falls in Liste
nicht in Liste
letzte ...
Iteratoren
lesend
rückwärts
Anzahl Zeichen
leer
Teilstring
Kopiere ab s[i ]
nach char-Feld p
&s[0]
n Zeichen
entfernen
"..."sv
string view(p)
string view(p, n)
s = s2
< <= == >= > !=
compare(s2 ,pos2opt ,n2opt )
compare(pos,n,s2 ,pos2 ,n2 )
npos bei Misserfolg
s.find(params)
s.rfind(params)
s.find first of(params)
s.find first not of(params)
s.find last of(params)
s.find last not of(params)
s.begin()
s.end()
s.cbegin() s.cend()
s.rbegin() s.rend()
s.crbegin() s.crend()
s.size()
s.empty()
s.substr(i ,n)
s.copy(p,n,i =0)
max. n Zeichen, ohne ’\0’
s.data()
s.remove prefix(n)
s.remove suffix(n)
Zeichenketten <string>
Literal
zusätzlich zu
Konstruktoren
n ab s[i ]
aus char[]
n mal c
Bereich
Verkettungen
Anhängen
Einfügen bei
Löschen
n ab s[i ]
Bereich
Ersetzen ab
Bereich
Inhalt löschen
Konversion
"..."s
string view:
mit params
string(s,i =0,n=npos)
string(ptr ,n opt )
string(n,c)
string(first,last)
string(string view )
to string(x )
s += s1 + s2
s.append(params)
s.insert(ipos,params)
s.insert(iter ,params)
s.erase(iter )
s.erase(i ,n)
s.erase(from,to)
s.replace(ipos,n,params)
s.replace(from,to,params)
s.clear()
stoi(s) stol(s)
stof(s) stod(s)
string view(s)
Kleinbuchstabe
Großbuchstabe
klein?
groß?
Buchstabe?
Buchstabe oder Ziffer?
Ziffer 0...9?
Hexziffer 0...9 A...F a...f
Leerraum, Tab, Zeilenende
Satzzeichen?
Steuerzeichen?
druckbar?
auch ’ ’
ohne ’ ’
tolower(c)
toupper(c)
islower(c)
isupper(c)
isalpha(c)
isalnum(c)
isdigit(c)
isxdigit(c)
isspace(c)
ispunct(c)
iscntrl(c)
isprint(c)
isgraph(c)
Reguläre Ausdrücke <regex>
Raw string s
Konstruktor
Typ
Übereinstimmung
Suchergebnis
Suche
gesamt
Teile
Ersetzen
R"delim(...)delim"
regex(s,type opt )
ECMAScript,basic,grep,...
regex match(s,rex )
regex match m
regex search(s,m,rex )
m[0]
m[1]...m[m.size()-1]
regex replace(s,rex ,new )
Mathematik <cmath>
Betrag / runden
dxe / bxc
√
xy / x
ex / ln x / lg x
trigonometrisch
Arcusfunktionen
im Kreis\(0, 0)
Hyberbelfkt.
fabs(x ) round(x )
ceil(x ) floor(x )
pow(x ,y) sqrt(x )
exp(x ) log(x ) log10(x )
sin(x ) cos(x ) tan(x )
asin(x ) acos(x ) atan(x )
atan2(y,x )
sinh(x ) cosh(x ) tanh(x )
Fehlererkennung <cassert>
Prüfung
bei Misserfolg
Test abschalten
vor
assert(Bedingung)
Ausschrift, Programmende
#define NDEBUG
#include <cassert>
Hilfsfunktionen <cstdlib>
Kommando
Programmende
system(befehl )
exit(fehlernum)
Ein-/Ausgabeströme <iostream>
Ausgabeströme (ostream)
Eingabeströme (istream)
formatierte Ausgabe
formatierte Eingabe
ein Zeichen c schreiben
Vorausschau
ein Zeichen c lesen
Zeichenkette char s[n] lesen
string s lesen
max. n char bis c übergehen
bisher erfolgreich?
solange Strom gültig
Fehlerzustand zurücksetzen
Formatierung mit
Eingabe
Ganzzahlbasis
Übergehen von
Whitespaces
Ausgabe
Zeilenvorschub
Puffer leeren
logische Werte
Zahldarstellung
Nichtganzzahlen
Genauigkeit
Ganzzahlbasis
Hexziffern, e/E
Ausgabebreite
Ausrichtung
Füllzeichen
Zeit ausgeben
cout cerr
cin
os<<wert
is>>variable
os.put(c)
is.peek()
is.get(c)
is.getline(s,n)
getline(is,s)
is.ignore(n,c)
if(os) ...
while(is) ...
stream.clear()
Manipulatoren <iomanip>
is>>manip
dec hex oct
ws noskipws
’ ’ ’\t’ ’\n’
os<<manip
endl
flush
noboolalpha
noshowpos noshowpoint
fixed scientific
setprecision(n)
dec hex oct noshowbase
nouppercase
setw(n)
(flüchtig)
left internal right
setfill(c)
put_time(tptr , "format")
cout<<fixed<<showpos<<setprecision(2)
<<right<<setw(10)<<x<<endl;
Dateiströme <fstream>
Eingabedatei
Ausgabedatei
E-/A-Datei
Modi aus ios
Beispiel:
ifstream is(name)
ofstream os(name)
fstream fs(name,modus)
out ate in app binary
ifstream d("a.txt",
ios::in|ios::binary)
unformatiert
is.read(adresse, nbytes)
lesen, schreiben
os.write(adresse, nbytes)
positionieren
is.seekg(pos)
relativ bezgl.
os.seekp(±n,ios::bezug)
vorn/aktuell/ende
bezug = beg cur end
Position
is.tellg()
erfragen
os.tellp()
Datei schließen
fs.close()
(automatisch)
Stringströme <sstream>
Eingabestrom
Ausgabestrom
alle Ausgaben
E-/A-Strom
istringstream is(string)
ostringstream os
os.str()
stringstream ss
I/O-Operatoren für Typ T überladen
ostream&
{ // ...
return
}
istream&
{ // ...
return
}
operator<<(ostream& os, T x)
os;
operator>>(istream& is, T& x)
is;
Zeitfunktionen <ctime>
Systemzeit
Zeitdifferenz
lokale und
Weltzeit
struct tm*
Wochentag
TagNr/Sommer
lokal → System
Zeichenkette
time(tptr ) (Sek. ab 1970)
difftime(t2 ,t1 )
localtime(tptr )
gmtime(tptr )
tm sec tm min tm hour
tm mday tm mon 0...11
tm year ab 1900
tm wday So=0...Sa=6
tm yday tm isdst
mktime(tmptr )
asctime(tmptr )
ctime(tptr )
Uhren und Zeitspannen <chrono>
Uhren
Zeitpunkt
konvertieren
Zeitspannen
berechnen
Ticks
Zeiteinheiten
umrechnen
gebrochen
SI-Vorsatz
<ratio>
10−24 ...10+24
(abhängig von
intmax t)
high resolution clock
steady clock
system clock
uhr ::now()
system clock::to time t(t1 )
system clock::from time t(t1 )
t1 .time since epoch()
t2 >=t1 t2 -t1 t1 +dt
dt.count()
duration<rep, ratio>
nanoseconds ... hours
duration cast<Ziel >(dt)
duration<double, milli>
yocto zepto atto femto
pico nano micro milli
centi deci deca hecto
kilo mega giga tera peta
exa zetta yotta
(c) René Richter 2004–2017 namespace-cpp.de
Schablonenbibliothek ( STL“)
”
mutierend (Reihenfolge ändernd)
Algorithmen <algorithm>
Umkehren
nicht modifizierend
Anwenden Fkt
Quantoren
Zählen wert
Zutreffen P
Suche nach wert
Zutreffen P
Wert ∈ [f2 ,l2 )
for each(f ,l ,Fkt)
all of(f ,l ,P )
any of(f ,l ,P )
none of(f ,l ,P )
count(f ,l ,wert)
... if(f ,l ,P )
find(f ,l ,wert)
... if(f ,l ,P )
... first of(f ,l ,f2 ,l2 P2 )
Schluss [f2 ,l2 )
... end(f ,l ,f2 ,l2 P2 )
Anfang [f2 ,l2 )
search(f ,l ,f2 ,l2 P2 )
nmalig
... n(f ,l ,n,wert P2 )
Nachbarn
Binärsuche wert
Grenzen
Bereich
Minimum
Maximum
im Bereich
(Position)
Eingrenzen
Vergleich
Sortierfolge
[f ,l )¡[f2 ,l2 )
Unterschied ab
adjacent find(f ,l P2 )
binary search(f ,l ,wert / )
lower bound(f ,l ,wert / )
upper bound(f ,l ,wert / )
equal range(f ,l ,wert / )
min(a,b / )
max(a,b / )
min element(f ,l / )
max element(f ,l / )
clamp(x ,lo,hi / )
equal(f ,l ,f2 P2 )
lexicographical compare(
f ,l ,f2 ,l2 / )
mismatch(f ,l ,f2 ,l2 P2 )
modifizierend (wertändernd)
Tauschen
Kopieren
Ausfüllen
mit Funktor
Ersetzen
Entfernen
ohne Dubletten
Umrechnen
swap(a,b)
copy(f ,l ,to)
... backward(f ,l ,to)
fill(f ,l ,wert)
... n(f ,n,wert)
generate(f ,l ,Gen)
... n(f ,n,Gen)
replace(f ,l ,alt,neu)
... if(f ,l ,P ,neu)
... copy(f ,l ,to,alt,neu)
... copy if(f ,l ,to,P ,neu)
remove(f ,l ,wert)
... if(f ,l ,P )
... copy(f ,l ,to,wert)
... copy if(f ,l ,to,P )
unique(f ,l P2 )
... copy(f ,l ,to P2 )
transform(f ,l ,to,Fkt)
transform(f ,l ,f2 ,l2 ,to,Fkt2 )
Teile tauschen
Durchmischen
n Werte
Permutieren
Sortieren
Teilbereich
Zweiteilen
bzgl. P
Mischen sortiert
[f ,l )
[f ,l )
[f ,l )
[f ,l )
[f ,l )
⊇ [f2 ,l2 )
∪ [f2 ,l2 )
∩ [f2 ,l2 )
\ [f2 ,l2 )
∆ [f2 ,l2 )
reverse(f ,l )
... copy(f ,l ,to)
rotate(f ,mitte,l )
... copy(f ,mitte,l )
shuffle(f ,l ,RandGen)
sample(f ,l ,to,n,RandGen)
next permutation(f ,l / )
prev permutation(f ,l / )
sort(f ,l / )
stable sort(f ,l / )
partial sort(f ,mitte,l / )
... copy(f ,mitte,l / )
nth element(f ,nth,l / )
partition(f ,l ,P )
stable partition(f ,l ,P )
merge(f ,l ,f2 ,l2 ,to / )
inplace ...(f ,mitte,l , / )
includes(f ,l ,f2 ,l2 / )
set union(f ,l ,f2 ,l2 ,to / )
set intersection(f ,l ,f2 ,l2 ,to / )
set difference(f ,l ,f2 ,l2 ,to / )
set symmetric difference(f ,l ,f2 ,l2 ,to / )
Zufallszahlen <random>
Entropiequelle
Zufallsgenerator
Verteilungen
Zufallswert
random device
mt19937(rd )
minstd rand(rd )
uniform int distribution(a,b)
uniform real distribution(a,b)
normal distribution(µ, σ)
dist(gen)
numerische Algorithmen <numeric>
Summe
Teilsummen
Nachbardifferenz
Skalarprodukt
accumulate(f ,l ,init ⊕ )
partial sum(f ,l ,to ⊕ )
adjacent difference(f ,l ,to )
inner product(f ,l ,f2 ,l2 ,init ⊕, )
Legende:
Iterator-Bereich [first,last)
Iterator Anfang Zielbereich
verallgemeinerte Funktionen
Generator x=Gen()
Prädikat bool P (x)
zweistellig bool P2 (x,y)
Vergleich bool /(x,y)
Binäroperator
optionales Argument, z.B. /
f ,l
to
Fkt,Fkt2
Gen
rand
P
P2
/
less<T>
⊕
plus<T>
/
Container
Allgemeine Container-Eigenschaften
Kopie
aus Bereich
Zuweisung
Tausch
Vergleich
lexikographisch
ist leer?
Anzahl Werte
max. Anzahl
Iteratoren
lesend
rückwärts
Einfügen
Entfernen
C (C 2 )
C (f ,l )
C =C 2
C .swap(C 2 )
== !=
< <= >= >
C .empty()
C .size()
C .max size()
C .begin()
C .end()
C .cbegin() C .cend()
C .rbegin() C .rend()
C .crbegin() C .crend()
C .insert(pos,x )
C .erase(pos)
C .erase(f ,l )
C .clear()
vector<T>
deque<T>
listT>
forward_list<T>
set<T>
multiset<T>
[1|2|3|4|5] <->
<-> [1|2|3|4|5] <->
[1]-[2]-[3]-[4]-[5]
->[1]->[2]->[3]->
{1 2 3 4 5}
{1 2 3 3 5}
map<Key, Value>
Mueller | 3373721
Schulze | 4632536
dynamisches Feld <vector>
sequentiell
Feldzugriff
vector<T>
C [index ] C .at(index )
doppelendige Schlange <deque>
wie vector<T>
Einfügen vorn
Entfernen vorn
deque<T>
C .push front(x )
C .pop front()
Listen <list> <forward list>
Sequentielle Container
vector<T> deque<T> list<T> forward list<T>
Konstruktoren
C (n)
C (n,x )
Zuweisung
n Std-Werte
C .assign(n)
n mal Wert x C .assign(n,x )
Bereich
C .assign(f ,l )
erstes Element
C .front()
letztes Element
C .back()
Einfügen bei pos C .insert(pos)
n mal Wert x C .insert(pos,n,x )
Bereich
C .insert(pos,f ,l )
am Ende
C .push back(x )
auf n Elemente
C .resize(n)
mit x auffüllen
C .resize(n,x )
Entferne hinten C .pop back()
Einfügen vorn
Einspleißen
ab start
Bereich f ,l
Einmischen
Sortieren
Umdrehen
Entfernen vorn
C .push front(x )
C .splice(pos,list)
C .splice(pos,list,start)
C .splice(pos,list,f ,l )
C .merge(list / )
C .sort( / )
C .reverse()
C .pop front()
C .remove(wert)
Zutreffen P
C .remove if(P )
Dubletten
C .unique( P2 )
forward list<T> C .before begin() / end()
C .splice after(pos,list...)
Mengen <set> <unordered set>
mehrere gleiche
Assoziative Container
unordered multi set<T>
unordered multi map<Key,Value>
Vergleich Werte C .value comp()
Schlüssel
C .key comp()
Zählen
C .count(key)
Suchen
C .find(key)
Anfang
C .lower bound(key)
Ende
C .upper bound(key)
Bereich
C .equal range(key)
Einfügen
C .insert(x )
Bereich
C .insert(f ,l )
Entfernen
C .erase(key)
Sortierkriterium
set<T / >
multiset<T / >
unordered set<T hash >
unordered multiset<T hash >
less<T> / hash<T>
Assoziative Felder <map> <unordered map>
gleiche Schlüssel
Einträge
Sortierkriterium
Wert-Zugriff
map<Key,Value / >
multimap<Key,Value / >
unordered map<Key,Value hash >
unordered multimap<Key,Value hash >
pair<const Key,Value>
less<T> / hash<T>
C .at(key) C [key]
C [key]=value
(c) René Richter 2004–2017 namespace-cpp.de
Zubehör
Wrapper
Container-Adapter <stack> <queue>
Smarte Zeiger
<memory>
Stapel stack<T>
ist leer?
Anzahl Elemente
Vergleiche
Einfügen Wert x
Entfernen (ohne Rückgabe)
oberstes Element
s.empty()
s.size()
< == ...
s.push(x )
s.pop()
s.top()
Warteschlange queue<T>
ist leer?
Anzahl Elemente
Vergleiche
Einfügen Wert x
Entfernen (ohne Rückgabe)
erstes Element
letztes Element
q.empty()
q.size()
< == ...
q.push(x )
q.pop()
q.front()
q.back()
... mit Vordrängeln priority queue<T C ,/ >
Sortierkriterium /
less<T>
ist leer?
p.empty()
Anzahl Elemente
p.size()
Einfügen Wert x
p.push(x )
Entfernen (ohne Rückgabe)
p.pop()
oberstes Element
p.top()
Heapfunktionen
aus <algorithm>
Herstellen Heap make heap(f ,l / )
*(l -1) dazu
push heap(f ,l , / )
*f nach hinten
pop heap(f ,l / )
Heap-Sort
sort heap(f ,l / )
Array <array> <valarray>
feste Größe
dyn. Größe
Elementauswahl
für 0 ≤ i < n
Operatoren
<cmath>
array<T ,N >
valarray<T >
v [slice(pos,n,dist)]
v [pos+i *dist]
+ - * / % & | ^ << >>
+ && || < <= >= > == !=
sqrt(v ) ...
Bitfolgen <bitset>
feste Größe N
aus Zahl
Zeichenkette
Bits setzen
löschen
negieren
gesetzte Bits
Konversion
bitset<N >
bitset(ulong)
bitset(str ,pos ,n )
b.set()
b.set(i)
b.reset() b.reset(i)
b.flip() b.flip(i)
b.count()
b.any()
b.none()
b.to string()
b.to ulong()
Zugriff
ohne Zähler
wieder zählen
evtl. vorhanden
<optional>
geordnetes Paar
<utility>
Vergleich
Tupel <tuple>
Zugriff
<variant>
bel. Typ <any>
unique ptr<T>
shared ptr<T>
make unique<T>(param)
make shared<T>(param)
*p p->member
weak ptr<T>(shared )
sp = w .lock()
optional<T>
o.has value()
o.value or(y)
pair<U,V>
p.first p.second
== <
tuple<Typliste>
make tuple(param)
t.get<Typ>() t.get<nr >()
variant<Typliste>
any
Funktoren <functional>
Objektklassen mit
einstellig
f (x )7→-x
f (x )7→!x
zweistellig
f (x,y)7→x +y
f (x,y)7→x -y
f (x,y)7→x *y
f (x,y)7→x /y
f (x,y)7→x %y
f (x,y)7→x ==y
f (x,y)7→x !=y
f (x,y)7→x >y
f (x,y)7→x <y
f (x,y)7→x >=y
f (x,y)7→x <=y
f (x,y)7→x &&y
f (x,y)7→x ||y
Negierer/Binder
f (args)7→!f (args)
f (args)7→f (fewer )
Methodenzeiger
Funktionszeiger
überladenem operator()
unary function<Arg,Res>
negate<T>
logical not<T>
binary function<A1 ,A2 ,Res>
plus<T>
minus<T>
multiplies<T>
divides<T>
modulus<T>
equal to<T>
not equal to<T>
greater<T>
less<T>
greater equal<T>
less equal<T>
logical and<T>
logical or<T>
not fn(args)
bind(f ,args)
mem fn(Klasse::methode)
function<R(ParamTypen)>
Beispiele:
int a[4] = { 1, 9, 6, 3 };
sort(a,a+4,greater<>()); // 9 6 3 1
transform(a,a+4,a,negate<>());
// -9 -6 -3 -1
function<int(int)> f =
[](int x){ return -x; };
transform(a,a+4,a,f);
// 9 6 3 1
Iteratoren <iterator>
Komplexe Zahlen <complex>
Iteratorkategorien
Spezialisierungen complex<float>
complex<double>
complex<long double>
Realteil
c.real()
real(c)
Imaginärteil
c.imag()
imag(c)
Betrag r
abs(c)
Winkel φ
arg(c)
Betragsquadrat
norm(c)
Konjugierte
conj(c)
polar(r,φ)
Funktionen aus
<cmath>
Output
Input
Forward
Bidirectional
Random Access
zusätzlich
zusätzlich
zusätzlich
Reverse (Bidirectional)
vertauschte Wirkung
versetzt darunterliegend
Operatoren
* ++
== != * -> ++
=
-< <= > >= + += -= []
++ -ri .base()
begin() --> end()
v
++
v
[............)
^ |
++ ^ |
rend()
<-- rbegin()
Iterator in um n weitersetzen
Abstand Input-Iteratoren
Zahlen-Wertebereiche <limits>
advance(in,n)
distance(f ,l )
Iterator-Adapter
Einfüger in Container C
an Position
insert iterator<C >
am Anfang
front insert iterator<C >
am Ende
back insert iterator<C >
Erzeugerinserter(C ,pos)
Funktionen
front inserter(C )
back inserter(C )
Beispiel:
copy(first,last,back_inserter(c2));
AusgabestromIteratoren
Konstruktor
Beispiel:
ostream iterator<T >
o(strom ,trennstring )
ostream_iterator<int> o(cout);
*o = 123; // cout << "123 ";
o++;
EingabestromIteratoren
Konstruktor
Beispiel:
istream iterator<T >
i ( strom )
istream_iterator<int> ende; // ohne Strom
istream_iterator<int> in(cin);
// liest und puffert 1. Wert
while(in != ende) {
wert = *in; // liefern
++in;
// neuen Wert einlesen
}
Schablone numeric limits<T>
Spezialisierungen für alle numerischen Typen
Angaben abrufbar
is specialized
kleinster Wert
min()
größter Wert
max()
Anzahl Ziffern (Basissystem) digits
im Dezimalsystem
digits10
vorzeichenbehaftet
is signed
ganzzahlig
is integer
beschränkt
is bounded
exakt
is exact
Überlauf möglich
is modulo
Zahlenbasis
radix
IEC 559 Fließkommatyp
is iec559
kleinstes e mit radixe
min exponent
mit 10e
min exponent10
größtes ...
max exponent
max exponent10
Wert für ∞ verfügbar
has infinity
∞
infinity()
kleinstes ε mit 1 + ε > 1
epsilon()
max. Rundungsfehler
round error()
Rundungsart
round style
round indeterminate
round toward zero
round to nearest
round toward infinity
...toward neg infinity
und weitere ...
Beispiel:
cout << numeric_limits<long>::min() << ’ ’
<< numeric_limits<long>::max();
Nur für Ausbildungszwecke.
Hinweise willkommen.
Recht auf Fehler vorbehalten.
(c) René Richter 2004–2017 namespace-cpp.de
© Copyright 2024 ExpyDoc
