part1.tex

\documentclass[aspectratio=169]{beamer}

\usepackage[utf8]{inputenc}
\usepackage{soul}
\usepackage{pdfpcnotes}
\usepackage{listings}
\usepackage{tikz}
\usepackage{booktabs}
\usepackage{minted}
\usepackage[ngerman]{babel}

\usetheme{Hannover}
\usecolortheme{dove}

\AtBeginSection[]{
  \begin{frame}
  \vfill
  \centering
  \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
    \usebeamerfont{title}\insertsectionhead\par%
  \end{beamercolorbox}
  \vfill
  \end{frame}
}

\lstset{language=C++,
                basicstyle=\ttfamily,
                keywordstyle=\color{blue}\ttfamily,
                stringstyle=\color{red}\ttfamily,
                commentstyle=\color{purple}\ttfamily,
                morecomment=[l][\color{magenta}]{\#}
}


\title{Eine Einführung in modernes C++}
\subtitle{Teil 1 -- Basics}
\author{Paul Nykiel}
\date{\today}

\begin{document}
\maketitle

\frame{
    \pnote{Sofort Fragen!}
    \pnote{Feedback erwünscht}
    \tableofcontents
}

\section{C}
\begin{frame}
    \frametitle{Was ist C}
    \begin{itemize}
        \item ANSI/ISO Standardisierte Programmiersprache
            \pause
        \item Entwickelt ab 1969 für Unix
            \pause
        \item \glqq{}Portabler Assembler\grqq{}
            \pause
        \item Einfach zu verstehen, schwierig zu verwenden
    \end{itemize} 
\end{frame}

\begin{frame}
    \frametitle{C im Vergleich zu Java}
    \begin{itemize}
        \item Undefiniertes Verhalten 
            \pnote{Null-Pointer, fehlendes Return, division durch Null. Kann nicht vom Compiler kontrolliert werden und zur Runtime gibt es keine passnden Mechanismen  z.B. Microcontroller. Aber quasi jede Sprache hat undefiniertes Verhalten bezeichnet es aber nicht so (z.B. Race-Conditions)}
            \pause
        \item Keine automatische Speicherverwaltung 
            \pnote{Keine Aufgabe der Sprache, wenn benötigt liefert die STL passende Container. Bei Microcontroller oder Echtzeitanwendungen nicht gewünscht.
            Unterscheidung Heap und Stack hervorheben.}
            \pause
        \item Kleiner Sprachkern und kleine Standardlibrary 
            \pnote{36 Schlüsselwörter, C\# z.B. 86. Keine UI, kein Networking...}
    \end{itemize}
\end{frame}

\section{Ein erstes C Programm}

\begin{frame}
    \Huge{Beispiel: Hello World}
    \pnote{Hello World. Erklärung: include, keine main-Klasse, Vergleich Code-Länge mit Java}
\end{frame}

\section{Buildprozess}
\begin{frame}
    \frametitle{Vom Sourcecode zur ausführbaren Datei}
    \begin{columns}
        \begin{column}{.5\textwidth}
            \begin{itemize}
                \item<+-> Präprozessor 
                    \pnote{Erklärung include und define an Hello World Bsp (gcc -E), einfache Textersetzung, Erklärung an Tafel}
                \item<+-> Compiler 
                    \pnote{Übersetzten von der Übersetzungseinheit in Assemblercode, Übersetzungseinheit definieren}
                \item<+-> Linker 
                    \pnote{Baut Programm zusammen und sucht Funktionen in anderen Übersetzungseinheiten}
                \item<+-> \lstinline{\#include}s sichern Typkonsistenz
                    \pnote{Unterschied Definition und Deklaration, Doku im Header gut für Übersicht}
            \end{itemize}
        \end{column}
        \begin{column}{.5\textwidth}
            \begin{figure}
                \includegraphics[width=\textwidth]{build.pdf}
            \end{figure}
        \end{column}
    \end{columns}
\end{frame}

\begin{frame}
    \Huge{Beispiel: Eine zweite Übersetzungseinheit}
    \pnote{Zweites C File, zuerst kein Header, alles einfach in gcc schmeißen, Message als char\[\]}
    \pnote{Zweites C File, separater Header, erläutern das nicht alles in den Header}
    \pnote{Gegenbeweise: alles in Header, noch weitere Übersetzungseinheit, Linker Fehler}
    \pnote{Wieso nicht alles als Header? Buildzeit}
\end{frame}

\begin{frame}
    \frametitle{Warum ein Buildsystem}
    \begin{itemize}
        \item Nur geänderte Dateien neu kompilieren 
            \pnote{erkennt welche Files geändert wurde, größere Projekte kompilieren sonst jedes mal mehrere Minuten bis Stunden (unser Code schon circa 2 Minuten)}
            \pause
        \item Einzelner Befehl an Compiler wird zu kompliziert
            \pnote{Vor allem bei vielen Flags und vielen Dateien}
            \pause
        \item Portabilität
            \pnote{Compiler und Flags werden unnabhängig vom OS und von installierten Compilern angegeben}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{CMake}
    Wird durch Datei \lstinline{CMakeLists.txt} konfiguriert:
    \inputminted{cmake}{examples/slides/CMakeLists.txt}
\end{frame}

\begin{frame}
    \Huge{Beispiel: CMake}
    \pnote{Einfaches CMake File dazu bauen, nochmal kompilieren, Lib ändern zeigen dass main nicht neu gebaut wird}
\end{frame}

\section{Speicher}
\begin{frame}
    \frametitle{Stack und Heap}
    \begin{columns}
        \begin{column}{.5\textwidth}
            \begin{itemize}
                \item<+-> Hauptspeicher (RAM) wird aus zwei Richtungen vergeben
                    \pnote{Aufteilung in Stack für Performance und Heap für dynamischen Speicher}
                \item<+-> Stack wird für Funktion aufgebaut
                    \pnote{Schnell da LIFO, wird automatisch wieder abgebaut}
                \item<+-> Heap für dynamischen Speicher
                    \pnote{Langsam, freier Speicher muss erst gefunden werden}
                \item<+-> Speicher auf dem Heap muss händisch reserviert und freigegeben werden
                    \pnote{Memory Leak wenn nicht wieder freigegeben}
                \item<+-> Bei mehr als einem Owner Verwaltung kompliziert
                    \pnote{Owner: Funktion die Pointer kennt}
            \end{itemize}
        \end{column}
        \begin{column}{.5\textwidth}
            \begin{figure}[H]
                \centering
                \begin{tikzpicture}
                    \draw [draw] (0,0) rectangle (3,5);
                    \filldraw [draw=black,fill=gray!20] (0,0) rectangle (3,1) node[pos=.5] {Stack};
                    \filldraw [draw=black,fill=gray!20] (0,4.5) rectangle (3,5) node[pos=.5] {Heap};
                    \filldraw [draw=black,fill=gray!20] (0,3.5) rectangle (3,4) node[pos=.5] {Heap};
                    \draw [->] (1.5,1) -- (1.5,2);
                \end{tikzpicture}
            \end{figure}
        \end{column}
    \end{columns}
\end{frame}

\begin{frame}
    \frametitle{Stack}
    \begin{columns}
        \begin{column}{.5\textwidth}
            \lstinputlisting{examples/slides/stack.c}
        \end{column}
        \begin{column}{.5\textwidth}
            \begin{figure}[H]
                \centering
                \only<1> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                    \end{tikzpicture}
                    \pnote{Anfang: Stack Leer (Hinweis: Stack = Stappel)}
                }
                \only<2,6> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,0) rectangle (3,1) node[pos=.5] {\lstinline{int a}};
                        \filldraw [draw=black,fill=gray!20] (0,1) rectangle (3,2) node[pos=.5] {\lstinline{int b}};
                    \end{tikzpicture}
                    \pnote{Lokale Variablen für Funktion werden der Reihe nach auf Stack gelegt}
                    \pnote{Nach beenden der Funktion werden Variablen wieder vom Stack genommen}
                }
                \only<3> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,0) rectangle (3,1) node[pos=.5] {\lstinline{int a}};
                        \filldraw [draw=black,fill=gray!20] (0,1) rectangle (3,2) node[pos=.5] {\lstinline{int b}};
                        \filldraw [draw=black,fill=gray!20] (0,2) rectangle (3,3) node[pos=.5] {Verwaltungsinfo};
                    \end{tikzpicture}
                    \pnote{Für jeden Funktionsaufruf wird ein "Stackframe" angelegt}
                }
                \only<4> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,0) rectangle (3,1) node[pos=.5] {\lstinline{int a}};
                        \filldraw [draw=black,fill=gray!20] (0,1) rectangle (3,2) node[pos=.5] {\lstinline{int b}};
                        \filldraw [draw=black,fill=gray!20] (0,2) rectangle (3,3) node[pos=.5] {Verwaltungsinfo};
                        \filldraw [draw=black,fill=gray!20] (0,3) rectangle (3,4) node[pos=.5] {\lstinline{int arg}};
                    \end{tikzpicture}
                    \pnote{Für jeden Funktionsaufruf wird ein "Stackframe" angelegt}
                }
                \only<5> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,0) rectangle (3,1) node[pos=.5] {\lstinline{int a}};
                        \filldraw [draw=black,fill=gray!20] (0,1) rectangle (3,2) node[pos=.5] {\lstinline{int b}};
                        \filldraw [draw=black,fill=gray!20] (0,2) rectangle (3,3) node[pos=.5] {Verwaltungsinfo};
                        \filldraw [draw=black,fill=gray!20] (0,3) rectangle (3,4) node[pos=.5] {\lstinline{int arg}};
                        \filldraw [draw=black,fill=gray!20] (0,4) rectangle (3,5) node[pos=.5] {\lstinline{int res}};
                    \end{tikzpicture}
                    \pnote{Für jeden Funktionsaufruf wird ein "Stackframe" angelegt}
                }
            \end{figure}
        \end{column}
    \end{columns}
