20160107/ainf-20160107.tex

-% ainf-20151217.pdf - Lecture Slides on Applied Computer Sciences
-% Copyright (C) 2012, 2013, 2015  Peter Gerwinski
+% ainf-20160107.pdf - Lecture Slides on Applied Computer Sciences
+% Copyright (C) 2012, 2013, 2015, 2016  Peter Gerwinski
 %
 % This document is free software: you can redistribute it and/or
 % modify it either under the terms of the Creative Commons
@@ -43,7 +43,7 @@
 
 \title{Angewandte Informatik}
 \author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{17.\ Dezember 2015}
+\date{7.\ Januar 2016}
 
 \begin{document}
 
@@ -66,21 +66,21 @@
         \item[4.3] Stack und FIFO
         \color{red}
         \item[4.4] Aufwandsabschätzungen
+        \item[4.4] Dynamische Speicherverwaltung
       \end{itemize}
     \item[\textbf{5}] \textbf{Hardwarenahe Programmierung}
       \begin{itemize}
-        \item[5.1] Bit-Operationen
-        \item[5.2] I/O-Ports
-        \item[5.3] Interrupts
+        \vspace*{-5pt}
+        \item[\dots]
         \color{medgreen}
         \item[5.4] volatile-Variable
         \color{black}
         \item[5.5] Software-Interrupts
-        \item[\dots]
+        \item[5.6] Byte-Reihenfolge -- Endianness
+        \item[5.6] Speicherausrichtung -- Alignment
       \end{itemize}
-    \color{gray}
-    \item[\makebox(0,0){\textbf{\raisebox{0.5ex}{\dots}}}]
-%    \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
+    \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+    \item[\textbf{7}] \textbf{Ergänzungen und Ausblicke}
   \end{itemize}
 
 \end{frame}
@@ -262,6 +262,23 @@
 
 \end{frame}
 
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \vspace*{-1.2cm}
+  \strut\hfill\makebox(0,0)[tr]{\includegraphics[width=7.5cm]{portb.jpg}}
+
+  \bigskip\bigskip
+
+  \begin{minipage}{4.5cm}
+    \lstinline{PORTA}, \lstinline{PORTB}, \lstinline{DDRA} usw.\
+    sind \lstinline{volatile}-Variable an numerisch vorgegebenen
+    Speicheradressen (z.\,B.\ \lstinline{0x38} für \lstinline{PORTB}).
+  \end{minipage}
+
+\end{frame}
+
 \iffalse
 
 \subsection{Software-Interrupts}
@@ -375,6 +392,107 @@
 
 \end{frame}
 
+\subsection{Dynamische Speicherverwaltung}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \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]
+
+  \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}
+
+\iffalse
+
+\setcounter{section}{5}
+\section{Objektorientierte Programmierung}
+\subsection{Konzepte und Ziele}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Array: feste Anzahl von Elementen desselben Typs (z.\,B.: 3 Zeiger)
+    \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}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Problem: Elemente unterschiedlichen Typs
+    \item
+      Lösung: den Typ des Elements zusätzlich speichern
+  \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.\\
+      \textarrow\ \newterm{Polymorphie}
+  \end{itemize}
+
+\fi
+
 \sectionnonumber{\inserttitle}
 
 \begin{frame}
@@ -392,18 +510,19 @@
         \item[4.3] Stack und FIFO
         \color{medgreen}
         \item[4.4] Aufwandsabschätzungen
+        \item[4.4] Dynamische Speicherverwaltung
       \end{itemize}
     \item[\textbf{5}] \textbf{Hardwarenahe Programmierung}
       \begin{itemize}
+        \vspace*{-5pt}
         \item[\dots]
         \item[5.4] volatile-Variable
         \item[5.5] Software-Interrupts
         \item[5.6] Byte-Reihenfolge -- Endianness
         \item[5.6] Speicherausrichtung -- Alignment
       \end{itemize}
-    \color{gray}
-    \item[\makebox(0,0){\textbf{\raisebox{0.5ex}{\dots}}}]
-%    \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
+    \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+    \item[\textbf{7}] \textbf{Ergänzungen und Ausblicke}
   \end{itemize}
 
 \end{frame}

