Skip to content
Snippets Groups Projects
Commit 922528f2 authored by Peter Gerwinski's avatar Peter Gerwinski
Browse files

Vorbereitung 23.1.2020

parent 84064fd6
Branches 2014ss
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
20191128/hp-musterloesung-20191128.pdf 0 → 100644
+ 0
− 0
View file @ 922528f2
File added
20191128/hp-musterloesung-20191128.tex 0 → 100644
+ 278
− 0
View file @ 922528f2
% hp-musterloesung-20191128.pdf - Solutions to the Exercises on Low-Level Programming
% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019 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: Datum-Bibliothek, Text-Grafik-Bibliothek, LED-Blinkmuster
\documentclass[a4paper]{article}
\usepackage{pgscript}
\usepackage{sfmath}
\begin{document}
\section*{Hardwarenahe Programmierung\\
Musterlösung zu den Übungsaufgaben -- 28.\ November 2019}
\exercise{Datum-Bibliothek}
Zerlegen Sie die Datum-Bibliothek aus der Übungsaufgabe 2 vom 7.\,11.\,2019
in eine \file{.c}- und eine \file{.h}-Datei. \points{4}
Hinweis: Schreiben Sie zusätzlich ein Test-Programm.
\solution
Die Dateien \gitfile{hp}{20191128}{dates.c} und \gitfile{hp}{20191128}{dates.h} enthalten die Bibliothek,
die Datei \gitfile{hp}{20191128}{test-dates.c} ein Programm zum Testen der Bibliothek.
\exercise{Text-Grafik-Bibliothek}
Schreiben Sie eine Bibliothek für "`Text-Grafik"' mit folgenden Funktionen:\vspace*{-\medskipamount}
\begin{itemize}
\item
\lstinline|void clear (char c)|\\
Bildschirm auf Zeichen \lstinline|c| löschen,\\
also komplett mit diesem Zeichen (z.\,B.: Leerzeichen) füllen
\item
\lstinline|void put_point (int x, int y, char c)|\\
Punkt setzen (z.\,B.\ einen Stern (\lstinline{*}) an die Stelle $(x,y)$ "`malen"')
\item
\lstinline|char get_point (int x, int y)|\\
Punkt lesen
% \item
% \lstinline|void fill (int x, int y, char c, char o)|\\
% Fläche in der "`Farbe"' \lstinline|o|,
% die den Punkt \lstinline|(x, y)| enthält,
% mit der "`Farbe"' \lstinline|c| ausmalen
\item
\lstinline|void display (void)|\\
das Gezeichnete auf dem Bildschirm ausgeben
\end{itemize}
Hinweise:\vspace*{-\medskipamount}
\begin{itemize}
\item
Eine C-Bibliothek besteht aus (mindestens)
einer \file{.h}-Datei und einer \file{.c}-Datei.
\item
Verwenden Sie ein Array als "`Bildschirm"'.
Vor dem Aufruf der Funktion \lstinline|display()| ist nichts zu sehen;\\
alle Grafikoperationen erfolgen auf dem Array.
\item
Verwenden Sie Präprozessor-Konstante,
z.\,B.\ \lstinline{WIDTH} und \lstinline{HEIGHT},\\
um Höhe und Breite des "`Bildschirms"' festzulegen:
\begin{lstlisting}[gobble=8]
#define WIDTH 72
#define HEIGHT 24
\end{lstlisting}
\item
Schreiben Sie zusätzlich ein Test-Programm,
das alle Funktionen der Bibliothek benutzt,\\
um ein hübsches Bild (z.\,B.\ ein stilisiertes Gesicht -- "`Smiley"')
auszugeben.
\end{itemize}
\points{8}
\solution
Siehe die Dateien \gitfile{hp}{20191128}{textgraph.c} und \gitfile{hp}{20191128}{textgraph.h} (Bibliothek)
sowie \gitfile{hp}{20191128}{test-textgraph.c} (Test-Programm).
Diese Lösung erfüllt zusätzlich die Aufgabe,
bei fehlerhafter Benutzung (Koordinaten außerhalb des Zeichenbereichs)
eine sinnvolle Fehlermeldung auszugeben,
anstatt unkontrolliert Speicher zu überschreiben und abzustürzen.
Das Schlüsselwort \lstinline{static}
bei der Deklaration der Funktion \lstinline{check_coordinates()}
bedeutet, daß diese Funktion nur lokal (d.\,h.\ innerhalb der Bibliothek)
verwendet und insbesondere nicht nach außen
(d.\,h.\ für die Benutzung durch das Hauptprogramm) exportiert wird.
Dies dient dazu, nicht unnötig Bezeichner zu reservieren
(Vermeidung von "`Namensraumverschmutzung"').
Man beachte die Verwendung einfacher Anführungszeichen (Apostrophe)
bei der Angabe von \lstinline{char}-Kon"-stanten (\lstinline{'*'})
im Gegensatz zur Verwendung doppelter Anführungszeichen
bei der Angabe von String-Konstanten
(String = Array von \lstinline{char}s, abgeschlossen mit Null-Symbol).
Um das einfache Anführungszeichen selbst als \lstinline{char}-Konstante anzugeben,
ist ein vorangestellter Backslash erforderlich: \lstinline{'\''} ("`Escape-Sequenz"').
Entsprechendes gilt für die Verwendung doppelter Anführungszeichen
innerhalb von String-Konstanten:
\lstinline{printf ("Your name is: \"%s\"", name);}
\exercise{LED-Blinkmuster}
Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
(Datei: \gitfile{hp}{20191128}{aufgabe-3.c}).
\begin{minipage}[t]{7cm}
\begin{lstlisting}[gobble=6]
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
uint8_t counter = 1;
uint8_t leds = 0;
ISR (TIMER0_COMP_vect)
{
if (counter == 0)
{
leds = (leds + 1) % 8;
PORTC = leds << 4;
}
counter++;
}
\end{lstlisting}
\end{minipage}\hfill\begin{minipage}[t]{8.5cm}
\begin{lstlisting}[gobble=6]
void init (void)
{
cli ();
TCCR0 = (1 << CS01) | (1 << CS00);
TIMSK = 1 << OCIE0;
sei ();
DDRC = 0x70;
}
int main (void)
{
init ();
while (1)
; /* do nothing */
return 0;
}
\end{lstlisting}
\end{minipage}
An die Bits Nr.\ 4, 5 und 6 des Output-Ports C des Mikro-Controllers sind LEDs angeschlossen.\\
Sobald das Programm läuft, blinken diese in charakteristischer Weise:
\begin{quote}
\newcommand{\tdn}[1]{\raisebox{-2pt}{#1}}
\begin{tabular}{|c|c|c|c|}\hline
\tdn{Phase} & \tdn{LED oben (rot)} & \tdn{LED Mitte (gelb)} & \tdn{LED unten (grün)} \\[2pt]\hline
1 & aus & aus & an \\\hline
2 & aus & an & aus \\\hline
3 & aus & an & an \\\hline
4 & an & aus & aus \\\hline
5 & an & aus & an \\\hline
6 & an & an & aus \\\hline
7 & an & an & an \\\hline
8 & aus & aus & aus \\\hline
\end{tabular}
\end{quote}
Jede Phase dauert etwas länger als eine halbe Sekunde.
Nach 8 Phasen wiederholt sich das Schema.
Erklären Sie das Verhalten des Programms anhand des Quelltextes:
\vspace{-\medskipamount}
\begin{itemize}\itemsep0pt
\item[(a)]
Wieso macht das Programm überhaupt etwas,
wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
in der \emph{nichts} passiert?
\points{1}
\item[(b)]
Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
wobei die Variable \lstinline|counter| auf 1 initialisiert,
fortwährend erhöht und nirgendwo zurückgesetzt wird?
\points{2}
\item[(c)]
Wie kommt das oben beschriebene Blinkmuster zustande?
\points{2}
\item[(d)]
Wieso dauert eine Phase ungefähr eine halbe Sekunde?
\points{2}
\item[(e)]
Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?
\points{1}
\end{itemize}
\goodbreak
Hinweis:
\vspace{-\medskipamount}
\begin{itemize}\itemsep0pt
\item
Die Funktion \lstinline|init()| sorgt dafür, daß der Timer-Interrupt Nr.\ 0 des Mikro-Controllers
etwa 488mal pro Sekunde aufgerufen wird.
Außerdem initialisiert sie die benötigten Bits an Port C als Output-Ports.
Sie selbst brauchen die Funktion \lstinline|init()| nicht weiter zu erklären.
\end{itemize}
\solution
\begin{itemize}\itemsep0pt
\item[(a)]
\textbf{Wieso macht das Programm überhaupt etwas,
wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
in der \emph{nichts} passiert?}
Das Blinken wird durch einen Interrupt-Handler implementiert.
Dieser wird nicht durch das Hauptprogramm,
sondern durch ein Hardware-Ereignis (hier: Uhr) aufgerufen.
\item[(b)]
\textbf{Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
wobei die Variable \lstinline|counter| auf 1 initialisiert,
fortwährend erhöht und nirgendwo zurückgesetzt wird?}
Die vorzeichenlose 8-Bit-Variable \lstinline{counter} kann nur
Werte von 0 bis 255 annehmen; bei einem weiteren
INkrementieren springt sie wieder auf 0 (Überlauf),
und die \lstinline{if}-Bedingung ist erfüllt.
\item[(c)]
\textbf{Wie kommt das oben beschriebene Blinkmuster zustande?}
In jedem Aufruf des Interrupt-Handlers wird die Variable
\lstinline{leds} um 1 erhöht und anschließend modulo 8 genommen.
Sie durchläuft daher immer wieder die Zahlen von 0 bis 7.
Durch die Schiebeoperation \lstinline{leds << 4} werden die 3 Bits
der Variablen \lstinline{leds} an diejenigen Stellen im Byte
geschoben, an denen die LEDs an den Mikro-Controller
angeschlossen sind (Bits 4, 5 und 6).
Entsprechend durchläuft das Blinkmuster immer wieder
die Binärdarstellungen der Zahlen von 0 bis 7
(genauer: von 1 bis 7 und danach 0).
\item[(d)]
\textbf{Wieso dauert eine Phase ungefähr eine halbe Sekunde?}
Der Interrupt-Handler wird gemäß Hinweis 488mal pro Sekunde aufgerufen.
Bei jedem 256sten Aufruf ändert sich das LED-Muster.
Eine Phase dauert somit $\frac{256}{488} \approx 0.52$ Sekunden.
\item[(e)]
\textbf{Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?}
Deklaration eines Interrupt-Handlers für den Timer-Interrupt Nr.\ 0
\end{itemize}
\end{document}
20200123/hello-gtk.png 0 → 120000
+ 1
− 0
View file @ 922528f2
../common/hello-gtk.png
\ No newline at end of file
20200123/hp-20200123.pdf 0 → 100644
+ 0
− 0
View file @ 922528f2
File added
20200123/hp-20200123.tex 0 → 100644
+ 1127
− 0
View file @ 922528f2
% hp-20200123.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, Datenstrukturen
\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{23.\ 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}
\item[\textbf{6}] \textbf{Objektorientierte Programmierung}
\begin{itemize}
\color{medgreen}
\item[6.0] Dynamische Speicherverwaltung
\color{black}
\item[6.1] Konzepte und Ziele
\item[6.2] Beispiel: Zahlen und Buchstaben
\color{medgreen}
\item[6.3] Unions
\item[6.4] Virtuelle Methoden
\color{red}
\item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
\item[6.6] Ausblick: C++
\end{itemize}
\item[\textbf{7}] \textbf{Datenstrukturen}
\begin{itemize}
\color{red}
\item[7.1] Stack und FIFO
\vspace*{-\smallskipamount}
\item[\dots]
\end{itemize}
\end{itemize}
\end{frame}
\setcounter{section}{5}
\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}
\section{Datenstrukturen}
\subsection{Stack und FIFO}
\begin{frame}[fragile]
\showsection
\showsubsection
\begin{minipage}{0.48\textwidth}
Im letzten Praktikumsversuch:
\begin{itemize}
\item
Array nur zum Teil benutzt
\item
Variable speichert genutzte Länge
\item
Elemente hinten anfügen\\
oder entfernen
\arrowitem
Stack\\
\strut
\end{itemize}
\bigskip
\begin{itemize}
\item
hinten anfügen/entfernen: $\mathcal{O}(1)$\hspace*{-1cm}
\item
vorne oder in der Mitte einfügen/entfernen: $\mathcal{O}(n)$
\end{itemize}
\end{minipage}\hfill
\begin{minipage}{0.52\textwidth}
Auch möglich:
\begin{itemize}
\item
Array nur zum Teil benutzt
\item
2 Variable speichern\\genutzte Länge (ringförmig)
\item
Elemente hinten anfügen\\
oder vorne entfernen
\arrowitem
FIFO
\end{itemize}
\bigskip
\begin{itemize}
\item
vorne oder hinten\\
anfügen oder entfernen: $\mathcal{O}(1)$
\item
in der Mitte einfügen/entfernen: $\mathcal{O}(n)$
\end{itemize}
\end{minipage}\hspace*{-1.5mm}
\end{frame}
\begin{frame}[fragile]
\showsection
\showsubsection
\bigskip
\begin{minipage}[b]{6cm}
\begin{center}
"`First In -- First Out"'
\bigskip
\begin{picture}(6,4)
\thicklines
\color{structure}
\put(0.5,0){\line(1,0){5}}
\put(3.5,0){\only<1-5>{\line(0,1){1}}}
\put(4.5,0){\only<1-4>{\line(0,1){1}}}
\put(3.5,1){\only<1-4>{\line(1,0){1}}}
\put(4.0,0.5){\only<1-4>{\makebox(0,0){\lstinline{3}}}}
\put(3.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
\put(3.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
\put(2.5,0){\only<2-6>{\line(0,1){1}}}
\put(2.5,1){\only<2-5>{\line(1,0){1}}}
\put(3.0,0.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
\put(2.0,1.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
\put(2.0,1.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
\put(1.5,0){\only<3-6>{\line(0,1){1}}}
\put(1.5,1){\only<3-6>{\line(1,0){1}}}
\put(2.0,0.5){\only<3-6>{\makebox(0,0){\lstinline{137}}}}
\put(1.0,1.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
\put(1.0,1.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
\put(4.55,1.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
\put(5.00,1.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
\put(3.55,1.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
\put(4.00,1.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
\put(2.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
\put(3.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
\end{picture}
\bigskip
FIFO = Queue = Reihe
\end{center}
\end{minipage}\hfill
\begin{minipage}[b]{6cm}
\begin{center}
"`Last In -- First Out"'
\bigskip
\begin{picture}(6,4)
\thicklines
\color{structure}
\put(1.5,0){\line(1,0){3}}
\put(2.5,0){\line(0,1){1}}
\put(3.5,0){\line(0,1){1}}
\put(2.5,1){\line(1,0){1}}
\put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
\put(2.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
\put(2.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
\put(2.5,1){\only<2-5>{\line(0,1){1}}}
\put(3.5,1){\only<2-5>{\line(0,1){1}}}
\put(2.5,2){\only<2-5>{\line(1,0){1}}}
\put(3.0,1.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
\put(2.0,2.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
\put(2.0,2.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
\put(2.5,2){\only<3-4>{\line(0,1){1}}}
\put(3.5,2){\only<3-4>{\line(0,1){1}}}
\put(2.5,3){\only<3-4>{\line(1,0){1}}}
\put(3.0,2.5){\only<3-4>{\makebox(0,0){\lstinline{137}}}}
\put(2.0,3.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
\put(2.0,3.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
\put(3.55,3.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
\put(4.00,3.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
\put(3.55,2.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
\put(4.00,2.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
\put(3.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
\put(4.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
\end{picture}
\bigskip
LIFO = Stack = Stapel
\end{center}
\end{minipage}
%
% \dots
\end{frame}
\begin{frame}
\showsection
\showsubsection
\bigskip
\begin{minipage}[t]{6cm}
Array (Stack, FIFO):\\
in der Mitte einfügen
\begin{center}
\begin{picture}(6,3.8)
\thicklines
\color{structure}
\put(1.5,0){\line(1,0){3}}
\put(2.5,0){\line(0,1){3}}
\put(3.5,0){\line(0,1){3}}
\put(2.5,1){\line(1,0){1}}
\put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
\put(2.5,1){\line(1,0){1}}
\put(3.0,1.5){\makebox(0,0){\lstinline{7}}}
\put(2.5,2){\line(1,0){1}}
\put(3.0,2.5){\makebox(0,0){\lstinline{137}}}
\put(2.5,3){\line(1,0){1}}
\put(1.5,1.5){\makebox(0,0)[b]{\lstinline{push (5)}}}
\put(1.5,1.45){\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.95,-0.45);}}}
\put(3.55,2.5){\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)..controls(0.5,0.45)..(0,0.9);}}}
\put(3.55,1.5){\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)..controls(0.5,0.45)..(0,0.9);}}}
\pause
\color{red}
\put(4.1,3.0){\makebox(0,0)[l]{\textbf{1.}}}
\put(4.1,2.0){\makebox(0,0)[l]{\textbf{2.}}}
\put(1.5,1.9){\makebox(0,0)[b]{\textbf{3.}}}
\pause
\put(6.0,1.5){\makebox(0,0)[tl]{$\mathcal{O}(n)$}}
\put(5.95,1.45){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-1.3,0.4);}}}
\put(5.95,1.49){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-1.3,1.1);}}}
\end{picture}
\end{center}
\end{minipage}\pause\hfill
\begin{minipage}[t]{5cm}
In Array (Stack, FIFO) \dots
\begin{itemize}
\item
einfügen: $\mathcal{O}(n)$
\item
suchen: $\mathcal{O}(n)$
\item
geschickt suchen: $\mathcal{O}(\log n)$
\item
beim Einfügen sortieren:\\
$\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
$\mathcal{O}(n^2)$
\end{itemize}
\end{minipage}
\end{frame}
\subsection{Verkettete Listen}
\begin{frame}
\showsection
\showsubsection
\begin{tikzpicture}
\color{structure}
\node(first) at (0,0.5) {first};
\node[shape=rectangle,draw,line width=1pt](3) at (1,2) {3};
\node[shape=rectangle,draw,line width=1pt](5) at (2,1) {5};
\node[shape=rectangle,draw,line width=1pt](7) at (3,2) {7};
\node[shape=rectangle,draw,line width=1pt](137) at (5,2) {137};
\node(NULL) at (7,2) {NULL};
\draw[-latex](first)--(3);
\only<1>{\draw[-latex](3)--(7);}
\only<2>{\draw[-latex](3) to[out=0] (5);}
\only<2>{\draw[-latex](5) to[in=180] (7);}
\draw[-latex](7)--(137);
\draw[-latex](137)--(NULL);
\end{tikzpicture}
\begin{itemize}
\item
Jeder Datensatz enthält einen Zeiger auf das nächste Element.
\item
Beim letzten Element zeigt der Zeiger auf \lstinline{NULL}.
\item
Eine Variable zeigt auf das erste Element.
\item
Wenn die Liste leer ist, zeigt die Variable auf \lstinline{NULL}.
\arrowitem
(einfach) \textbf{verkettete Liste}
\end{itemize}
\end{frame}
\begin{frame}
\showsection
\showsubsection
\begin{minipage}[t]{5cm}
In Array (Stack, FIFO) \dots
\begin{itemize}
\item
in der Mitte einfügen: $\mathcal{O}(n)$
\item
wahlfreier Zugriff: $\mathcal{O}(1)$
\item
suchen: $\mathcal{O}(n)$
\item
geschickt suchen: $\mathcal{O}(\log n)$
\item
beim Einfügen sortieren:\\
$\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
$\mathcal{O}(n^2)$
\end{itemize}
\end{minipage}\hfill
\begin{minipage}[t]{6cm}
In (einfach) verkettete/r Liste \dots
\begin{itemize}
\item
in der Mitte einfügen: $\mathcal{O}(1)$
\item
wahlfreier Zugriff: $\mathcal{O}(n)$
\item
suchen: $\mathcal{O}(n)$
\item
geschickt \hspace*{-1.7cm}\tikz{\draw[red](-1.7,0)--(0,0.2);\draw[red](-1.7,0.2)--(0,0);}
suchen: {\color{red}$\mathcal{O}(n)$}
\item
beim Einfügen sortieren:
$\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
$\mathcal{O}(n^2)$
\end{itemize}
\end{minipage}
\pause
\medskip
\begin{center}
\begin{minipage}[t]{6cm}
In (ausbalancierten) Bäumen \dots
\begin{itemize}
\item
in der Mitte einfügen: $\mathcal{O}(\log n)$
\item
wahlfreier Zugriff: $\mathcal{O}(\log n)$
\item
suchen: $\mathcal{O}(\log n)$
\item
beim Einfügen sortieren:
$\mathcal{O}(n \log n)$
\end{itemize}
\end{minipage}
\end{center}
\vspace*{-1cm}
\end{frame}
\subsection{Bäume}
\begin{frame}[fragile]
\showsection
\showsubsection
\begin{minipage}[t]{5cm}
\vspace*{-6cm}
\begin{lstlisting}[gobble=6]
¡typedef struct node
{
int content;
struct node *left, *right;
} node;¿
\end{lstlisting}
\bigskip
\bigskip
\begin{onlyenv}<6->
\begin{itemize}
\item
Einfügen: rekursiv, $\mathcal{O}(\log n)$
\item
Suchen: rekursiv, $\mathcal{O}(\log n)$
\item
beim Einfügen sortieren:\\
rekursiv, $\mathcal{O}(n\log n)$
\begin{onlyenv}<7->
\smallskip
\item
{\color{red}
\emph{Worst Case\/}: $\mathcal{O}(n^2)$\\
vorher bereits sortiert}\\
\textarrow\ balancierte Bäume\\
\hspace*{2.15em}Anwendung: Datenbanken\hspace*{-2cm}
\end{onlyenv}
\end{itemize}
\vspace*{-1cm}
\end{onlyenv}
\end{minipage}\hfill
\begin{minipage}[t]{7cm}
\begin{center}
\begin{tikzpicture}
\color{structure}
\node(root) at (0,0) {\lstinline{node *root;}};
\begin{onlyenv}<2>
\node(3) at (-2,-3) {\lstinline{NULL}};
\node(137) at (2,-3) {\lstinline{NULL}};
\end{onlyenv}
\begin{onlyenv}<2->
\node[shape=rectangle,draw,line width=1pt](7) at (0,-1.5) {7};
\draw[-latex](root)--(7);
\draw[-latex](7)--(3);
\draw[-latex](7)--(137);
\end{onlyenv}
\begin{onlyenv}<3>
\node(3) at (-2,-3) {\lstinline{NULL}};
\end{onlyenv}
\begin{onlyenv}<3->
\node[shape=rectangle,draw,line width=1pt](137) at (2,-3) {137};
\node(137_left) at (1,-4.5) {\lstinline{NULL}};
\node(137_right) at (3,-4.5) {\lstinline{NULL}};
\draw[-latex](137)--(137_left);
\draw[-latex](137)--(137_right);
\end{onlyenv}
\begin{onlyenv}<4>
\node(5) at (-1,-4.5) {\lstinline{NULL}};
\end{onlyenv}
\begin{onlyenv}<4->
\node[shape=rectangle,draw,line width=1pt](3) at (-2,-3) {3};
\node(3_left) at (-3,-4.5) {\lstinline{NULL}};
\draw[-latex](3)--(3_left);
\draw[-latex](3)--(5);
\end{onlyenv}
\begin{onlyenv}<5->
\node[shape=rectangle,draw,line width=1pt](5) at (-1,-4.5) {5};
\node(5_left) at (-2,-6) {\lstinline{NULL}};
\node(5_right) at (0,-6) {\lstinline{NULL}};
\draw[-latex](5)--(5_left);
\draw[-latex](5)--(5_right);
\end{onlyenv}
\end{tikzpicture}
\end{center}
\end{minipage}
\end{frame}
\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}
\item[\textbf{6}] \textbf{Objektorientierte Programmierung}
\begin{itemize}
\vspace*{-\smallskipamount}
\item[\dots]
\item[6.3] Unions
\item[6.4] Virtuelle Methoden
\color{medgreen}
\item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
\item[6.6] Ausblick: C++
\end{itemize}
\item[\textbf{7}] \textbf{Datenstrukturen}
\begin{itemize}
\color{medgreen}
\item[7.1] Stack und FIFO
\item[7.2] Verkettete Listen
\item[7.3] Bäume
\end{itemize}
\end{itemize}
\vspace*{-1.5cm}
\begin{flushright}
\rightskip 2cm
\large
\em
\color{orange}%
Viel Erfolg\hspace*{0.25cm}\strut\\
in der Klausur!
\end{flushright}
\end{frame}
\end{document}
20200123/hp-uebung-20200123.pdf
+ 0
− 0
View file @ 922528f2
No preview for this file type
20200123/hp-uebung-20200123.tex
+ 2
− 2
View file @ 922528f2
......@@ -40,7 +40,7 @@
\exercise{Stack-Operationen}
Das folgende Programm (\gitfile{hp}{20190121}{aufgabe-1.c})
Das folgende Programm (\gitfile{hp}{20200123}{aufgabe-1.c})
implementiert einen Stapelspeicher (Stack).
Dies ist ein Array, das nur bis zu einer variablen Obergrenze (Stack-Pointer)
tatsächlich genutzt wird.
......@@ -141,7 +141,7 @@
\exercise{Iterationsfunktionen}
Wir betrachten das folgende Programm (\gitfile{hp}{20190114}{aufgabe-2.c}):
Wir betrachten das folgende Programm (\gitfile{hp}{20200123}{aufgabe-2.c}):
\begin{minipage}[t]{0.4\textwidth}
\begin{lstlisting}[gobble=6]
......
20200123/pgslides.sty 0 → 120000
+ 1
− 0
View file @ 922528f2
../20200102/pgslides.sty
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

Impressum Datenschutzerklärung