\end{frame}

\begin{frame}
    \Huge{Reicht das nicht?}
    \pnote{Limitierung: wenn Speicher länger als Funktion bestehen soll und z.t. wenn dynamisch Speicher gebraucht wird}
\end{frame}

\begin{frame}
    \frametitle{Heap}
    \begin{columns}
        \begin{column}{.5\textwidth}
            \lstinputlisting{examples/slides/heap.cpp}
            \pnote{Unterscheidung zu Java: new erfordert MANUELLE speicherverwaltung}
        \end{column}
        \begin{column}{.5\textwidth}
            \begin{figure}[H]
                \centering
                \only<1> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,5) rectangle (3,4) node[pos=.5] {In Verwendung};
                    \end{tikzpicture}
                    \pnote{Heap wird nicht der Reihe nach belegt, einzelne Teile können schon belegt sein (z.b. von ld)}
                }
                \only<2> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,5) rectangle (3,4) node[pos=.5] {In Verwendung};
                        \filldraw [draw=black,fill=gray!20] (0,4) rectangle (3,2) node[pos=.5] {\lstinline{a}};
                    \end{tikzpicture}
                    \pnote{new fragt nach neuem Speicher: wie hier sichtbar muss der explizit gesucht werden}
                }
                \only<3> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,5) rectangle (3,4) node[pos=.5] {In Verwendung};
                        \filldraw [draw=black,fill=gray!20] (0,4) rectangle (3,2) node[pos=.5] {\lstinline{a}};
                        \filldraw [draw=black,fill=gray!20] (0,2) rectangle (3,0) node[pos=.5] {\lstinline{b}};
                    \end{tikzpicture}
                    \pnote{new nicht wie Java}
                }
                \only<4> {
                    \begin{tikzpicture}
                        \draw [draw] (0,0) rectangle (3,6);
                        \filldraw [draw=black,fill=gray!20] (0,5) rectangle (3,4) node[pos=.5] {In Verwendung};
                        \filldraw [draw=black,fill=gray!20] (0,2) rectangle (3,0) node[pos=.5] {\lstinline{b}};
                    \end{tikzpicture}
                    \pnote{mit delete muss speicher explizit freigegeben, sonst Leak, siehe b}
                }
                
            \end{figure}
        \end{column}
    \end{columns}
\end{frame}

\section{Pointer}
\begin{frame}
    \frametitle{Pointer}
    \begin{itemize}
        \item Pointer 
            \pause
        \item Angst!
            \pause
        \item Gefährlich!
            \pause
        \item Böse!
            \pause
        \item Nicht schlimm aber viel Fehlerpotential
            \pnote{Leaks, Owner nicht definiert, vor allem bei Librarys relevant}
            \pause
        \item Was ist ein Pointer: eigentlich nur ein \lstinline{int} den der Compiler separat behandelt.
            \pnote{int repräsentiert die Adresse der variable}
            \pause
        \item \lstinline{int b = 17; int *a = &b;}
            \pnote{Pointer als Referenz, Pointer zeigt auf Stack, dereferenzierung und address of}
            \pause
        \item \lstinline{int *c = new int();}
            \pnote{Pointer als Owner, Hier gleich ein potentieller Leak}
            \pause
        \item \lstinline{delete c;}
            \pnote{Immer mit delete, das will doch wirklich keiner}
            \pause
        \item Speicherverwaltung gehört nicht in die Anwendungslogik
            \pnote{Permanente Fehlerquelle, Zeitverschwendung, Ab jetzt als Raw-Pointer bezeichnet und nie wieder verwenden!}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Beispiel Pointer}
    \lstinputlisting{examples/slides/pointer.cpp}
    \pnote{Auf Stack: Kein Owner}
    \pnote{Auf Heap: Owner}
