Commit 39eb854b authored by me's avatar me
Browse files

clarified some statements

parent 9010ac2d
......@@ -4,7 +4,7 @@
\indeItem{virtual base class}{
\begin{itemize}
\item Eine Basis-Klasse, die mittels ``virtual'' vererbt wurde. Diese ist lediglich einmal in dem Unterklassen-Objekt enthalten, selbst bei häufigerem Vorkommen als virtual Base.
\item Eine Basis-Klasse, die mittels \il{virtual} vererbt wurde. Diese ist lediglich einmal in dem Unterklassen-Objekt enthalten, selbst bei häufigerem Vorkommen als virtual Base.
\item Bei nicht-virtual-Vererbung initialisiert der Konstruktor womöglich lediglich die direkte Basis-Klasse.
\item Die Initialisierung von virtuellen Basis-Klassen erfolgt durch die niedrigste Unterklasse, die entsprechende Initialisierungen explizit vornehmen muss.
\end{itemize}
......
......@@ -14,9 +14,9 @@
\begin{lstlisting}[caption={[Template Specialisation]Template Specialisation - Partial Specialisation ist nur bei Klassen erlaubt}, label=lst:template_specialisation]
template<typename T1, typename T2> void ff(){}
// anscheinend muss man hier tatsächlich alle explizit angeben
template <> void ff<int,int>(){}
template<> void ff<int,int>(){}
// und deswegen geht das hier auch nicht, da partial specialisation nicht erlaubt ist
template <typename T1> void ff<T1,int>(){}
template<typename T1> void ff<T1,int>(){}
// bei Klassen hingegen geht das
template<typename T1, typename T2> class Y{};
......@@ -27,8 +27,8 @@ template<typename T1> classY<T1, int>{};
\begin{figure}[h!]
\begin{lstlisting}[caption={Template Specialisation kann sehr tricky sein}, label=lst:template_specialisation_crazy_example]
template<typename T>void f3(T t){}
template <typename T> void f3(T*){}
template <> void f3<int*>(int* a){}
template<typename T> void f3(T*){}
template<> void f3<int*>(int* a){}
int* ip = new int[2];
// ruft T* auf, weil die Specialisation eine Spezialisierung der ERSTEN Funktion ist und beim Finden des "best match" betrachtet der Compiler die beiden Generic-Funktionen, wovon die T* den besseren Match liefert.
......@@ -40,9 +40,9 @@ f3(ip);
\begin{figure}[h!]
\begin{lstlisting}[caption={Template Function in template class}, label=lst:template_function_off_template_class]
template<typename T1, typename T2>class Y{
template<typename T1, typename T2> class Y{
public:
template<typename TT>void print(TT t);
template<typename TT> void print(TT t);
};
// zwei template-Listen, deren Reihenfolge egal ist
template<typename T1, typename T2>template<typename TT>
......@@ -53,19 +53,19 @@ void Y <T1, T2>::print(TT);
\hspace*{-1cm}\begin{minipage}{1.1\linewidth}
\begin{lstlisting}[caption={typename als Hilfe zur Konfliktauflösung}, label=lst:typename_solves_conflicts]
template<typename T1>class X{
template<typename T1> class X{
public:
// hier wüsste der Compiler nicht ob mem eine Member-Variable oder ein typedef ist. Dh. er weiss nicht ob das eine Multiplikation oder eine Referenz auf T::mem sein soll
// hier wüsste der Compiler nicht ob mem eine Member-Variable oder ein typedef ist. Dh. er weiß nicht ob das eine Multiplikation oder eine Referenz auf T::mem sein soll
// T::mem *p1;
// das hier sind die beiden Dinge, die für sich genommen funktionieren
// beiden diese Dinge funktionieren jeweils für sich genommen, aber nicht gemeinsam
static int const i = T::mem *p; // T::mem muss eine Variable sein
typename T::mem *p1; // T::mem muss ein type sein
};
\end{lstlisting}
\end{minipage}
\inde{Trailing return types \cref{lst:trailing_return_type}}{Zu Verwenden bei unbekanntem Return-Typen.}
\inde{Trailing return types \cref{lst:trailing_return_type}}{Zu Verwenden bei unbekanntem Rückgabe-Typen.}
\begin{figure}[h!]
\begin{lstlisting}[caption={[Trailing Return Type Beispiel]Trailing Return Type Beispiel\\Der Rückgabetyp steht hinter der Parameterliste}, label=lst:trailing_return_type]
template<typename It>
......@@ -73,7 +73,7 @@ auto fcn(It beg, It end)->decltype(*beg){return *beg;}
\end{lstlisting}
\end{figure}
\inde{Forwarding \textit{std::forward\textless Type\textgreater(arg)} \cref{lst:forwarding_example}}{Ein Argument unverändert an die nächste Funktion weiterreichen. Dh const, non-const, lvalue, rvalue, ... bleibt bestehen
\inde{Forwarding \il{std::forward<Type>(arg)} \cref{lst:forwarding_example}}{Ein Argument unverändert an die nächste Funktion weiterreichen. D.h. const, non-const, lvalue, rvalue, ... bleibt bestehen
}
\begin{figure}[h!]
\begin{lstlisting}[caption={Forwarding Beispiel}, label=lst:forwarding_example]
......@@ -91,7 +91,7 @@ void flip(F f, T1 &&t1, T2 &&t2){
\begin{figure}[h!]
\begin{lstlisting}[caption={Variadic Template-Funktion. Erlaubt auch ziemlich coole Rekursionen}, label=lst:variadic_template_function]
template<typename T,typename ... Args>
void f(const T & t, const Args & rest);
void f(const T &t, const Args &rest);
template<typename T>
ostream &print(ostream &os, const T &t){
......
......@@ -3,14 +3,14 @@
\item IO-Objekte können nicht assigned werden
\item condition state. Flag der Stream-Klassen, das angibt, ob der Stream korrumpiert ist oder valide
\begin{itemize}
\item fail: initialisation-fail, format-Error, Beispiel String to int, ermöglicht weitere Lese-Versuche mit anderen Parametern
\item fail: initialisation-fail, format-Error, Beispiel \il{string} to \il{int}, ermöglicht weitere Lese-Versuche mit anderen Parametern
\item bad: Böse Dinge sind passiert, Verwendung des Streams nicht mehr möglich
\item strm::iostate, strm::badbit, strm::failbit, strm::eofbit
\item s.good(), s.bad(), s.fail(), s.eof()
\item s.clear(), s.setstate(flag), s.rdstate()
\item \il{strm::iostate, strm::badbit, strm::failbit, strm::eofbit}
\item \il{s.good(), s.bad(), s.fail(), s.eof()}
\item \il{s.clear(), s.setstate(flag), s.rdstate()}
\end{itemize}
\item stringstream scheint recht nützlich zu sein
\item Wenn ein Output-Stream an ein Input-Stream gebunden (stream.tie(\&stream2)) wird, dann wird dieser immer dann geflusht, wenn vom Input-Stream gelesen wird
\item \il{stringstream} scheint recht nützlich zu sein
\item Wenn ein Output-Stream an ein Input-Stream gebunden (\il{stream.tie(\&stream2)}) wird, dann wird dieser immer dann geflusht, wenn vom Input-Stream gelesen wird
\item Beim Program-Crash wird nicht geflusht
\item Deque (Double-ended queue) scheint wohl schneller zu sein, kann schnell vorne und hinten anfügen.\\
Es erfolgt beim Einfügen/Löschen keine Verschiebung von Elementen
......
......@@ -2,7 +2,7 @@
\begin{itemize}
\item Im Header stehende Template-Funktionen, wobei die Header in mehrere Source-Files includiert werden, werden unter Umständen mehrfach compiliert, nur um später weggeworfen zu werden.\\
Dies lässt sich vermeiden, indem die entsprechende Funktion mittels extern und template-Angaben in allen bis auf einer Datei bekannt gemacht wird.
\item Type traits (Type-Checking is\_\textless type\textgreater, z.B. is\_pointer) läuft zur Compile-Zeit durch
\item Type traits (Type-Checking \il{is_<type>}, z.B. \il{is_pointer}) läuft zur Compile-Zeit durch
\item Man kann Class-Templates auch via verschachtelte-Class-Templates in die Class-Definition einer verwendenden Klasse angeben (vgl. \cref{lst:multiple_class_template})
\item Nette Fibonacci-Template-Metaprogramming (vgl. \cref{lst:template_meta_programming_loop_class})
\end{itemize}
......@@ -29,13 +29,13 @@ public:
static void run(Container &v){
// value sind die Fibonacci-Zahlen, diese werden woanders berechnet (s.u.)
v.push_back(T<beg>::value);
Loop<beg+1,end,T>::run(v);
Loop<beg+1, end, T>::run(v);
}
};
// template specialisation, Abbruchbedingung
template<unsigned long end, template<unsigned long>class T>
class Loop<end,end, T>{
class Loop<end, end, T>{
public:
template<typename Container>
static void run(Container &v){}
......
......@@ -12,7 +12,7 @@ words.erase(endunique, words.end());
\begin{figure}[h!]
\begin{lstlisting}[caption={Parameter an eine Funktion mappen, Parameter sind call by value, sofern nicht using ref(arg) oder cref(arg) (für const ref) verwendet wird}, label=lst:bind]
// syntax: auto newCallable = bind(callable,arg_list)
// syntax: auto newCallable = bind(callable, arg_list)
#include <functional> // std::ref
using namespace std::placeholders; // _1
......@@ -21,7 +21,7 @@ vector<string>words;
while(cin >> s)
words.push_back(s);
for_each(words.begin(),words.end(),
bind(print,ref(cout),_1, ' '));
bind(print, ref(cout), _1, ' '));
// for_each funktioniert auch mit lambda-Funktionen (s.u. Algorithmen-Syntax)
for_each(words.begin(),words.end(),
......@@ -151,7 +151,7 @@ unordered\_map, unordered\_set, unordered\_multimap, unordered\_multiset
\end{itemize}
\begin{figure}[h!]
\begin{lstlisting}[caption={Container Dinge}, label=lst:container_stuff]
\begin{lstlisting}[caption={Container-Dinge \il{first, second}}, label=lst:container_stuff]
// count the number of times each word occurs in the input
// map from string to size_t
map<string, size_t> word_count;
......
......@@ -2,20 +2,20 @@
\begin{itemize}
\item Protected Vererbung: Kein Zugriff von friends der abgeleiteten Klasse
\item Default Vererbung bei Structs ist public, bei Klassen hingegen ist es private (relevant dabei ist der Typ des erbenden Kindes)
\item pure-virtual-function: \il{virtual <type> <func>() = 0;} sorgt für abstrakte Klasse
\item pure-virtual-function: \il{virtual <type> <func>() = 0;} implizieren, dass die Klasse abstrakt ist
\item Wenn Funktionen nicht virtual sind, dann wird der statische Klassen-Typ verwendet:\\
\il{Base b* = new Derived d;}\\
\il{b->func();}\\
ruft func() der Base auf, wenn diese non-virtual ist\\
ruft \il{func()} der Base auf, wenn diese non-virtual ist\\
virtual Funktionen sind auch in sämtlichen Unterklassen implizit virtual
\item Destructors von abstrakten Klassen sollten stets virtual sein. Dies ist nicht zwingend notwendig, wenn die Klasse pure-abstract ist, weil dann überhaupt keine Objekte erzeugt werden können.
\item \il{class Class final\{\};}\\
Verhindert Vererbung von Class
\item \il{using Base::Base;}\\
sorgt dafür, dass für jeden Konstruktor der Base-Klasse ein Konstruktor in der Derived Klasse mit der selben Parameterliste angelegt wird, der die Parameter an die entsprechenden Konstruktoren der Base-Klass weiterreicht.
sorgt dafür, dass für jeden Konstruktor der Basis-Klasse ein Konstruktor in der Derived Klasse mit der selben Parameterliste angelegt wird, der die Parameter an die entsprechenden Konstruktoren der Basis-Klasse weiterreicht.
\item In Assignment-Copy-Operatoren der Unterklasse muss auch entsprechender Code für die Oberklasse enthalten sein
\item dynamic\_cast castet vom Base-Type zu einem Derived-Type. Erfordert anscheinend, dass die Base-Klasse abstract ist
\item typeid, type\_info nützliche Dinge
\item \il{dynamic_cast} castet vom Basis-Typen zu einem Derived-Typen. Erfordert anscheinend, dass die Basis-Klasse abstract ist
\item \il{typeid, type_info} nützliche Dinge
\end{itemize}
......@@ -37,16 +37,13 @@ void main() {
\begin{figure}[h!]
\begin{lstlisting}[caption={statische Funktionen mit den selben Parametern wie non-static können nicht überschrieben werden},label=example_static_functions]
\begin{lstlisting}[caption={statische Funktionen mit den selben Parametern wie non-static können nicht überladen werden},label=example_static_functions]
struct A {
using std::cout; using std::endl;
// error: static function can't be overloaded
void print(int a, char b = '0')
{ cout << "int" << endl; }
void print(float a, char b)
{ cout << "float" << endl; }
static void print(double a)
{ cout << "static double" << endl; }
static void print(int a, char b = '0')
{ cout << "static int" << endl; }
};
......
......@@ -94,7 +94,7 @@
% ....
%\addtokomafont{pageheadfoot}{\upshape}
\newcommand{\mytitle}{Advanced Programming Techniques\\Zusammenfassung des Wichtigsten}
\newcommand{\mytitle}{Advanced Programming Techniques\\Zusammenfassung des Wichtigsten\\\href{https://gitlab.cs.fau.de/by92gyfi/advPT}{Quellcode}}
\newcommand{\semester}{Wintersemester 2015/16}
\newcommand{\dozent}{Dr. Harald Köstler}
......
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