Vorbereitung 7.1.2016

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,8 +392,109 @@
 
 \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}
+
 \sectionnonumber{\inserttitle}
 
+\fi
+
 \begin{frame}
 
   \showsectionnonumber
@@ -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

@@ -117,4 +117,52 @@
       \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{14}
+
 \end{document}