20160107/ainf-uebung-20160107.tex

@@ -24,21 +24,13 @@
 
 \usepackage{pgscript}
 \usepackage{enumerate}
-\usepackage{pdftricks}
-\usepackage{sfmath}
-
-\begin{psinputs}
-  \usepackage{pgscript}
-%  \definecolor{PracticallyWhite}{rgb}{0.99 0.99 0.99}
-  \definecolor{verylightgray}{rgb}{0.95 0.95 0.95}
-\end{psinputs}
+\usepackage{ifthen}
 
 \newcounter{exercise}
 \newcommand{\exercise}[1]{\addtocounter{exercise}{1}\subsection*{Aufgabe \arabic{exercise}: #1}}
 
 \newcounter{points}
-\newcommand{\onepoint}{(1 Punkt)\addtocounter{points}{1}}
-\newcommand{\points}[1]{(#1 Punkte)\addtocounter{points}{#1}}
+\newcommand{\points}[1]{\ifthenelse{#1=1}{(1 Punkt)}{(#1 Punkte)}\addtocounter{points}{#1}}
 
 \begin{document}
 
@@ -46,8 +38,131 @@
 
   \section*{Angewandte Informatik\\Übungsaufgaben -- 7.\ Januar 2016}
 
-  \subsection*{???}
+  \exercise{Landau-Symbole}
+
+  Von welcher Ordnung (Landau-Symbol) sind die folgenden Problemstellungen?\\
+  Begründen Sie jeweils Ihre Antwort.
+  \begin{enumerate}[\hspace{0.9em}(a)]
+    \item
+      Iterative Berechnung einer Fakultät
+      (siehe Übungsaufgabe 1 vom 19.\,11.\,2015)\\
+      \points{1}
+    \item
+      Rekursive Berechnung einer Fakultät\\
+      \points{1}
+    \item
+      Türme von Hanoi (nötige Anzahl von Verschiebungen
+      in Abhängigkeit von der Anzahl der Scheiben)\\
+      \points{1}
+    \item
+      \lstinline{push()} auf einen Stack\\
+      \points{1}
+    \item
+      Einfügen eines Elements irgendwo in den Stack
+      ("`mitten in den Stapel schieben"')\\
+      \points{1}
+    \item
+      \lstinline{push()} auf einen FIFO\\
+      \points{1}
+  \end{enumerate}
+
+  \exercise{Länge von Strings}
+
+  (Diese Übungsaufgabe ist eine Ergänzung zu Aufgabe 1 der Probeklausur
+  vom 22.\,10.\,2015.)
+
+  Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
+
+  Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
+
+  Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
+  zur Verfügung (\lstinline{#include <string.h>}).
+
+  Wir betrachten nun die folgenden Funktionen:
+  \begin{center}
+    \begin{minipage}{8cm}
+      \begin{lstlisting}[gobble=8]
+        int fun_1 (char *s)
+        {
+          int x = 0;
+          for (int i = 0; i < strlen (s); i++)
+            x += s[i];
+          return x;
+        }
+      \end{lstlisting}
+    \end{minipage}%
+    \begin{minipage}{6cm}
+      \vspace*{-1cm}
+      \begin{lstlisting}[gobble=8]
+        int fun_2 (char *s)
+        {
+          int i = 0, x = 0;
+          int len = strlen (s);
+          while (i < len)
+            x += s[i++];
+          return x;
+        }
+      \end{lstlisting}
+      \vspace*{-1cm}
+    \end{minipage}
+  \end{center}
+  \begin{itemize}
+    \item[(g)]
+      Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen\\
+      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
+      \points{2}
+    \item[(h)]
+      Von welcher Ordnung (Landau-Symbol) ist Ihre selbstgeschriebene,
+      effizientere Funktion und warum?
+      \points{1}
+  \end{itemize}
+
+  \clearpage
+
+  \exercise{Dynamisches Bit-Array}
+
+  Schreiben Sie die folgenden Funktionen zur Verwaltung eines dynamischen Bit-Arrays:
+  \begin{itemize}
+    \item
+      \lstinline{void bit_array_init (int n)}\\
+      Das Array initialisieren, so daß man \lstinline{n} Bits darin speichern kann.\\
+      Die Array-Größe \lstinline{n} ist keine Konstante, sondern erst im laufenden Programm bekannt.\\
+      Die Bits sollen auf den Anfangswert 0 initialisiert werden.
+    \item
+      \lstinline{void bit_array_set (int i, int value)}\\
+      Das Bit mit dem Index \lstinline{i} auf den Wert \lstinline{value} setzen.\\
+      Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen;
+      der Wert \lstinline{value} darf 1 oder 0 sein.
+    \item
+      \lstinline{void bit_array_flip (int i)}\\
+      Das Bit mit dem Index \lstinline{i} auf den entgegengesetzten Wert setzen,\\
+      also auf 1, wenn er vorher 0 ist, bzw.\ auf 0, wenn er vorher 1 ist.\\
+      Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen.
+    \item
+      \lstinline{int bit_array_get (int i)}\\
+      Den Wert des Bit mit dem Index \lstinline{i} zurückliefern.\\
+      Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen.
+    \item
+      \lstinline{void bit_array_resize (int new_n)}\\
+      Die Größe des Arrays auf \lstinline{new_n} Bits ändern.\\
+      Dabei soll der Inhalt des Arrays, soweit er in die neue Größe paßt, erhalten bleiben.\\
+      Neu hinzukommende Bits sollen auf 0 initialisiert werden.
+    \item
+      \lstinline{void bit_array_done (void)}\\
+      Den vom Array belegten Speicherplatz wieder freigeben.
+  \end{itemize}
+  Bei Bedarf dürfen Sie den Funktionen zusätzliche Parameter mitgeben,
+  beispielsweise um mehrere Arrays parallel verwalten zu können.
+  (In der objektorientierten Programmierung wäre dies der implizite Parameter \lstinline{this},
+  der auf die Objekt-Struktur zeigt.)
+
+  Die Bits sollen möglichst effizient gespeichert werden,
+  z.\,B.\ jeweils 8 Bits in einer \lstinline{uint8_t}-Variablen.
+
+  Die Funktionen sollen möglichst robust sein,
+  d.\,h.\ das Programm darf auch bei unsinnigen Parameterwerten nicht abstürzen,
+  sondern soll eine Fehlermeldung ausgeben.
 
-  \points{42}
+  \points{14}
 
 \end{document}

20160107/malloc-1.c

+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  int *buffer = NULL;
+
+  buffer = malloc (24 * sizeof (int));   /* 42 Integer-Variable anlegen */
+                /* ^^ Zahlendreher infolge Code-Verdopplung! */
+
+  for (int i = 0; i < 42; i++)
+    buffer[i] = i;
+
+  /* free() vergessen! :-( */
+
+  return 0;
+}

20160107/malloc-2.c

+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  int *buffer = NULL;
+
+  buffer = malloc (24 * sizeof (int));   /* 42 Integer-Variable anlegen */
+                /* ^^ Zahlendreher infolge Code-Verdopplung! */
+
+  for (int i = 0; i < 1042; i++)
+    buffer[i] = i;
+
+  /* free() vergessen! :-( */
+
+  return 0;
+}

20160107/malloc-3.c

+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  int *buffer = NULL;
+
+  buffer = malloc (24 * sizeof (int));   /* 42 Integer-Variable anlegen */
+                /* ^^ Zahlendreher infolge Code-Verdopplung! */
+
+  for (int i = 0; i < 42000; i++)
+    buffer[i] = i;
+
+  /* free() vergessen! :-( */
+
+  return 0;
+}

20160107/malloc-4.c

+#include <stdio.h>
+#include <stdlib.h>
+
+int main (void)
+{
+  int *buffer = NULL;
+
+  buffer = malloc (24 * sizeof (int));   /* 42 Integer-Variable anlegen */
+                /* ^^ Zahlendreher infolge Code-Verdopplung! */
+
+  for (int i = 0; i < 42000; i++)
+    {
+      printf ("i = %d\n", i);
+      buffer[i] = i;
+    }
+
+  /* free() vergessen! :-( */
+
+  return 0;
+}

20160107/malloc-5.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#define SIZE 42
+
+int main (void)
+{
+  int *buffer = NULL;
+  buffer = malloc (SIZE * sizeof (int));   /* SIZE Integer-Variable anlegen */
+
+  for (int i = 0; i < SIZE; i++)
+    buffer[i] = i;
+
+  free (buffer);
+  return 0;
+}

20160107/portb.jpg

+../common/portb.jpg
\ No newline at end of file

20160107/sort-10.c

+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+int comp_counter = 0;
+
+void clear_screen (void)
+{
+  printf ("\e[H\e[J");
+}
+
+void output_marked (char **name, int mark1, int mark2)
+{
+  clear_screen ();
+  for (int i = 0; name[i]; i++)
+    if (i == mark1 || i == mark2)
+      printf ("%s <--\n", name[i]);
+    else
+      printf ("%s\n", name[i]);
+  printf ("%d\n", comp_counter);
+}
+
+void output (char **name)
+{
+  output_marked (name, -1, -1);
+}
+
+int compare (char **name, int left, int right)
+{
+  comp_counter++;
+  output_marked (name, left, right);
+  usleep (200000);
+  return strcmp (name[left], name[right]);
+}
+
+void sort (char **name)
+{
+  int target = 0;
+  while (name[target])
+    target++;             /* Länge des Arrays ermitteln */
+  int start = 1;
+  while (target > 0)
+    {
+      for (int i = start; i < target; i++)
+        if (compare (name, i - 1, i) > 0)
+          {
+            char *temp = name[i - 1];
+            name[i - 1] = name[i];
+            name[i] = temp;
+          }
+      target--;
+    }
+}
+
+int main (void)
+{
+  char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
+                   "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
+                   "Thomas", "Ulrich", "Zacharias", NULL };
+  sort (name);
+  return 0;
+}

20160107/sort-11.c

+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+int comp_counter = 0;
+
+void clear_screen (void)
+{
+  printf ("\e[H\e[J");
+}
+
+void output_marked (char **name, int mark1, int mark2)
+{
+  clear_screen ();
+  for (int i = 0; name[i]; i++)
+    if (i == mark1 || i == mark2)
+      printf ("%s <--\n", name[i]);
+    else
+      printf ("%s\n", name[i]);
+  printf ("%d\n", comp_counter);
+}
+
+void output (char **name)
+{
+  output_marked (name, -1, -1);
+}
+
+int compare (char **name, int left, int right)
+{
+  comp_counter++;
+  output_marked (name, left, right);
+  usleep (200000);
+  return strcmp (name[left], name[right]);
+}
+
+void sort (char **name)
+{
+  int target = 0;
+  while (name[target])
+    target++;             /* Länge des Arrays ermitteln */
+  int start = 1;
+  int last_swap = 0;
+  while (target > 0)
+    {
+      for (int i = start; i < target; i++)
+        if (compare (name, i - 1, i) > 0)
+          {
+            last_swap = i;
+            char *temp = name[i - 1];
+            name[i - 1] = name[i];
+            name[i] = temp;
+          }
+      target = last_swap;
+    }
+}
+
+int main (void)
+{
+  char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
+                   "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
+                   "Thomas", "Ulrich", "Zacharias", NULL };
+  sort (name);
+  return 0;
+}

20160107/sort-12.c

+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+int comp_counter = 0;
+
+void clear_screen (void)
+{
+  printf ("\e[H\e[J");
+}
+
+void output_marked (char **name, int mark1, int mark2)
+{
+  clear_screen ();
+  for (int i = 0; name[i]; i++)
+    if (i == mark1 || i == mark2)
+      printf ("%s <--\n", name[i]);
+    else
+      printf ("%s\n", name[i]);
+  printf ("%d\n", comp_counter);
+}
+
+void output (char **name)
+{
+  output_marked (name, -1, -1);
+}
+
+int compare (char **name, int left, int right)
+{
+  comp_counter++;
+  output_marked (name, left, right);
+  usleep (200000);
+  return strcmp (name[left], name[right]);
+}
+
+void sort (char **name)
+{
+  int target = 0;
+  while (name[target])
+    target++;             /* Länge des Arrays ermitteln */
+  int start = 1;
+  while (target > 0)
+    {
+      int last_swap = 0;
+      for (int i = start; i < target; i++)
+        if (compare (name, i - 1, i) > 0)
+          {
+            last_swap = i;
+            char *temp = name[i - 1];
+            name[i - 1] = name[i];
+            name[i] = temp;
+          }
+      target = last_swap;
+    }
+}
+
+int main (void)
+{
+  char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
+                   "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
+                   "Thomas", "Ulrich", "Zacharias", NULL };
+  sort (name);
+  return 0;
+}

20160107/sort-13.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+int comp_counter = 0;
+
+void clear_screen (void)
+{
+  printf ("\e[H\e[J");
+}
+
+void output_marked (char **name, int mark)
+{
+  clear_screen ();
+  for (int i = 0; name[i]; i++)
+    if (i == mark)
+      printf ("%s <--\n", name[i]);
+    else
+      printf ("%s\n", name[i]);
+  printf ("%d\n", comp_counter);
+}
+
+void output (char **name)
+{
+  output_marked (name, -1);
+}
+
+int compare (char **name, int left, char *right)
+{
+  comp_counter++;
+  output_marked (name, left);
+  usleep (100000);
+  return strcmp (name[left], right);
+}
+
+void sort (char **name, int left, int right)  /* QuickSort */
+{
+  if (left < right)
+    {
+      int middle = left + rand () % (right - left + 1);
+      char *test = name[middle];
+      int l = left;
+      int r = right;
+      while (l <= r)
+        {
+          while (compare (name, l, test) < 0)
+            l++;
+          while (compare (name, r, test) > 0)
+            r--;
+          if (l <= r)
+            {
+              char *temp = name[l];
+              name[l] = name[r];
+              name[r] = temp;
+              l++;
+              r--;
+            }
+        }
+      sort (name, left, r);
+      sort (name, l, right);
+    }
+}
+
+int main (void)
+{
+  char *names[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
+                    "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
+                    "Thomas", "Ulrich", "Zacharias", NULL };
+  srand (13);
+  sort (names, 0, 15);
+  output (names);
+  return 0;
+}

20160107/sort-9.c

+#include <stdio.h>
+#include <string.h>
+
+void sort (char **name)
+{
+  int target = 0;
+  while (name[target])
+    target++;             /* Länge des Arrays ermitteln */
+  while (target > 0)
+    {
+      for (int i = 1; i < target; i++)
+        if (strcmp (name[i - 1], name[i]) > 0)
+          {
+            char *temp = name[i - 1];
+            name[i - 1] = name[i];
+            name[i] = temp;
+          }
+      target--;
+    }
+}
+
+int main (void)
+{
+  char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
+                   "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
+                   "Thomas", "Ulrich", "Zacharias", NULL };
+  sort (name);
+  for (int i = 0; name[i]; i++)
+    printf ("%s\n", name[i]);
+  return 0;
+}

20160111/noreturn-1.c

+#include <stdio.h>
+#include <stdlib.h>
+
+__attribute__ ((noreturn)) void fatal_error (char *msg)
+{
+  fprintf (stderr, "%s\n", msg);
+  exit (1);
+}
+
+int main (void)
+{
+  fatal_error ("error not found");
+}

20160111/random-1.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+int main (int argc, char **argv)
+{
+  FILE *dev_random = fopen ("/dev/random", "rb");
+  if (!dev_random)
+    {
+      fprintf (stderr, "%s: cannot open /dev/random\n", argv[0]);
+      exit (1);
+    }
+  else
+    {
+      uint16_t x;
+      fread (&x, sizeof (x), 1, dev_random);
+      printf ("%d\n", x);
+      fclose (dev_random);
+    }
+  return 0;
+}