Commit 9010ac2d authored by me's avatar me
Browse files

extended lstinline usage

parent 82a503c1
......@@ -10,9 +10,9 @@ Wenn der Operator aber inlined wird, dann sollte auch bei der postfix-Notation e
\begin{itemize}
\item std::cin nimmt auch eine Typprüfung vor.
\item Schlüsselwort ``explicit'' verhindert impliziten Aufruf bei Assignment. - Sinnvoll bei Copy-Constructor, wenn das Objekt sehr groß ist, um by-value-Funktionscalls zu vermeiden
\item Schlüsselwort ``auto'' als Typ lässt den Typ vom Compiler bei der Initialisierung bestimmen. Kann jedoch weder const, noch Referenzen repräsentieren.
\item \il{std::cin} nimmt auch eine Typprüfung vor.
\item Schlüsselwort \il{explicit} verhindert impliziten Aufruf bei Assignment. - Sinnvoll bei Copy-Constructor, wenn das Objekt sehr groß ist, um by-value-Funktionscalls zu vermeiden
\item Schlüsselwort \il{auto} als Typ lässt den Typ vom Compiler bei der Initialisierung bestimmen. Kann jedoch weder const, noch Referenzen repräsentieren.
\item In Bitfeldern sorgt ein 0-bitiger Eintrag für Alginment auf das nächste Byte
\item In Bitfeldern lassen sich mehrere Einträge zu einem zusammenfassen, z.B: int b:5, c:11 (Zugriff erfolgt über selben Eintrag)
\end{itemize}
\section{Lecture 2}
\begin{itemize}
\item Für float kann auch die Beschreibung $F$, statt $f$ verwendet werden
\item Operationen auf float sind wesentlich schneller als double
\item Für \il{float} kann auch die Beschreibung \il{F}, statt \il{f} verwendet werden
\item Operationen auf \il{float} sind wesentlich schneller als \il{double}
\item Declaration: Stellt die Definition irgendwo im Programm sicher (header)
\item Definition: Fordert Speicher für einen Typ an und initialisiert diesen optional (source)
\item potential scope: In dem die Variable sichtbar sein könnte, solange sie nicht überdeckt ist
......@@ -10,7 +10,7 @@
\begin{itemize}
\item C++-Referenz ist im Grunde ein Alias: type \&id = object;\\
\item C++-Referenz ist im Grunde ein Alias: type \il{&id = object;}\\
Der Unterschied zu einer C-Type-Referenz ist, es kann kein anderes Objekt referenzieren, nachdem es ein Objekt referenzierte
\item Nonconst reference kann nur an ein Objekt des identischen Typen der Referenz gehangen werden
\item const reference: kann darüberhinaus auch const object, nonconst object, Ergebnis einer Expression\\
......@@ -34,8 +34,8 @@ double dval = 3.14; int const &ri = dval;
\begin{itemize}
\item Synonym zu ``typedef type synonym'': ``using synonym = type''
\item decltype: Vererbt quasi den eigenen Typ weiter
\item Synonym zu \il{typedef type synonym} ist \il{using synonym = type}
\item \il{decltype}: Vererbt quasi den eigenen Typ weiter
\end{itemize}
\begin{figure}[h!]
......
......@@ -4,10 +4,10 @@
\caption[Expression-Klassen]{Expression-Klassen}
\label{fig:expr_cat_tax}
\end{figure}
\inde{lvalue}{Gibt Funktion oder Objekt zurück. Nonconst lvalue ist meist der linke Operand einer Zuweisung. Verfügt meist über eine Adresse. Kann nicht moved werden. Verfügen über eine Identität. Beispiele: a = b, a += b, ++a, a[n]}
\inde{xvalue}{Referenziert ein Objekt, das kurz vor dem Tod steht. Man möchte Ressourcen moven. Häufig in Kombination mit rvalue-Expressions. Sind somit Literale oder temporäre Objekte. Die referenzierten Variablen sind allerdings weiterhin lvalues. Können moved werden. Verfügen über eine Identität. Beispiele: std::move(a), a[n] wobei a ein rvalue}
\inde{lvalue}{Gibt Funktion oder Objekt zurück. Nonconst lvalue ist meist der linke Operand einer Zuweisung. Verfügt meist über eine Adresse. Kann nicht moved werden. Verfügen über eine Identität. Beispiele: \il{a = b, a += b, ++a, a[n]}}
\inde{xvalue}{Referenziert ein Objekt, das kurz vor dem Tod steht. Man möchte Ressourcen moven. Häufig in Kombination mit rvalue-Expressions. Sind somit Literale oder temporäre Objekte. Die referenzierten Variablen sind allerdings weiterhin lvalues. Können moved werden. Verfügen über eine Identität. Beispiele: \il{std::move(a), a[n]} wobei \il{a} ein rvalue}
\inde{glvalue}{schlicht eine Oberbezeichnung. Verfügt über eine Identität.}
\inde{prvalue}{``Pure rvalue'', das kein xvalue ist. Verfügen über keine Identität. Können moved werden. Beispiele: a++, a+b, a \&\& b, a \textless b, a == b}
\inde{prvalue}{``Pure rvalue'', das kein xvalue ist. Verfügen über keine Identität. Können moved werden. Beispiele: \il{a++, a+b, a && b, a < b, a == b}}
\inde{rvalue}{Gibt einen Wert, nicht jedoch die Adresse zurück. Kann moved werden.}
\begin{figure}[h!]
......@@ -32,7 +32,7 @@ float &&f(){return 2;}
\begin{itemize}
\item Überladene Operatoren behalten ihre Ausführungspriorität. d.h.\\
cout $<<(70<60) ?$ "fail" : "pass";\\
\il{cout <<(70<60) ? "fail" : "pass";}\\
gibt 1 oder 0 aus
\item \href{http://de.cppreference.com/w/cpp/language/operator_precedence}{Operatoren}
\end{itemize}
......@@ -41,9 +41,9 @@ gibt 1 oder 0 aus
\begin{itemize}
\item Promotion ist ein Cast in einen größeren Datentyp, ohne Informationsverlust
\item Conversion allgemeine Typumwandlung
\item static\_cast: Häufige Verwendung um implizite Umwandlung vom Compiler zu überschreiben
\item const\_cast: entfernt const
\item dynamic\_cast: Dynamischer Typ
\item \il{static_cast}: Häufige Verwendung um implizite Umwandlung vom Compiler zu überschreiben
\item \il{const_cast}: entfernt const
\item \il{dynamic_cast}: Dynamischer Typ
\item reinterpret\_cast: Interpretation des Operations-Inhalts als einen anderen Typen. Keine Typüberprüfung
\item Rechen-Beispiele mit impliziter Typ-Konvertierung
\end{itemize}
......@@ -67,9 +67,9 @@ unsigned long + long
\indeItem{Einige Print-Preprocessor-Makros}{
\begin{itemize}
\item \_\_LINE\_\_
\item \_\_FUNCTION\_\_
\item \_\_TIME\_\_
\item \_\_DATE\_\_
\item \il{__LINE__}
\item \il{__FUNCTION__}
\item \il{__TIME__}
\item \il{__DATE__}
\end{itemize}
}
\section{Lecture 3a}
\begin{itemize}
\item constexpr kann zur Compilezeit ausgewertet werden
\item \il{constexpr} kann zur Compilezeit ausgewertet werden
\item Floating Operationen, die zur Laufzeit ausgewertet werden müssen nicht die selben Ergebnisse liefern, wie jene zur Compilezeit, dh:\\
\end{itemize}
......@@ -14,7 +14,7 @@ sizeof(array)==size;// muss nicht wahr sein
\begin{figure}[h!]
\begin{lstlisting}[caption={Operator-Überladen mit constexpr},label=lst:overloaded_operators_with_constexpr]
\begin{lstlisting}[caption={Operator-Überladen mit \il{constexpr}},label=lst:overloaded_operators_with_constexpr]
struct A{
constexpr A(int i) : val(i){}
constexpr operator int() const {return val;}
......@@ -31,7 +31,7 @@ X<a> x; // verwendet int-operator für das template
\begin{figure}[h!]
\begin{lstlisting}[caption={Template-Metaprogramming mit constexpr},label=lst:template_metaprogramming_with_constexpr]
\begin{lstlisting}[caption={Template-Metaprogramming mit \il{constexpr}},label=lst:template_metaprogramming_with_constexpr]
constexpr int factorial(int n){return n <= 1 ? 1: (n*factorial(n-1));}
template<int n>
......
......@@ -39,7 +39,7 @@ int(&arrRef(void))[5]{
\begin{enumerate}
\item Exakte Übereinstimmung: Argument und Parameter-Typen sind identisch
\item Promotion
\item Standard conversions: z.B. double to int
\item Standard conversions: z.B. \il{double} to \il{int}
\item class type conversions
\end{enumerate}
\end{itemize}
......@@ -47,7 +47,7 @@ int(&arrRef(void))[5]{
\indeItem{Conversions-Dinge}{
\begin{itemize}
\item Arithmetische Operationen nehmen keine Typen kleiner als int an, dort erfolgt automatisch eine promotion zu int. Beispiel: \il{char c = 1; typeid(c+c);} ist in der Tat ein int.
\item Arithmetische Operationen nehmen keine Typen kleiner als \il{int} an, dort erfolgt automatisch eine promotion zu \il{int}. Beispiel: \il{char c = 1; typeid(c+c);} ist in der Tat ein \il{int}.
\item Bei Floating-point conversion, also keine promotion, ist der Typ nicht exakt darstellbar, sondern liegt zwischen zwei darstellbaren Werten ist die Rundung Implementierungssache (default das nähere der beiden)
\item Prinzipiell ist immer nur eine Conversion auf einmal erlaubt
\item \il{NULL/nullptr} kann in jeden beliebigen Pointer konvertiert werden (einschließlich cv - \il{const/volatile}), was in lediglich einer Conversion möglich ist.
......@@ -80,7 +80,7 @@ typedef int (*PF) (int*,int); PF ff(int);
\item return type kann weggelassen werden, wird automatisch vom zurückgegebenen Typ bestimmt
\item capture list ist häufig leer, eine Liste lokaler Variablen, die in der umgebenen Funktion definiert werden.\\
Die lokale Kopie folgt den gewohnten call-by-reference und call-by-value Semantiken.\\
Die lokale Kopie darf anscheinend nur dann verändert werden, wenn ``\il{mutable}'' angegeben ist - s. \cref{lst:compose_functions}
Die lokale Kopie darf anscheinend nur dann verändert werden, wenn \il{mutable} angegeben ist - s. \cref{lst:compose_functions}
\item auto bei Lambda Funktionen ist wohl ein wenig Magie, undefinierter Typ, der häufig das repräsentiert was man will
\end{itemize}
}
\section{Lecture 6}
\begin{itemize}
\item Prefix-Operator Type\& operator++(){}
\item Postfix-Operator Type operator++(int){}
\item der Int-Parameter wird benötigt um die beiden auseinander zu halten, kann allerdings nur beim expliziten .operator++() verwendet werden
\item Prefix-Operator \il{Type& operator++()\{\}}
\item Postfix-Operator \il{Type operator++(int)\{\}}
\item der Int-Parameter wird benötigt um die beiden auseinander zu halten, kann allerdings nur beim expliziten \il{.operator++()} verwendet werden
\item es können nicht mehrere implizite Class-type-conversions direkt aufeinander folgen
\end{itemize}
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment