diff --git a/20200109/hp-2019ws-p4.tex b/20200109/hp-2019ws-p4.tex
index 3f4a14e0d8fc82d0b78e65837211f62cbf8f41b6..0091478169680e3c97a7d149a80ef7064f6ae9ab 100644
--- a/20200109/hp-2019ws-p4.tex
+++ b/20200109/hp-2019ws-p4.tex
@@ -20,7 +20,7 @@
 % Attribution-ShareAlike 3.0 Unported License along with this
 % document.  If not, see <http://creativecommons.org/licenses/>.
 
-% README: Versuch 16. und 23.1.2020: Objektorientiertes Grafik-Programm
+% README: Versuch 4, 16. und 23.1.2020: Objektorientiertes Grafik-Programm
 
 \documentclass[a4paper]{article}
 
diff --git a/20200116/Tower_of_Hanoi.jpeg b/20200116/Tower_of_Hanoi.jpeg
new file mode 120000
index 0000000000000000000000000000000000000000..a1a794afda08596ffa2f46f278db53455de25b6c
--- /dev/null
+++ b/20200116/Tower_of_Hanoi.jpeg
@@ -0,0 +1 @@
+../common/Tower_of_Hanoi.jpeg
\ No newline at end of file
diff --git a/20200116/dynmem-1.c b/20200116/dynmem-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..56148108873fc8dae9bdb7f8b555a4172883c6ad
--- /dev/null
+++ b/20200116/dynmem-1.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+  for (int i = 0; i < 3; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  return 0;
+}
diff --git a/20200116/dynmem-2.c b/20200116/dynmem-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..f78a21ec7a8285f4c3fc41e3b549dd333e11c22e
--- /dev/null
+++ b/20200116/dynmem-2.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+
+  char **new_name = malloc (4 * sizeof (char*));
+  for (int i = 0; i < 3; i++)
+    new_name[i] = name[i];
+  name = new_name;   /* Speicherleck: Array wurde nicht freigegeben! */
+
+  name[3] = "Dieter";
+
+  for (int i = 0; i < 4; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  return 0;
+}
diff --git a/20200116/dynmem-3.c b/20200116/dynmem-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..0db6dd4f7f67d8d4db8ce8264a0ba533082da721
--- /dev/null
+++ b/20200116/dynmem-3.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+
+  char **new_name = malloc (4 * sizeof (char*));
+  for (int i = 0; i < 3; i++)
+    new_name[i] = name[i];
+  free (name);
+  name = new_name;   /* kein Speicherleck: Array wurde freigegeben. */
+
+  name[3] = "Dieter";
+
+  for (int i = 0; i < 4; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  return 0;
+}
diff --git a/20200116/dynmem-4.c b/20200116/dynmem-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..d1ebf99fd76b60aa3bcf97ebc2eb7b76c1a583a9
--- /dev/null
+++ b/20200116/dynmem-4.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+
+  char **new_name = malloc (4 * sizeof (char*));
+  for (int i = 0; i < 3; i++)
+    new_name[i] = name[i];
+  free (name);
+  name = new_name;
+
+  name[3] = "Dieter";
+
+  for (int i = 0; i < 4; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  free (new_name);   /* Fehler: Array wurde bereits freigegeben! */
+  return 0;
+}
diff --git a/20200116/dynmem-5.c b/20200116/dynmem-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..c8a5807d1172df17419fa05efffcb643b8e75ba7
--- /dev/null
+++ b/20200116/dynmem-5.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+
+  char **new_name = malloc (4 * sizeof (char*));
+  for (int i = 0; i < 3; i++)
+    new_name[i] = name[i];
+  free (name);
+  name = new_name;
+  new_name = NULL;   /* Zeiger wird nicht mehr gebraucht. */
+
+  name[3] = "Dieter";
+
+  for (int i = 0; i < 4; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  return 0;
+}
diff --git a/20200116/dynmem-6.c b/20200116/dynmem-6.c
new file mode 100644
index 0000000000000000000000000000000000000000..b80cd7fa18551d2046a2aa77e7f4d1bc74157f0b
--- /dev/null
+++ b/20200116/dynmem-6.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+  name = realloc (name, 4 * sizeof (char));
+  name[3] = "Dieter";        /* Fehler: ^ "*" vergessen; zu wenig Speicher */
+  for (int i = 0; i < 4; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  return 0;
+}
diff --git a/20200116/dynmem-7.c b/20200116/dynmem-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..414a24a14321085196c5c2887f3c7d90e7c81e01
--- /dev/null
+++ b/20200116/dynmem-7.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  char **name = malloc (3 * sizeof (char *));
+  name[0] = "Anton";
+  name[1] = "Berthold";
+  name[2] = "Caesar";
+  name = realloc (name, 4 * sizeof (char *));
+  name[3] = "Dieter";
+  for (int i = 0; i < 4; i++)
+    printf ("%s\n", name[i]);
+  free (name);
+  return 0;
+}
diff --git a/20200116/hello-gtk.png b/20200116/hello-gtk.png
new file mode 120000
index 0000000000000000000000000000000000000000..cca99209d86683a9a3b0f70bbc149780bae10ba6
--- /dev/null
+++ b/20200116/hello-gtk.png
@@ -0,0 +1 @@
+../common/hello-gtk.png
\ No newline at end of file
diff --git a/20200116/hp-20200116.pdf b/20200116/hp-20200116.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..da6d761d3af2e5e06b73867c862801c0a85d22d6
Binary files /dev/null and b/20200116/hp-20200116.pdf differ
diff --git a/20200116/hp-20200116.tex b/20200116/hp-20200116.tex
new file mode 100644
index 0000000000000000000000000000000000000000..b0ec7c7d5a3c3b87d8e0b69ef63561ced0896274
--- /dev/null
+++ b/20200116/hp-20200116.tex
@@ -0,0 +1,935 @@
+% hp-20200116.pdf - Lecture Slides on Low-Level Programming
+% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: objektorientierte Programmierung, dynamische Speicherverwaltung
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{tikz}
+\usepackage{rotating}
+
+\usefonttheme[onlymath]{serif}
+
+\definecolor{medcyan}{rgb}{0.0,0.5,0.7}
+
+\title{Hardwarenahe Programmierung}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{16.\ Januar 2020}
+
+\begin{document}
+
+\maketitleframe
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+      \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
+    \item[\textbf{2}] \textbf{Einführung in C}
+    \item[\textbf{3}] \textbf{Bibliotheken}
+    \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+    \item[\textbf{5}] \textbf{Algorithmen}
+      \begin{itemize}
+        \item[5.1] Differentialgleichungen
+        \color{medcyan}
+        \item[5.\hbox to 0.56em{\boldmath$\frac{1+i}{\sqrt2}$}]\hspace*{0.90em}Quantencomputer
+        \vspace*{1pt}
+        \color{medgreen}
+        \item[5.2] Rekursion
+        \item[5.3] Aufwandsabschätzungen
+      \end{itemize}
+    \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+      \begin{itemize}
+        \color{red}
+        \item[6.0] Dynamische Speicherverwaltung
+        \color{medgreen}
+        \item[6.1] Konzepte und Ziele
+        \item[6.2] Beispiel: Zahlen und Buchstaben
+        \color{red}
+        \item[6.3] Unions
+        \item[6.4] Virtuelle Methoden
+        \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
+        \item[6.6] Ausblick: C++
+      \end{itemize}
+    \item[\textbf{7}] \textbf{Datenstrukturen}
+  \end{itemize}
+
+\end{frame}
+
+\setcounter{section}{4}
+\section{Algorithmen}
+\setcounter{subsection}{1}
+\subsection{Rekursion}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Vollständige Induktion:
+  \vspace*{-0.725cm}
+  \begin{displaymath}
+    \hspace*{4cm}
+    \left.
+      \begin{array}{r}
+        \mbox{Aussage gilt für $n = 1$}\\[2pt]
+        \mbox{Schluß von $n - 1$ auf $n$}
+      \end{array}
+    \right\}
+    \mbox{Aussage gilt für alle $n\in\mathbb{N}$}
+  \end{displaymath}
+  \vspace*{-0.5cm}
+
+  \pause
+
+  Türme von Hanoi
+
+  \begin{onlyenv}<2>
+    \begin{center}
+      \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg}
+    \end{center}
+  \end{onlyenv}
+
+  \begin{onlyenv}<3->
+    \begin{itemize}
+      \item
+        64 Scheiben, 3 Plätze,
+        \only<3-4>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\
+        immer 1 Scheibe verschieben
+      \item
+        Ziel: Turm verschieben
+      \item
+        Es dürfen nur kleinere Scheiben\\
+        auf größeren liegen.
+      \bigskip
+      \pause
+      \pause
+      \item
+        $n = 1$ Scheibe: fertig
+      \item
+        Wenn $n - 1$ Scheiben verschiebbar:\\
+        schiebe $n - 1$ Scheiben auf Hilfsplatz,\\
+        verschiebe die darunterliegende,\\
+        hole $n - 1$ Scheiben von Hilfsplatz
+    \end{itemize}
+    \begin{onlyenv}<5>
+      \vspace{-4.3cm}
+      \begin{lstlisting}[gobble=8,xleftmargin=6.4cm]
+        void move (int from, int to, int disks)
+        {
+          if (disks == 1)
+            move_one_disk (from, to);
+          else
+            {
+              int help = 0 + 1 + 2 - from - to;
+              move (from, help, disks - 1);
+              move (from, to, 1);
+              move (help, to, disks - 1);
+            }
+        }
+      \end{lstlisting}
+    \end{onlyenv}
+    \begin{onlyenv}<6->
+      \vspace{-5.0cm}
+      \hspace*{7.4cm}\begin{minipage}[t]{5cm}
+        32 Scheiben:
+        \begin{lstlisting}[gobble=10,style=terminal]
+          $ ¡time ./hanoi-9a¿
+          ...
+          real    0m32,712s
+          user    0m32,708s
+          sys     0m0,000s
+        \end{lstlisting}
+        \pause[7]
+        \begin{itemize}
+          \arrowitem
+            etwas über 1 Minute\\
+            für 64 Scheiben
+        \end{itemize}
+        \pause
+        \vspace*{-0.5cm}
+        \begin{picture}(0,0)
+          \color{red}
+          \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}}
+          \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}}
+        \end{picture}
+
+        Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
+        % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859
+        \begin{itemize}
+          \arrowitem
+            $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$
+            Jahre\\[\smallskipamount]
+            für 64 Scheiben
+        \end{itemize}
+      \end{minipage}
+    \end{onlyenv}
+  \end{onlyenv}
+
+\end{frame}
+
+\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
+
+\begin{frame}[fragile]
+
+%  \newcommand{\w}{\hspace*{0.75pt}}
+
+  \showsubsection
+
+  \begin{picture}(0,0)
+    \put(7.6,-0.5){%
+      \begin{minipage}[t]{5.3cm}
+%        \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
+        \vspace*{-1.0cm}\alt<6->{\includegraphics{landau-symbols-3.pdf}}%
+                       {\alt<5->{\includegraphics{landau-symbols-2.pdf}}%
+                                {\includegraphics{landau-symbols.pdf}}}
+        \small
+        \begin{description}\itemsep0pt\leftskip-0.5cm
+          \item[$n$:] Eingabedaten
+          \item[$g(n)$:] Rechenzeit
+        \end{description}
+      \end{minipage}}
+  \end{picture}
+
+  \vspace*{-\bigskipamount}
+
+  Wann ist ein Programm "`schnell"'?
+
+  \medskip
+
+  \begin{onlyenv}<1-2>
+      Türme von Hanoi: $\mathcal{O}(2^n)$
+      \par\medskip
+      Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
+      % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859
+      \begin{itemize}
+        \arrowitem
+          $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$
+          Jahre\\[\smallskipamount]
+          für 64 Scheiben
+      \end{itemize}
+
+      \bigskip
+  \end{onlyenv}
+
+  \begin{onlyenv}<2->
+    Faustregel:\\Schachtelung der Schleifen zählen\\
+    $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$
+
+    \bigskip
+  \end{onlyenv}
+
+  \begin{onlyenv}<3>
+    \textbf{Beispiel: Sortieralgorithmen}
+
+    \smallskip
+
+    Anzahl der Vergleiche bei $n$ Strings
+    \begin{itemize}
+      \item
+        Maximum suchen mit Schummeln: $\mathcal{O}(1)$
+      \item
+        Maximum suchen: $\mathcal{O}(n)$
+      \item
+        Selection-Sort: $\mathcal{O}(n^2)$
+      \item
+        Bubble-Sort: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$
+      \item
+        Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$
+    \end{itemize}
+
+  \end{onlyenv}
+
+  \begin{onlyenv}<4>
+    \textbf{Wie schnell ist RSA-Verschlüsselung?}
+
+    \smallskip
+
+    \begin{math}
+      c = m^e\,\%\,N
+    \end{math}
+    \quad
+    ("`$\%$"' = "`modulo"')
+
+    \medskip
+
+    \begin{lstlisting}[gobble=6,xleftmargin=2em]
+      int c = 1;
+      for (int i = 0; i < e; i++)
+        c = (c * m) % N;
+    \end{lstlisting}
+
+    \smallskip
+
+    \begin{itemize}
+      \item
+        $\mathcal{O}(e)$ Iterationen
+%      \item
+%        wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist:
+%        $\mathcal{O}(2^n)$ Iterationen
+      \item
+        mit Trick:
+        $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$)
+    \end{itemize}
+
+    \smallskip
+
+    Jede Iteration enthält eine Multiplikation und eine Division.\\
+    Aufwand dafür: $\mathcal{O}(\log e)$\\
+    \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$
+
+  \end{onlyenv}
+
+  \begin{onlyenv}<5->
+
+    \textbf{Wie schnell ist RSA?}\\
+
+    \smallskip
+
+    ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$)
+
+    \begin{itemize}
+      \item
+        Ver- und Entschlüsselung (Exponentiation):\\
+        \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
+        \only<6->{{\color{magenta}$\mathcal{O}(n^2)$}}
+      \item
+        Schlüsselerzeugung (Berechnung von $d$):\\
+        \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
+        \only<6->{{\color{magenta}$\mathcal{O}(n^2)$}}
+      \item
+        Verschlüsselung brechen (Primfaktorzerlegung):\\
+        \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss}
+        \only<6->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}}
+    \end{itemize}
+
+    \vspace{0cm plus 1filll}
+
+    \textbf{Die Sicherheit von RSA beruht darauf,
+    daß das Brechen der Verschlüsselung aufwendiger ist als
+    \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).}
+
+    \vspace*{0.65cm}
+
+  \end{onlyenv}
+
+\end{frame}
+
+\section{Objektorientierte Programmierung}
+
+\addtocounter{subsection}{-1}
+\subsection{Dynamische Speicherverwaltung}
+
+\begin{frame}[fragile]
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
+    \item
+      Dynamisches Array: variable Anzahl von Elementen desselben Typs
+  \end{itemize}
+
+  \bigskip
+
+  \begin{lstlisting}
+    char *name[] = { "Anna", "Berthold", "Caesar" };
+
+    ...
+
+     name[3] = "Dieter";
+  \end{lstlisting}
+
+  \begin{picture}(0,0)
+    \color{red}
+    \put(0,0){\line(3,1){3.5}}
+    \put(0,1){\line(3,-1){3.5}}
+  \end{picture}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsection
+  \showsubsection
+
+  \bigskip
+
+  \begin{lstlisting}
+    #include <stdlib.h>
+
+    ...
+
+      char **name = malloc (3 * sizeof (char *));
+        /* Speicherplatz für 3 Zeiger anfordern */
+
+    ...
+
+      free (name)
+        /* Speicherplatz freigeben */
+
+  \end{lstlisting}
+
+\end{frame}
+
+\subsection{Konzepte und Ziele}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+%      Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
+      Array: Elemente desselben Typs (z.\,B.\ 3 ganze Zahlen)
+%    \item
+%      Dynamisches Array: variable Anzahl von Elementen desselben Typs
+    \item
+      Problem: Elemente unterschiedlichen Typs
+    \item
+      Lösung: den Typ des Elements zusätzlich speichern
+  \end{itemize}
+  \begin{itemize}
+    \item
+      Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden}
+    \begin{onlyenv}<1>
+      \item
+        Was die Funktion bewirkt,\\
+        hängt vom Typ des Objekts ab
+      \item
+        Realisierung über endlose \lstinline{if}-Ketten
+    \end{onlyenv}
+    \begin{onlyenv}<2>
+      \item
+        Was die Funktion bewirkt
+        \begin{picture}(0,0)
+          \color{red}
+          \put(-4.00,-0.10){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);%
+                                  \draw[thick](-0.1,-0.05)--(3.75,0.3);}}
+        \end{picture}%
+        Welche Funktion aufgerufen wird,\\
+        hängt vom Typ des Objekts ab: \newterm{virtuelle Methode}
+      \item
+        Realisierung über endlose \lstinline{if}-Ketten%
+        \begin{picture}(0,0)
+          \color{red}
+          \put(-2.75,-0.10){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);%
+                                  \draw[thick](-0.1,-0.05)--(2.5,0.3);}}
+          \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\
+                           kommt gleich
+%                           nächste Woche
+                         \end{rotate}}
+        \end{picture}
+        Zeiger, die im Objekt gespeichert sind\\
+        (Genaugenommen: Tabelle von Zeigern)
+    \end{onlyenv}
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Problem: Elemente unterschiedlichen Typs
+    \item
+      Lösung: den Typ des Elements zusätzlich speichern
+    \item
+      \newterm{Methoden\/} und \newterm{virtuelle Methoden}
+  \end{itemize}
+
+  \begin{itemize}
+    \item
+      Zeiger auf verschiedene Strukturen\\
+      mit einem gemeinsamen Anteil von Datenfeldern\\
+      \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassen} von Objekten
+    \item
+      Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\
+      \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung}
+    \item
+%      Explizite Typumwandlung eines Zeigers auf die Basisklasse\\
+%      in einen Zeiger auf die \newterm{abgeleitete Klasse}\\
+%      \textarrow\ Man kann ein Array unterschiedlicher Objekte\\
+%      \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\
+      Zeiger auf die Basisklasse dürfen auf Objekte\\
+      der \newterm{abgeleiteten Klasse} zeigen\\
+      \textarrow\ \newterm{Polymorphie}
+  \end{itemize}
+
+\end{frame}
+
+\subsection{Beispiel: Zahlen und Buchstaben}
+
+\begin{frame}[fragile]
+
+  \showsection
+  \showsubsection
+
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+        } t_base;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          int content;
+        } t_integer;¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          char *content;
+        } t_string;¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+  
+\end{frame}
+
+\begin{frame}[fragile]
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+        } t_base;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          int content;
+        } t_integer;¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          char *content;
+        } t_string;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.7cm]
+    \begin{onlyenv}<1>
+      \begin{minipage}{8cm}
+        \begin{lstlisting}[gobble=10]
+          ¡t_integer i = { 1, 42 };
+          t_string s = { 2, "Hello, world!" };
+
+          t_base *object[] = { (t_base *) &i, (t_base *) &s };¿
+        \end{lstlisting}
+      \end{minipage}%
+      \begin{picture}(0,0)
+        \color{red}
+        \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}}
+      \end{picture}
+    \end{onlyenv}
+%    \begin{onlyenv}<2>
+%      \begin{minipage}{5cm}
+%        \begin{lstlisting}[gobble=10]
+%          ¡typedef union
+%          {
+%            t_base base;
+%            t_integer integer;
+%            t_string string;
+%          } t_object;¿
+%        \end{lstlisting} %      \end{minipage}
+%    \end{onlyenv}
+  \end{center}
+  
+\end{frame}
+
+\subsection{Unions}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Variable teilen sich denselben Speicherplatz.
+
+  \medskip
+
+  \begin{minipage}[t]{3.7cm}
+    \begin{lstlisting}[gobble=6]
+      ¡typedef union
+      {
+        int8_t i;
+        uint8_t u;
+      } num8_t;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{4.5cm}
+    \begin{lstlisting}[gobble=6]
+      ¡int main (void)
+      {
+        num8_t test;
+        test.i = -1;
+        printf ("%d\n", test.u);
+        return 0;
+      }¿
+    \end{lstlisting}
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Variable teilen sich denselben Speicherplatz.
+
+  \medskip
+
+  \begin{minipage}[t]{3.7cm}
+    \begin{lstlisting}[gobble=6]
+      ¡typedef union
+      {
+        char s[8];
+        uint64_t x;
+      } num_char_t;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{4.5cm}
+    \begin{lstlisting}[gobble=6]
+      ¡int main (void)
+      {
+        num_char_t test = { "Hello!" };
+        printf ("%lx\n", test.x);
+        return 0;
+      }¿
+    \end{lstlisting}
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Variable teilen sich denselben Speicherplatz.
+
+  \medskip
+
+  \begin{minipage}[t]{3.7cm}
+    \begin{lstlisting}[gobble=6]
+      ¡typedef union
+      {
+        t_base base;
+        t_integer integer;
+        t_string string;
+      } t_object;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3.0cm}
+    \begin{lstlisting}[gobble=6]
+
+      ¡typedef struct
+      {
+        int type;
+      } t_base;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3.0cm}
+    \begin{lstlisting}[gobble=6]
+
+      ¡typedef struct
+      {
+        int type;
+        int content;
+      } t_integer;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3.0cm}
+    \begin{lstlisting}[gobble=6]
+
+      ¡typedef struct
+      {
+        int type;
+        char *content;
+      } t_string;¿
+    \end{lstlisting}
+  \end{minipage}
+
+  \bigskip
+
+  \begin{center}
+    \begin{minipage}{8.5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡if (this->base.type == T_INTEGER)
+          printf ("Integer: %d\n", this->integer.content);
+        else if (this->base.type == T_STRING)
+          printf ("String: \"%s\"\n", this->string.content);¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+
+\end{frame}
+
+\subsection{Virtuelle Methoden}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  \begin{lstlisting}
+    void print_object (t_object *this)
+    {
+      if (this->base.type == T_INTEGER)
+        printf ("Integer: %d\n", this->integer.content);
+      else if (this->base.type == T_STRING)
+        printf ("String: \"%s\"\n", this->string.content);
+    }
+  \end{lstlisting}
+
+  \begin{picture}(0,0)
+    \color{red}
+    \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}}
+    \put(1,-2){\mbox{\textarrow}}
+    \put(0,-3){\mbox{Zeiger auf Funktionen}}
+  \end{picture}
+
+  \begin{lstlisting}[xleftmargin=4cm]
+    void print_integer (t_object *this)
+    {
+      printf ("Integer: %d\n", this->integer.content);
+    }
+
+    void print_string (t_object *this)
+    {
+      printf ("String: \"%s\"\n", this->string.content);
+    }
+  \end{lstlisting}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  Zeiger auf Funktionen
+
+  \medskip
+
+  \begin{lstlisting}
+    void (* print) (t_object *this);
+  \end{lstlisting}
+  \begin{picture}(0,1.2)(0,-0.9)
+    \color{red}
+    \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}}
+    \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}}
+  \end{picture}
+
+  \begin{itemize}
+    \item
+      Objekt enthält Zeiger auf Funktion
+      \begin{onlyenv}<1>
+        \medskip
+        \begin{lstlisting}[gobble=10]
+          typedef struct
+          {
+            void (* print) (union t_object *this);
+            int content;
+          } t_integer;
+        \end{lstlisting}
+      \end{onlyenv}
+      \begin{onlyenv}<2->
+        \vspace*{-3.5cm}  % Why doesn't a picture environment work here??? :-(
+        \begin{lstlisting}[gobble=10,xleftmargin=5.5cm]
+          typedef struct
+          {
+            void (* print) (union t_object *this);
+            int content;
+          } t_integer;
+        \end{lstlisting}
+        \vspace*{0.85cm}
+        \bigskip
+        \smallskip
+      \end{onlyenv}
+    \pause
+    \item
+      Konstruktor initialisiert diesen Zeiger
+      \begin{onlyenv}<2>
+        \medskip
+        \begin{lstlisting}[gobble=10]
+          t_object *new_integer (int i)
+          {
+            t_object *p = malloc (sizeof (t_integer));
+            p->integer.print = print_integer;
+            p->integer.content = i;
+            return p;
+          }
+        \end{lstlisting}
+        \vspace*{-2cm}
+      \end{onlyenv}
+    \pause
+    \item
+      Aufruf: "`automatisch"' die richtige Funktion
+      \begin{onlyenv}<3>
+        \medskip
+        \begin{lstlisting}[gobble=10]
+          for (int i = 0; object[i]; i++)
+            object[i]->base.print (object[i]);
+        \end{lstlisting}
+      \end{onlyenv}
+    \pause
+    \medskip
+    \item
+      in größeren Projekten:\\
+      Objekt enthält Zeiger auf Tabelle von Funktionen
+  \end{itemize}
+\end{frame}
+
+\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \scriptsize
+  \begin{lstlisting}
+    #include <gtk/gtk.h>
+
+    int main (int argc, char **argv)
+    {
+      gtk_init (&argc, &argv);
+      GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_title (GTK_WINDOW (window), "Hello");
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+      GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
+      gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
+      GtkWidget *label = gtk_label_new ("Hello, world!");
+      gtk_container_add (GTK_CONTAINER (vbox), label);
+      GtkWidget *button = gtk_button_new_with_label ("Quit");
+      g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
+      gtk_container_add (GTK_CONTAINER (vbox), button);
+      gtk_widget_show (button);
+      gtk_widget_show (label);
+      gtk_widget_show (vbox);
+      gtk_widget_show (window);
+      gtk_main ();
+      return 0;
+    }
+  \end{lstlisting}
+
+  \vspace*{-6cm}\strut\hfill
+  \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm]
+  \begin{flushright}
+    \normalsize\bf Praktikumsversuch:\\
+    Objektorientiertes Zeichenprogramm
+  \end{flushright}
+  
+\end{frame}
+
+\subsection{Ausblick: C++}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          void (* print) (union t_object *this);
+        } t_base;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5.5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          void (* print) (...);
+          int content;
+        } t_integer;¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          void (* print) (union t_object *this);
+          char *content;
+        } t_string;¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+  
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TBase
+        {
+          virtual void print (void);
+        };¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5.5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TInteger: public TBase
+        {
+          virtual void print (void);
+          int content;
+        };¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TString: public TBase
+        {
+          virtual void print (void);
+          char *content;
+        };¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+  
+\end{frame}
+
+\end{document}
diff --git a/20200116/landau-symbols-2.pdf b/20200116/landau-symbols-2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4
--- /dev/null
+++ b/20200116/landau-symbols-2.pdf
@@ -0,0 +1 @@
+../common/landau-symbols-2.pdf
\ No newline at end of file
diff --git a/20200116/landau-symbols-3.pdf b/20200116/landau-symbols-3.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..46efa409b35ff5df763c744a423599cba515d886
--- /dev/null
+++ b/20200116/landau-symbols-3.pdf
@@ -0,0 +1 @@
+../common/landau-symbols-3.pdf
\ No newline at end of file
diff --git a/20200116/landau-symbols.pdf b/20200116/landau-symbols.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565
--- /dev/null
+++ b/20200116/landau-symbols.pdf
@@ -0,0 +1 @@
+../common/landau-symbols.pdf
\ No newline at end of file
diff --git a/20200116/objects-1.c b/20200116/objects-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a628668fd7b8fb3a0d9886ac14e8e909bc23793
--- /dev/null
+++ b/20200116/objects-1.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+int main (void)
+{
+  t_integer i = { 1, 42 };
+  t_string s = { 2, "Hello, world!" };
+
+  t_base *object[] = { &i, &s };
+
+  return 0;
+}
diff --git a/20200116/objects-10.c b/20200116/objects-10.c
new file mode 100644
index 0000000000000000000000000000000000000000..ac47c0ed5479be655b7d76aba558526b2dc774a3
--- /dev/null
+++ b/20200116/objects-10.c
@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+  void (* print) (t_object *this);
+} t_base;
+
+typedef struct
+{
+  int type;
+  void (* print) (t_object *this);
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  void (* print) (t_object *this);
+  char *content;
+} t_string;
+
+typedef union
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+void print_integer (t_object *this)
+{
+  printf ("Integer: %d\n", this->integer.content);
+}
+
+void print_string (t_object *this)
+{
+  printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.type = T_INTEGER;
+  p->integer.print = print_integer;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->string.type = T_STRING;
+  p->string.print = print_string;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->base.print (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-11.c b/20200116/objects-11.c
new file mode 100644
index 0000000000000000000000000000000000000000..a15c8eb239b2315845f24f3b4f111d3670d7ea33
--- /dev/null
+++ b/20200116/objects-11.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+union t_object;
+
+typedef struct
+{
+  int type;
+  void (* print) (union t_object *this);
+} t_base;
+
+typedef struct
+{
+  int type;
+  void (* print) (union t_object *this);
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  void (* print) (union t_object *this);
+  char *content;
+} t_string;
+
+typedef union t_object
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+void print_integer (t_object *this)
+{
+  printf ("Integer: %d\n", this->integer.content);
+}
+
+void print_string (t_object *this)
+{
+  printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.type = T_INTEGER;
+  p->integer.print = print_integer;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->string.type = T_STRING;
+  p->string.print = print_string;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->base.print (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-12.c b/20200116/objects-12.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d605e1b295e252b2d947a1d4ac04c9fc805d36d
--- /dev/null
+++ b/20200116/objects-12.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+union t_object;
+
+typedef struct
+{
+  void (* print) (union t_object *this);
+} t_base;
+
+typedef struct
+{
+  void (* print) (union t_object *this);
+  int content;
+} t_integer;
+
+typedef struct
+{
+  void (* print) (union t_object *this);
+  char *content;
+} t_string;
+
+typedef union t_object
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+void print_integer (t_object *this)
+{
+  printf ("Integer: %d\n", this->integer.content);
+}
+
+void print_string (t_object *this)
+{
+  printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.print = print_integer;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->string.print = print_string;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->base.print (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-13.c b/20200116/objects-13.c
new file mode 100644
index 0000000000000000000000000000000000000000..81ef279b060e0b6290194fdeda8c3330cb716cdd
--- /dev/null
+++ b/20200116/objects-13.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+union t_object;
+struct t_vmt;
+
+typedef struct
+{
+  struct t_vmt *vmt;
+} t_base;
+
+typedef struct
+{
+  struct t_vmt *vmt;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  struct t_vmt *vmt;
+  char *content;
+} t_string;
+
+typedef union t_object
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+typedef struct t_vmt
+{
+  void (* print) (union t_object *this);
+} t_vmt;
+
+void print_integer (t_object *this)
+{
+  printf ("Integer: %d\n", this->integer.content);
+}
+
+void print_string (t_object *this)
+{
+  printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_vmt vmt_integer = { print_integer };
+t_vmt vmt_string = { print_string };
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.vmt = &vmt_integer;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->integer.vmt = &vmt_string;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->base.vmt->print (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-2.c b/20200116/objects-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..a47cfb4276085399afb86795d04b1f6ae20c95bf
--- /dev/null
+++ b/20200116/objects-2.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+int main (void)
+{
+  t_integer i = { 1, 42 };
+  t_string s = { 2, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s };
+
+  return 0;
+}
diff --git a/20200116/objects-3.c b/20200116/objects-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff9224c0767ccad39f5b1396720ee73b6a0455fb
--- /dev/null
+++ b/20200116/objects-3.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+int main (void)
+{
+  t_integer i = { 1, 42 };
+  t_string s = { 2, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s };
+
+  for (int i = 0; i < 2; i++)
+    if (object[i]->type == 1)
+      printf ("Integer: %d\n", object[i]->content);
+    else if (object[i]->type == 2)
+      printf ("String: \"%s\"\n", object[i]->content);
+
+  return 0;
+}
diff --git a/20200116/objects-4.c b/20200116/objects-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..ef7bffe80471d4b014258824421dce0557fc41dd
--- /dev/null
+++ b/20200116/objects-4.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+int main (void)
+{
+  t_integer i = { 1, 42 };
+  t_string s = { 2, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s };
+
+  for (int i = 0; i < 2; i++)
+    if (object[i]->type == 1)
+      printf ("Integer: %d\n", (t_integer *) object[i]->content);
+    else if (object[i]->type == 2)
+      printf ("String: \"%s\"\n", (t_string *) object[i]->content);
+
+  return 0;
+}
diff --git a/20200116/objects-5.c b/20200116/objects-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..820181d87e2a04b81cd2e03aa7980d970cd6c1a6
--- /dev/null
+++ b/20200116/objects-5.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+int main (void)
+{
+  t_integer i = { 1, 42 };
+  t_string s = { 2, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s };
+
+  for (int i = 0; i < 2; i++)
+    if (object[i]->type == 1)
+      printf ("Integer: %d\n", ((t_integer *) object[i])->content);
+    else if (object[i]->type == 2)
+      printf ("String: \"%s\"\n", ((t_string *) object[i])->content);
+
+  return 0;
+}
diff --git a/20200116/objects-6.c b/20200116/objects-6.c
new file mode 100644
index 0000000000000000000000000000000000000000..86847c9085083e2d5093026619550fb272b5f4ec
--- /dev/null
+++ b/20200116/objects-6.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+void print_object (t_base *this)
+{
+  if (this->type == 1)
+    printf ("Integer: %d\n", ((t_integer *) this)->content);
+  else if (this->type == 2)
+    printf ("String: \"%s\"\n", ((t_string *) this)->content);
+}
+
+int main (void)
+{
+  t_integer i = { 1, 42 };
+  t_string s = { 2, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s };
+
+  for (int i = 0; i < 2; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-7.c b/20200116/objects-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..b9b24ad65f650aeda194e4570ae853e1a5ad8f11
--- /dev/null
+++ b/20200116/objects-7.c
@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+void print_object (t_base *this)
+{
+  if (this->type == T_INTEGER)
+    printf ("Integer: %d\n", ((t_integer *) this)->content);
+  else if (this->type == T_STRING)
+    printf ("String: \"%s\"\n", ((t_string *) this)->content);
+}
+
+int main (void)
+{
+  t_integer i = { T_INTEGER, 42 };
+  t_string s = { T_STRING, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s, NULL };
+
+  for (int i = 0; object[i]; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-8.c b/20200116/objects-8.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c93e8f6c3c4b5e504c758dfa87b8510e98c0692
--- /dev/null
+++ b/20200116/objects-8.c
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+void print_object (t_base *this)
+{
+  if (this->type == T_INTEGER)
+    printf ("Integer: %d\n", ((t_integer *) this)->content);
+  else if (this->type == T_STRING)
+    printf ("String: \"%s\"\n", ((t_string *) this)->content);
+}
+
+t_integer *new_integer (int i)
+{
+  t_integer *p = malloc (sizeof (t_integer));
+  p->type = T_INTEGER;
+  p->content = i;
+  return p;
+}
+
+t_string *new_string (char *s)
+{
+  t_string *p = malloc (sizeof (t_string));
+  p->type = T_STRING;
+  p->content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_base *object[] = { (t_base *) new_integer (42),
+                       (t_base *) new_string ("Hello, world!"),
+                       NULL };
+
+  for (int i = 0; object[i]; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/20200116/objects-9.c b/20200116/objects-9.c
new file mode 100644
index 0000000000000000000000000000000000000000..41468b043cd69b1c19b2c4456eb937ff34dbe9f8
--- /dev/null
+++ b/20200116/objects-9.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+typedef union
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+void print_object (t_object *this)
+{
+  if (this->base.type == T_INTEGER)
+    printf ("Integer: %d\n", this->integer.content);
+  else if (this->base.type == T_STRING)
+    printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.type = T_INTEGER;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->string.type = T_STRING;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/20200116/pgslides.sty b/20200116/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..da062f7454c898ca1bc89bc29f268d9f00b21e5b
--- /dev/null
+++ b/20200116/pgslides.sty
@@ -0,0 +1 @@
+../20200102/pgslides.sty
\ No newline at end of file
diff --git a/20200116/unions-1.c b/20200116/unions-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..b75a6063b50193e13e9a2fd0ce140db6a8827499
--- /dev/null
+++ b/20200116/unions-1.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef union
+{
+  int8_t i;
+  uint8_t u;
+} num8_t;
+
+int main (void)
+{
+  num8_t test;
+  test.i = -1;
+  printf ("%d\n", test.u);
+  return 0;
+}
diff --git a/20200116/unions-2.c b/20200116/unions-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..be8562a50395e50e007dc1c0b19b98a476935670
--- /dev/null
+++ b/20200116/unions-2.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef union
+{
+  char s[8];
+  uint64_t x;
+} num_char_t;
+
+int main (void)
+{
+  num_char_t test = { "Hello!" };
+  printf ("%lx\n", test.x);
+  return 0;
+}
diff --git a/README.md b/README.md
index 8985f87d5730e652b5efa1f7fab977a6847ee7f5..b5b3929d7e4b8ce4f3f4fba38749e12dc63fbb24 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ Vortragsfolien und Beispiele:
  * [19.12.2019: Binärdarstellung negativer Zahlen, Speicherausrichtung - Alignment](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191219/hp-20191219.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191219/)
  * [02.01.2020: Quantencomputer, Datensicherheit und Datenschutz](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200102/hp-20200102.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20200102/)
  * [09.01.2020: Rekursion, Aufwandsabschätzungen, objektorientierte Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200109/hp-20200109.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20200109/)
+ * [16.01.2020: objektorientierte Programmierung, dynamische Speicherverwaltung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200116/hp-20200116.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20200116/)
  * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/hp-slides-2019ws.pdf)
 
 Übungsaufgaben:
diff --git a/hp-slides-2019ws.pdf b/hp-slides-2019ws.pdf
index 01e2773d41e8a2c023cba7620493e9ee7407a021..e58c987c624249785e642c33b8475ad5a6c6db0b 100644
Binary files a/hp-slides-2019ws.pdf and b/hp-slides-2019ws.pdf differ
diff --git a/hp-slides-2019ws.tex b/hp-slides-2019ws.tex
index d2cf57e289b32a0c0013ab672ed4fcf593fbcc4a..c976bd232a8ca75a32615f181e26bd6bc81ac5a9 100644
--- a/hp-slides-2019ws.tex
+++ b/hp-slides-2019ws.tex
@@ -34,4 +34,8 @@
   \includepdf[pages=-]{20191219/hp-20191219.pdf}
   \pdfbookmark[1]{02.01.2020: Quantencomputer, Datensicherheit und Datenschutz}{20200102}
   \includepdf[pages=-]{20200102/hp-20200102.pdf}
+  \pdfbookmark[1]{09.01.2020: Rekursion, Aufwandsabschätzungen, objektorientierte Programmierung}{20200109}
+  \includepdf[pages=-]{20200109/hp-20200109.pdf}
+  \pdfbookmark[1]{16.01.2020: objektorientierte Programmierung, dynamische Speicherverwaltung}{20200116}
+  \includepdf[pages=-]{20200116/hp-20200116.pdf}
 \end{document}