\end{frame}

\section{C++}
\begin{frame}
    \frametitle{Was ist C++}
    \pnote{Kurz Hintergrund für Einordnung}
    \begin{itemize}
        \item \st{C with classes}
            \pnote{Ursprünglicher Name, da initial nur Erweiterung von C um Objektorientung}
            \pause
        \item Wird in quasi jeder Domäne genutzt
            \pnote{Embedded, Betriebssysteme, Systemnahe Entwicklung, Signalverarbeitung (Codierung), Desktop-Anwendungen, Spiele, Server-Anwendungen, HPC...}
            \pause
        \item Ziele: Performanter und sicherer Code
            \pnote{Sicheres Typensystem, checks zur Compile Time (unterschied zur Run Timer hervorheben), maschinennah}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{C++ im Vergleich zu Java}
    \begin{itemize}
        \item Templates 
            \pnote{Nicht generics, viel mächtiger, z.B. Boost MSM, sichere Pointer (Guideline support library), Turing-vollständig}
            \pause
        \item Operatorenüberladung
            \pnote{Bsp. Vektor, Iteratoren...}
            \pause
        \item Tendentiell weniger tiefe Vererbung
            \pnote{Z.b. Container und Iteratoren, keine Überklasse aber Eigenschaften (forward-Iterator), dadurch weniger Boilerplate}
            \pause
        \item Mehrfachvererbung
            \pnote{Dadurch keine Interfaces notwendig, aber selten genutzt}
            \pause
        \item Definierte Objektlebenszeit
            \pnote{Konstruktor, Destruktor, Scope}
    \end{itemize}
\end{frame}

\section{Ein erstes C++ Programm}

\begin{frame}
    \Huge{Beispiel: Hello World}
    \pnote{Hello World. Erklärung: include, keine main-Klasse, namespaces, Operatorenüberladung, Vergleich Code-Länge mit Java}
\end{frame}

\section{Zero-Copy}

\begin{frame}
    \frametitle{Speicherverwaltung}
    \begin{itemize}
        \item \lstinputlisting{examples/slides/copy.cpp}
            \pnote{f ist Funktion list->list und b ist list. Was passiert hier, wie viele Objekte existieren, wie viel Speicher wird genutzt, wie oft wird kopiert}
            \pause
        \item Jegliche Zuweisung ist eine Kopie, auch für Funktionsargumente
            \pnote{Funktionsargumente, Zuweisung.... Explizit große Container erwähnen}
            \pause
        \item Einfach verständlich
            \pnote{Vgl. komisches Java Verhalten. Trivial ein Objekt zu kopieren, deep copy in Java und C\# schwierig (Internet: selber implementieren oder serializieren und deserializieren)}
            \pause
        \item Für große Objekte unnötige Performanceeinbuße
            \pnote{Spricht gegen das was ich in Einleitung gesagt habe, Performance in C++ wichtig}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Smart-Pointer}
    \begin{itemize}
        \item Standardlibrary kann Verwaltung übernehmen
            \pnote{Erwähnung Operatorenüberladung und Lifetime}
            \pause
        \item \lstinline{unique\_ptr}
            \pnote{Quasi Drop-In-Replacement für Raw-Ptr, machen selber den Speicher am Ende der Lebenszeit frei}
            \pause
        \item Genau ein Owner
            \pnote{Explizit verboten zu kopieren (=delete), Bsp. kopieren in Klasse, jetzt uneindeutiger Owner. Oftmals für Factory Methoden, kein Overhead zu Raw-Pointer}
            \pause
        \item
            \lstinline{std::unique\_ptr<int> a = std::make\_unique<int>(17);}
            \pause
        \item \lstinline{shared\_ptr}
            \pnote{Zusätzlich Zählen von Instanzen (siehe Copy-Constructor)}
            \pause
        \item Quasi immer nutzbar
            \pnote{Dafür kopieren... minimal langsamer (nicht bei Zugriff)}
            \pause
        \item
            \lstinline{std::shared\_ptr<int> a = std::make\_shared<int>(17);}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Referenzen}
    \begin{itemize}
        \item Sprachfeature kein Library-Feature
            \pnote{Werden vom Compiler zu Pointern gemacht, nie Owner. Hier betrachtet L-Value-Referenzen}
            \pause
        \item Können nicht null sein
            \pnote{Zeigen immer auf anderes Objekt, eine Art Alias}
            \pause
        \item Können aber ungültig werden
            \pnote{z.B. lokale Variablen}
            \pause
        \item
            \lstinline{int b = 17; int &a = b;}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Zusammenfassung Pointer}
    \begin{itemize}
        \item Raw-Pointer: Sollten quasi nie verwendet werden
            \pnote{Ausser pre C++11 und mit C APIs}
            \pause
        \item Unique-Pointer: Oftmals Ersatz für Raw-Pointer
            \pnote{Limitierung: Ein Owner kein Overhead}
            \pause
        \item Shared-Pointer: Sichere Pointer für beliebig viele Owner
            \pnote{Am Ähnlichsten zu Java, aber etwas Overhead (immer noch weniger als Java und definierte Lifetime)}
            \pause
        \item Referenzen: Oftmals um Kopien zu vermeiden
            \pnote{Sprachfeature}
    \end{itemize}
\end{frame}

\begin{frame}
    \Huge{Beispiel: Pointer \& Referenzen}
    \pnote{Wo Pointer/Ref einbauen? Frage welche Sorte Pointer. HelloWorld Lib Ergänzen mit Referenzen, jetzt in CLion}
\end{frame}

\end{document}