Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • 2016ws
  • 2017ws
  • 2018ws
  • 2019ws
  • 2020ws
  • 2021ws
  • 2022ws
  • 2023ws
  • 2024ws
9 results

Target

Select target project
  • pgerwinski/hp
  • bwildenhain/hp
  • Daniel.Eisi/hp
  • aahrens/hp
4 results
Select Git revision
  • 2016ws
  • 2017ws
  • 2018ws
  • master
4 results
Show changes
Showing
with 976 additions and 77 deletions
#include <stdio.h>
#define STACK_SIZE 10
int stack[STACK_SIZE];
int stack_pointer = 0;
void push (int x)
{
stack[stack_pointer++] = x;
}
int pop (void)
{
return stack[--stack_pointer];
}
int main (void)
{
push (3);
push (7);
push (137);
printf ("%d\n", pop ());
printf ("%d\n", pop ());
printf ("%d\n", pop ());
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 10
int stack[STACK_SIZE];
int stack_pointer = 0;
void push (int x)
{
if (stack_pointer < STACK_SIZE)
stack[stack_pointer++] = x;
else
{
fprintf (stderr, "stack overflow\n");
exit (1);
}
}
int pop (void)
{
if (stack_pointer > 0)
return stack[--stack_pointer];
else
{
fprintf (stderr, "stack underflow\n");
exit (1);
}
}
int main (void)
{
push (3);
push (7);
push (137);
printf ("%d\n", pop ());
printf ("%d\n", pop ());
printf ("%d\n", pop ());
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 10
int stack[STACK_SIZE];
int stack_pointer = 0;
void push (int x)
{
if (stack_pointer < STACK_SIZE)
stack[stack_pointer++] = x;
else
{
fprintf (stderr, "stack overflow\n");
exit (1);
}
}
int pop (void)
{
if (stack_pointer > 0)
return stack[--stack_pointer];
else
{
fprintf (stderr, "stack underflow\n");
exit (1);
}
}
int main (void)
{
for (int i = 0; i < 42; i++)
push (i);
printf ("%d\n", pop ());
printf ("%d\n", pop ());
printf ("%d\n", pop ());
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 10
int stack[STACK_SIZE];
int stack_pointer = 0;
void push (int x)
{
if (stack_pointer < STACK_SIZE)
stack[stack_pointer++] = x;
else
{
fprintf (stderr, "stack overflow\n");
exit (1);
}
}
int pop (void)
{
if (stack_pointer > 0)
return stack[--stack_pointer];
else
{
fprintf (stderr, "stack underflow\n");
exit (1);
}
}
int main (void)
{
push (3);
push (7);
push (137);
for (int i = 0; i < 42; i++)
printf ("%d\n", pop ());
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
int main (void)
{
node *root = malloc (sizeof (node));
root->content = 7;
root->left = NULL;
root->right = NULL;
printf ("%d\n", root->content);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
int main (void)
{
node *root = malloc (sizeof (node));
root->content = 7;
root->left = NULL;
root->right = NULL;
node *new = malloc (sizeof (node));
new->content = 137;
new->left = NULL;
new->right = NULL;
if (root->content < new->content)
root->right = new;
else
root->left = new;
printf ("%d\n", root->content);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
int main (void)
{
node *root = malloc (sizeof (node));
root->content = 7;
root->left = NULL;
root->right = NULL;
node *new = malloc (sizeof (node));
new->content = 137;
new->left = NULL;
new->right = NULL;
if (root->content < new->content)
root->right = new;
else
root->left = new;
printf ("%d\n", root->content);
printf ("%d\n", root->right->content);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
void output (node *p)
{
if (p)
{
output (p->left);
printf ("%d\n", p->content);
output (p->right);
}
}
int main (void)
{
node *root = malloc (sizeof (node));
root->content = 7;
root->left = NULL;
root->right = NULL;
node *new = malloc (sizeof (node));
new->content = 137;
new->left = NULL;
new->right = NULL;
if (root->content < new->content)
root->right = new;
else
root->left = new;
output (root);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
void output (node *p)
{
if (p)
{
output (p->left);
printf ("%d\n", p->content);
output (p->right);
}
}
void insert (node *p, node *new)
{
if (p)
{
if (p->content < new->content)
insert (p->right, new);
else
insert (p->left, new);
}
else
{
new->left = NULL;
new->right = NULL;
}
}
int main (void)
{
node *root = NULL;
node *new = malloc (sizeof (node));
new->content = 7;
insert (root, new);
new = malloc (sizeof (node));
new->content = 137;
insert (root, new);
output (root);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
void output (node *p)
{
if (p)
{
output (p->left);
printf ("%d\n", p->content);
output (p->right);
}
}
void insert (node *p, node *new)
{
if (p)
{
if (p->content < new->content)
insert (p->right, new);
else
insert (p->left, new);
}
else
{
p = new;
new->left = NULL;
new->right = NULL;
}
}
int main (void)
{
node *root = NULL;
node *new = malloc (sizeof (node));
new->content = 7;
insert (root, new);
new = malloc (sizeof (node));
new->content = 137;
insert (root, new);
output (root);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
void output (node *p)
{
if (p)
{
output (p->left);
printf ("%d\n", p->content);
output (p->right);
}
}
void insert (node **p, node *new)
{
if (*p)
{
if ((*p)->content < new->content)
insert (&(*p)->right, new);
else
insert (&(*p)->left, new);
}
else
{
*p = new;
new->left = NULL;
new->right = NULL;
}
}
int main (void)
{
node *root = NULL;
node *new = malloc (sizeof (node));
new->content = 7;
insert (&root, new);
new = malloc (sizeof (node));
new->content = 137;
insert (&root, new);
output (root);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int content;
struct node *left, *right;
} node;
void output (node *p)
{
if (p)
{
output (p->left);
printf ("%d\n", p->content);
output (p->right);
}
}
void insert (node **p, int content)
{
if (*p)
{
if ((*p)->content < content)
insert (&(*p)->right, content);
else
insert (&(*p)->left, content);
}
else
{
node *new = malloc (sizeof (node));
new->content = content;
*p = new;
new->left = NULL;
new->right = NULL;
}
}
int main (void)
{
node *root = NULL;
insert (&root, 7);
insert (&root, 137);
insert (&root, 3);
insert (&root, 5);
output (root);
return 0;
}
#include <stdio.h>
#include <string.h>
void insert_into_string (char src, char *target, int pos)
{
int len = strlen (target);
for (int i = pos; i < len; i++)
{
target[i+1] = target[i];
printf ("i = %d, target = \"%s\"\n", i, target);
}
target[pos] = src;
printf ("src eingefügt, target = \"%s\"\n", target);
}
int main (void)
{
char test[100] = "Hochshule Bochum";
insert_into_string ('c', test, 5);
printf ("%s\n", test);
return 0;
}
Themen, 30.01.2025, 11:19:15
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Seiteneffekte
- Zeiger, Strings, Arrays
- Hardwarenahe Programmierung: Bit-Manipulation
- Hardwarenahe Programmierung: Daten im Speicher:
Aufteilung auf Speicherzellen, Endianness, Alignment
- Objektorientierte Programmierung, Zeiger auf Funktionen
- Algorithmen, Landau-Symbole
Beispiele für Seiteneffekte
- Aufgabe 6.1: s[i++]
Beispiele für Zeiger, Strings, Arrays:
- Aufgabe 2.3, 3.1, 3.2, 6.1, 11.4
Beispiele für Bit-Manipulation:
- Klausur von 2016, Aufgabe 4: XBM-Dateien
- Aufgaben zu Mikrocontrollern: 5.2, 5.3, 9.1
- Aufgabe 8.2, 11.3
Beispiele für Daten im Speicher:
- Aufgabe 8.1, 9.3, 10.1
Beispiele für objektorientierte Programmierung:
- Callbacks: Aufgabe 6.2
- Aufgabe 10.3
- Klausur von 2016, Aufgabe 3
Beispiele für Algorithmen, Landau-Symbole:
- Aufgabe 9.2, 10.2
- Klausur von 2016, Aufgabe 1(d)
Nicht relevant:
- Aufgabe 5.1 (Nicht als Aufgabe. Daß Sie das können, setze ich voraus.;-)
- };->== (Gnu)
- verkettete Listen, Bäume
- Rechnertechnik: Assembler, Redcode usw.
- bestenfalls rudimentär: make, Präprozessor
Probeklausur vom 29.1.2016, 30.01.2025, 11:46:51
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Aufgabe 1:
(a)
- *Nicht* den Quelltext Zeile für Zeile beschreiben.
- Dies ist nicht der Bubble-Sort, sondern der Selection-Sort.
Vorsicht: Nicht jeder Quelltext, der so aussieht, ist
überhaupt ein funktionierender Sortier-Algorithmus!
- Beispiel für eine Erklärung der Funktion:
Die Funktion geht in einer äußeren Schleife einen String durch.
Für jeden Buchstaben im String geht die Funktion in einer
inneren Schleife alle rechts davon stehenden Zeichen durch
und sucht nach einem, das kleiner ist. In diesem Fall tauscht
es das kleinere Zeichen nach vorne, also an die Stelle, an der
wir gerade mit der äußeren Schleife sind. Nachdem die äußere
Schleife durchgelaufen ist, ist der String gemäß der
ASCII-Reihenfolge sortiert (Selection-Sort).
Dies ist in Eile ("unter Klausur-Bedingungen") heruntergeschrieben.
Mit mehr Zeit könnte man das natürlich besser und kürzer formulieren.
Hierfür gäbe es aber volle Punktzahl.
(b) ASCII-Reihenfolge: Groß- vor Kleinbuchstaben
(c) Der String hat dann keinen Null-Terminator.
printf() wird dann über den String hinaus aus dem Speicher lesen.
Dies kann zu einem Absturz führen.
(d) O(n²), weil zwei geschachtelte Schleifen
(e) („Quicksort“ log n)
In einem alphabetisch sortierten Array kann man die Suche in der Mitte
beginnen und sich durch Halbieren der Intervalle an die gesuchte Position
herantasten. Wegen des fortwährenden Halbierens geschieht dies in O(log n).
--> Damit verkürzt sich die innere Schleife von O(n) auf O(log n).
Zusammen mit der äußeren Schleife haben wir dann O(n log n).
Zusammen mit Rekursion ergibt dies den Merge-Sort.
Alternative: In der inneren Schleife feststellen, ob das Array vielleicht
bereits sortiert ist. Dies führt auf den Bubble-Sort.
Alternative: Das Wort "Quicksort" hinschreiben. --> Teilpunkte
Alternative: Das Wort "Quicksort" hinschreiben und erklären. --> volle Punktzahl
Alternative: Quicksort implementieren --> volle Punktzahl
(z.B.: Beispiel-Programm qsort-3.c so modifizieren, daß es die Buchstaben
in einem String sortiert anstelle eines Arrays von Strings.)
Aufgabe 2:
(a) Funktion output() erklären
Die Funktion gibt die in dem Array enthaltenen Integer-Werte aus.
Das Array wird übergeben als ein Zeiger auf vorzeichenlose 16-Bit-Variablen.
Das Ende des Arrays wird durch den Zahlenwert 0 erkannt.
(b) Begründen Sie den Unterschied zwischen der ersten (2 3 5 7 11 13 17)
und der zweiten Zeile (3 5 7 11 13 17) der Ausgabe des Programms. (2 Punkte)
Ein Pointer auf das Array zeigt immer auf das erste Zeichen im Array.
Wenn man den Pointer um 1 erhöht, zeigt er auf das zweite Zeichen,
(c) Erklären Sie die beim Compilieren auftretenden Warnungen
und die dritte Zeile (2 3 5 7 11 13 17) der Ausgabe des Programms. (3 Punkte)
Die Funktion erwartet einen Zeiger auf uint16_t,
bekommt aber einen Zeiger auf char.
--> Warnungen erklärt.
Der Zeiger zeigt aber auf die korrekte Speicherzelle,
daher funktioniert die Ausgabe des Arrays normal.
(d) Erklären Sie die vierte Zeile (768 1280 1792 2816 3328 4352) der Ausgabe des Programms.
Sie dürfen einen Little-Endian-Rechner voraussetzen. (4 Punkte)
zeigt auf speicheradresse 0x01 also nur 1 byte verschoben
Bildchen malen: Bytes im Speicher
16-Bit-Zahlen: | 2 | 3 | 5 | 7 | 11 | 13 | 17 | 0 |
8-Bit-Speicherzellen: | 2 | 0 | 3 | 0 | 5 | 0 | 7 | 0 | 11 | 0 | 13 | 0 | 17 | 0 | 0 | 0 |
^
Hier setze ich Little-Endian voraus. Bei Big-Endian wäre es: | 0 | 2 | 0 | 3 | ...
Zeiger p2 zeigt zunächst auf die erste Speicherzelle (mit der 2).
| 2 | 0 | 3 | 0 | 5 | 0 | 7 | 0 | 11 | 0 | 13 | 0 | 17 | 0 | 0 | 0 |
^
p2
Nach dem p2++ zeigt p2 auf die zweite Speicherzelle (mit einer 0).
| 2 | 0 | 3 | 0 | 5 | 0 | 7 | 0 | 11 | 0 | 13 | 0 | 17 | 0 | 0 | 0 |
^
p2
Nun geben wir die dort befindliche 16-Bit-Zahl aus: | 0 | 3 |
hexadezimal: | 0x00 | 0x03 |
In Little-Endian ist dies: 0x0300, also 768.
(In Big-Endian wäre dies: 0x0003, also 3.)
Und so weiter.
char = 8-Bit-Zahl, z.B.: | 2 | 1 Speicherzelle
uint16_t = 16-Bit-Zahl, z.B.: | 2 | 0 | (Little-Endian) 2 Speicherzellen
bzw. | 0 | 2 | (Big-Endian)
Typischerweise:
char = int8_t, von -128 bis +127
unsigned char = uint8_t, von 0 bis 255
int = int32_t
unsigned = uint32_t
long = int64_t auf 64-Bit-Rechner, int32_t auf 32-Bit-Rechner
unsigned long = uint64_t bzw. uint32_t
long long = int64_t
unsigned long long = uint64_t
würde die richtige ausgabe folgen wenn man 2 mal p2++ rechnen würde
--> Dann hätten wir wieder die Situation aus der zweiten Zeile.
Dann würde p2 auf die Speicherzelle mit der 3 zeigen,
und output() würde das Array ab der 3 ausgeben.
Aufgabe 3:
(a) Zeiger auf Funktion, die ein int zurückliefert
und zwei int-Parameter a und b erwartet.
Zweck:
- erzeugt einen dynamischen aufruf von funktionen
- virtuelle Methode
? "Callback"
- In jedem operation-Objekt ist gespeichert,
welche Methode aufgerufen werden soll,
um das Rechenergebnis der Operation wirklich auszurechnen.
(Der vierte Zeiger im Array ist auf NULL gesetzt,
um das Ende des Arrays zu kennzeichnen.)
Hinter der Deklaration des operation-Objekts dürfen weitere
Klassen-Deklarationen folgen, weitere typedefs.
Insofern könnte man auch hier ein "[...]" ergänzen.
(b) Konstruktoren und Methoden schreiben.
--> siehe: loesung-3b.c
Bei den Konstruktoren verwendet man sinnvollerweise malloc(),
siehe dazu: 20250109/objects-08.c und Nachfolger.
Besonders ordentlich ist es, den Speicher nach Gebrauch
wieder freizugeben. Bei Programmen, die längere Zeit laufen
sollen, ist dies sogar absolut notwendig.
(c) Dann fehlt die Ende-Kennung des Arrays,
und die Schleife liest über das Array hinaus.
Sofern dahinter nicht ein Null-Zeiger liegt (auf 64-Bit-Rechner:
8 aufeinanderfolgende 8-Bit-Speicherzellen mit dem Wert 0),
führt dies mit hoher Wahrscheinlichkeit zu einem Speicherzugriffsfehler,
da der Struktur ein Zeiger auf eine Funktion entnommen wird,
die wir anschließend aufrufen.
kürzer: Dies führt sehr wahrscheinlich zu einem Absturz.
Aufgabe 4:
Siehe loesung-4.c.
Weitere Lösungen durch Sprachmodelle: Siehe loesung-4-*.c.
Zu loesung-4.c:
int bytes = (aufgabe_4_width + 7) / 8;
bedeutet: auf ganze Bytes auffüllen
durch 8 teilen, immer aufrunden. (Nur "/" rundet immer ab.)
Die Bedingung
if (byte & (1 << (x % 8)))
bedeutet: Ist Bit Nr. (x % 8) in dem Byte gesetzt?
Das "&" steht für eine bitweise Und-Operation:
byte = 0x14 = 0b00010100
bitweise Und-Verknüpfung mit: 1 << 2 = 0b100 = 0b00000100
Ergebnis: 0b00010100
& 0b00000100
----------
0b00000100
Dies ist != 0, also gehen wir in das "if" hinein.
Das Pixel ist gesetzt; wir geben einen Stern aus.
(Es ist "<<" wegen "LSB first". Bei "MSB first" wäre es: "0x80 >> (x % 8)".)
#include <stdio.h>
#include <string.h>
void insert_into_string (char src, char *target, int pos)
{
int len = strlen (target);
for (int i = len - 1; i >= pos; i--)
{
target[i+1] = target[i];
printf ("i = %d, target = \"%s\"\n", i, target);
}
target[pos] = src;
printf ("src eingefügt, target = \"%s\"\n", target);
}
int main (void)
{
char test[100] = "Hochshule Bochum";
insert_into_string ('c', test, 5);
printf ("%s\n", test);
return 0;
}
Hardwarenahe Programmierung Hardwarenahe Programmierung
=========================== ===========================
Lehrveranstaltung im Wintersemester 2019/20 Lehrveranstaltung im Wintersemester 2024/25
Hochschule Bochum, Campus Velbert/Heiligenhaus Hochschule Bochum, Campus Velbert/Heiligenhaus
Prof. Dr. rer. nat. Peter Gerwinski Prof. Dr. rer. nat. Peter Gerwinski
Copyright © 2012–2019 Peter Gerwinski Copyright © 2012–2024 Peter Gerwinski
**Diese Lehrmaterialien sind freie Software.** **Diese Lehrmaterialien sind freie Software.**
Sie dürfen diese gemäß den jeweils angegebenen Lizenzen Sie dürfen diese gemäß den jeweils angegebenen Lizenzen
([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/CC-BY-SA-3.0), ([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/CC-BY-SA-3.0),
[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/GNU-GPL-3), [GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/GNU-GPL-3),
[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/BSD-MODIFIED)) [modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/BSD-MODIFIED))
studieren, kopieren, modifizieren und/oder weitergeben. studieren, kopieren, modifizieren und/oder weitergeben.
Für Details siehe [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/README). Für Details siehe [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/README).
Vortragsfolien und Beispiele: Vortragsfolien und Beispiele:
----------------------------- -----------------------------
* [10.10.2019: Einführung, Einführung in C (bis Schleifen)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191010/hp-20191010.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191010/) * [10.10.2024: Einführung, Einführung in C](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241010/hp-20241010.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241010/)
* [17.10.2019: Einführung in C: Seiteneffekte, Funktionen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191017/hp-20191017.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191017/) * [17.10.2024: Einführung in C: Seiteneffekte](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241017/hp-20241017.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241017/)
* [24.10.2019: Einführung in C: Zeiger, Arrays und Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191024/hp-20191024.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191024/) * [31.10.2024: Einführung in C: Funktionen, Zeiger, Arrays und Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241031/hp-20241031.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241031/)
* [31.10.2019: Einführung in C: Arrays und Strings und Zeichen, Strukturen, Dateien und Fehlerbehandlung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191031/hp-20191031.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191031/) * [07.11.2024: Einführung in C: Strukturen, Dateien und Fehlerbehandlung, Parameter des Hauptprogramms, String-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241107/hp-20241107.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241107/)
* [07.11.2019: Parameter des Hauptprogramms, String-Operationen, Bit-Operationen, I/O-Ports](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191107/hp-20191107.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191107/) * [14.11.2024: Bibliotheken: Präprozessor](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241114/hp-20241114.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241114/)
* [14.11.2019: Bit-Operationen, I/O-Ports](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191114/hp-20191114.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191114/) * [21.11.2024: Bibliotheken einbinden; Hardwarenahe Programmierung: I/O-Ports](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241121/hp-20241121.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241121/)
* [21.11.2019: Interrupts, volatile-Variable, Bibliotheken: Einführung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191121/hp-20191121.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191121/) * [28.11.2024: Bibliotheken verwenden, Callbacks, make; Hardwarenahe Programmierung: I/O-Ports](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241128/hp-20241128.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241128/)
* [28.11.2019: Präprozessor, Bibliotheken](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191128/hp-20191128.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191128/) * [05.12.2024: Hardwarenahe Programmierung: Interrupts, volatile-Variable](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241205/hp-20241205.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241205/)
* [05.12.2019: Bibliotheken, Differentialgleichungen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191205/hp-20191205.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191205/) * [12.12.2024: Byte-Reihenfolge, Binärdarstellung negativer Zahlen, Speicherausrichtung, Algorithmen: Differentialgleichungen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241212/hp-20241212.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241212/)
* [12.12.2019: make, Byte-Reihenfolge - Endianness](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191212/hp-20191212.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20191212/) * [19.12.2024: Darstellung von Gleitkommazahlen, Rekursion, Aufwandsabschätzungen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241219/hp-20241219.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20241219/)
* [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/) * [09.01.2025: Objektorientierte Programmierung: Einführung, Unions](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250109/hp-20250109.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20250109/)
* [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/) * [16.01.2025: Objektorientierte Programmierung: virtuelle Methoden, Beispiel, C++; Datenstrukturen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250116/hp-20250116.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/20250116/)
* [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/) * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/hp-slides-2024ws.pdf)
* [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/)
* [23.01.2020: Objektorientierte Programmierung, Datenstrukturen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200123/hp-20200123.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20200123/)
* [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/hp-slides-2019ws.pdf)
Übungsaufgaben: Übungsaufgaben:
--------------- ---------------
* [10.10.2019: Hello-World-Programme, Schaltjahr ermitteln, Maximum berechnen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191010/hp-uebung-20191010.pdf) * [10.10.2024: 0: Hello-World-Programme, Schaltjahr ermitteln, Maximum berechnen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241010/hp-uebung-20241010.pdf)
* [17.10.2019: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191017/hp-uebung-20191017.pdf) * [17.10.2024: 1: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241017/hp-uebung-20241017.pdf)
* [24.10.2019: Seltsame Programme, Kalender-Berechnung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191024/hp-uebung-20191024.pdf) * [31.10.2024: 2: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241031/hp-uebung-20241031.pdf)
* [31.10.2019: Strings, Programm analysieren, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191031/hp-uebung-20191031.pdf) * [07.11.2024: 3: Arrays mit Zahlen, Einfügen in Strings, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241107/hp-uebung-20241107.pdf)
* [07.11.2019: Arrays mit Zahlen, Datum-Bibliothek](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191107/hp-uebung-20191107.pdf) * [14.11.2024: 4: Text-Grafik-Bibliothek, Datum-Bibliothek, Ausgabe von Hexadezimal-Zahlen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241114/hp-uebung-20241114.pdf)
* [14.11.2019: Ausgabe von Hexadezimalzahlen, Einfügen in Strings, Länge von Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191114/hp-uebung-20191114.pdf) * [21.11.2024: 5: Zahlensysteme, Mikrocontroller, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241121/hp-uebung-20241121.pdf)
* [21.11.2019: Zahlensysteme, Mikrocontroller](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191121/hp-uebung-20191121.pdf) * [28.11.2024: 6: Länge von Strings, Iterationsfunktionen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241128/hp-uebung-20241128.pdf)
* [28.11.2019: Datum-Bibliothek, Text-Grafik-Bibliothek, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191128/hp-uebung-20191128.pdf) * [05.12.2024: 7: Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241205/hp-uebung-20241205.pdf)
* [05.12.2019: Löschen aus Strings, Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191205/hp-uebung-20191205.pdf) * [12.12.2024: 8: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Kondensator](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241212/hp-uebung-20241212.pdf)
* [12.12.2019: Kondensator, hüpfender Ball](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191212/hp-uebung-20191212.pdf) * [19.12.2024: 9: PBM-Grafik, Fakultät, Speicherformate von Zahlen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241219/hp-uebung-20241219.pdf)
* [19.12.2019: Trickprogrammierung, Thermometer-Baustein an I²C-Bus](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191219/hp-uebung-20191219.pdf) * [09.01.2025: 10: Personen-Datenbank, Einfügen in Strings (Ergänzung), objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250109/hp-uebung-20250109.pdf)
* [09.01.2020: Speicherformate von Zahlen, Zeigerarithmetik, Personen-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200109/hp-uebung-20200109.pdf) * [16.01.2025: 11: Einfach und doppelt verkettete Listen, ternärer Baum, dynamisches Bit-Array, Stack-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250116/hp-uebung-20250116.pdf)
* [16.01.2020: Fakultät, Länge von Strings (Neuauflage), objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200116/hp-uebung-20200116.pdf)
* [23.01.2020: Stack-Operationen, Iteratorfunktionen, dynamisches Bit-Array](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200123/hp-uebung-20200123.pdf)
Musterlösungen: Musterlösungen:
--------------- ---------------
* [17.10.2019: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191017/hp-musterloesung-20191017.pdf) * [17.10.2024: 1: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241017/hp-musterloesung-20241017.pdf)
* [24.10.2019: Seltsame Programme, Kalender-Berechnung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191024/hp-musterloesung-20191024.pdf) * [31.10.2024: 2: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241031/hp-musterloesung-20241031.pdf)
* [31.10.2019: Strings, Programm analysieren, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191031/hp-musterloesung-20191031.pdf) * [07.11.2024: 3: Arrays mit Zahlen, Einfügen in Strings, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241107/hp-musterloesung-20241107.pdf)
* [07.11.2019: Arrays mit Zahlen, Datum-Bibliothek](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191107/hp-musterloesung-20191107.pdf) * [14.11.2024: 4: Text-Grafik-Bibliothek, Datum-Bibliothek, Ausgabe von Hexadezimal-Zahlen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241114/hp-musterloesung-20241114.pdf)
* [14.11.2019: Ausgabe von Hexadezimalzahlen, Einfügen in Strings, Länge von Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191114/hp-musterloesung-20191114.pdf) * [21.11.2024: 5: Zahlensysteme, Mikrocontroller, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241121/hp-musterloesung-20241121.pdf)
* [21.11.2019: Zahlensysteme, Mikrocontroller](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191121/hp-musterloesung-20191121.pdf) * [28.11.2024: 6: Länge von Strings, Iterationsfunktionen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241128/hp-musterloesung-20241128.pdf)
* [28.11.2019: Datum-Bibliothek, Text-Grafik-Bibliothek, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191128/hp-musterloesung-20191128.pdf) * [05.12.2024: 7: Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241205/hp-musterloesung-20241205.pdf)
* [23.01.2020: Datum-Bibliothek, Text-Grafik-Bibliothek, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200123/hp-musterloesung-20200123.pdf) * [12.12.2024: 8: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Kondensator](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241212/hp-musterloesung-20241212.pdf)
* [19.12.2024: 9: PBM-Grafik, Fakultät, Speicherformate von Zahlen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241219/hp-musterloesung-20241219.pdf)
* [09.01.2025: 10: Personen-Datenbank, Einfügen in Strings (Ergänzung), objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250109/hp-musterloesung-20250109.pdf)
* [16.01.2025: 11: Einfach und doppelt verkettete Listen, ternärer Baum, dynamisches Bit-Array, Stack-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250116/hp-musterloesung-20250116.pdf)
Tafelbilder: Tafelbilder:
------------ ------------
* [07.11.2019: Beispiele für Bit-Manipulation](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191107/photo-20191107-172458.jpg) * [05.12.2024: Schaltzeichen: „Widerstand ist zwecklos!“](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241205/pull-up-pull-down-0-widerstand-ist-zwecklos.png)
* [14.11.2019: Logische und bitweise Und-Verknüpfung (rechts), einzelnes Bit auf 1 setzen (links)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191114/photo-20191114-172339.jpg) * [05.12.2024: Ohne Pull-Up- oder Pull-Down-Widerstand ist der Schaltzustand bei geöffnetem Taster undefiniert.](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241205/pull-up-pull-down-1-ohne-pull-up-pull-down.png)
* [14.11.2019: Einzelnes Bit auf 1 (rechts) bzw. auf 0 (links) setzen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191114/photo-20191114-172358.jpg) * [05.12.2024: Pull-Down-, Pull-Up- und interner Pull-Up-Widerstand](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241205/pull-up-pull-down-2-mit-pull-up-pull-down.png)
* [14.11.2019: Einzelnes Bit auf 0 setzen (rechts) bzw. umklappen (Mitte) bzw. abfragen (links)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191114/photo-20191114-172434.jpg) * [12.12.2024: Differentialgleichung des mathematischen Pendels](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241212/pendel-1-differentialgleichung.png)
* [05.12.2019: Schräger Wurf](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191205/photo-20191205-171706.jpg) * [12.12.2024: Analytische Lösung Differentialgleichung des mathematischen Pendels mit Kleinwinkelnäherung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241212/pendel-2-analytische-loesung-mit-kleinwinkelnaeherung.png)
* [19.12.2019: Interpretation von Bytes im Speicher als Zahlenwert](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191219/photo-20191219-172103.jpg)
* [19.12.2019: Bildschirmspeicher als Beispiel für Speicherausrichting (Alignment)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191219/photo-20191219-172146.jpg)
* [02.01.2020: Quantencomputer: physikalische Realisierung von Qubits](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200102/photo-20200102-174206.jpg)
Praktikumsunterlagen: Praktikumsunterlagen:
--------------------- ---------------------
* [Versuch 1, 17. und 31.10.2019: RSA-Verschlüsselung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191010/hp-2019ws-p1.pdf) * [Versuch 1: RSA-Verschlüsselung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241017/hp-2024ws-p1.pdf)
* [Versuch 2, 14. und 21.11.2019: Druckknopfampel](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191107/hp-2019ws-p2.pdf) * [Versuch 2: Druckknopfampel](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241121/hp-2024ws-p2.pdf)
* [Versuch 3, 12. und 19.12.2019: Weltraum-Simulation](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20191212/hp-2019ws-p3.pdf) * [Versuch 3: Weltraum-Simulation](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20241212/hp-2024ws-p3.pdf)
* [Versuch 4, 16. und 23.1.2020: Objektorientiertes Grafik-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20200109/hp-2019ws-p4.pdf) * [Versuch 4: Objektorientiertes Grafik-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/20250109/hp-2024ws-p4.pdf)
Alte Klausuren: Alte Klausuren:
--------------- ---------------
* [Wintersemester 2015/16](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/exams/20160129/ainf-klausur-20160129.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/exams/20160129/) * [Wintersemester 2015/16](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/exams/20160129/ainf-klausur-20160129.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/exams/20160129/)
* [Wintersemester 2016/17](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/exams/20170206/hp-klausur-20170206.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/exams/20170206/) * [Wintersemester 2016/17](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/exams/20170206/hp-klausur-20170206.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/exams/20170206/)
* [Wintersemester 2017/18](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/exams/20180213/hp-klausur-20180213.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/exams/20180213/) * [Wintersemester 2017/18](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/exams/20180213/hp-klausur-20180213.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/exams/20180213/)
Skript: Skript:
------- -------
* [Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/script/hp-2019ws.pdf) * [Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/script/hp-2024ws.pdf)
Original-Materialien einschließlich Beispiel-Programme und LaTeX-Quelltexte: Original-Materialien einschließlich Beispiel-Programme und LaTeX-Quelltexte:
---------------------------------------------------------------------------- ----------------------------------------------------------------------------
* [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/common) * [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/common)
* [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/script) * [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/script)
* [201????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master) * [202????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws)
* [branch 2018ws – vollständige Lehrmaterialien vom Wintersemester 2018/19](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2018ws) * [branch 2023ws – vollständige Lehrmaterialien vom Wintersemester 2022/23](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws)
Low-Level Programming Low-Level Programming
===================== =====================
Course in winter semester 2019–20 Course in winter semester 2024-25
Bochum University of Applied Sciences, Campus Velbert/Heiligenhaus Bochum University of Applied Sciences, Campus Velbert/Heiligenhaus
Prof. Dr. rer. nat. Peter Gerwinski Prof. Dr. rer. nat. Peter Gerwinski
Copyright © 2012–2019 Peter Gerwinski Copyright © 2012–2024 Peter Gerwinski
**These teaching materials are Free Software.** **These teaching materials are Free Software.**
You may study, copy, modify, and/or distribute them You may study, copy, modify, and/or distribute them
according to their respective licences according to their respective licences
([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/CC-BY-SA-3.0), ([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/CC-BY-SA-3.0),
[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/GNU-GPL-3), [GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/GNU-GPL-3),
[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/BSD-MODIFIED)). [modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/BSD-MODIFIED)).
See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/README) for details. See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/common/README) for details.
* [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/common) * [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/common)
* [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/script) * [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws/script)
* [201????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master) * [202????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2024ws)
* [hp-slides-2019ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/hp-slides-2019ws.pdf) * [hp-slides-2024ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2024ws/hp-slides-2024ws.pdf)
* [branch 2018ws – complete teaching materials from winter semester 2018–19](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2018ws) * [branch 2023ws – complete teaching materials from winter semester 2022-23](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws)
File moved
...@@ -34,6 +34,7 @@ ...@@ -34,6 +34,7 @@
\usepackage{xcolor} \usepackage{xcolor}
\usepackage{enumerate} \usepackage{enumerate}
\usepackage{ifthen} \usepackage{ifthen}
\usepackage{substr}
%% Repair kerning: Automatically insert "\kern{-0.15em}" between "//" % (in URLs). %% Repair kerning: Automatically insert "\kern{-0.15em}" between "//" % (in URLs).
%% PG20151206: This seems unnecessary here. Maybe due to \sf? %% PG20151206: This seems unnecessary here. Maybe due to \sf?
...@@ -94,15 +95,18 @@ ...@@ -94,15 +95,18 @@
\newcommand{\textarrow}{{\boldmath $\longrightarrow$}} \newcommand{\textarrow}{{\boldmath $\longrightarrow$}}
\newcommand{\arrowitem}{\item[\textarrow]} \newcommand{\arrowitem}{\item[\textarrow]}
\newcommand{\newterm}[1]{\emph{\color{darkgreen}#1}} \newcommand{\newterm}[1]{\emph{\color{darkgreen}#1}}
\newcommand{\strong}[1]{\textbf{#1}}
\newcounter{exercise} \newcounter{exercise}
\newcommand{\exercise}[1]{\addtocounter{exercise}{1}\subsection*{Aufgabe \arabic{exercise}: #1}} \newcommand{\exercise}[1]{\addtocounter{exercise}{1}\subsection*{Aufgabe \arabic{exercise}: #1}}
\newcommand{\solution}{\subsubsection*{Lösung}} \newcommand{\solution}{\subsubsection*{Lösung}}
\newif\ifwithsolutions
\IfSubStringInString{\detokenize{musterloesung}}{\jobname}{\withsolutionstrue}{\withsolutionsfalse}
\newcounter{points} \newcounter{points}
\newcommand{\points}[1]{\ifthenelse{#1=1}{(1 Punkt)}{(#1 Punkte)}\addtocounter{points}{#1}} \newcommand{\points}[1]{\ifthenelse{#1=1}{(1 Punkt)}{(#1 Punkte)}\addtocounter{points}{#1}}
\newcommand{\gitfile}[3]{\href{https://gitlab.cvh-server.de/pgerwinski/#1/raw/master/#2/#3}{\file{#3}}} \newcommand{\gitfile}[3]{\href{https://gitlab.cvh-server.de/pgerwinski/#1/raw/#2/#3}{\file{#3}}}
\usepackage{listings} \usepackage{listings}
\lstset{basicstyle=\color{blendedblue}, \lstset{basicstyle=\color{blendedblue},
......
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
char symbol;
int (*calculate) (int a, int b);
}
operation;
operation *new_operation (void)
{
operation *op = malloc (sizeof (operation));
op->symbol = '?';
op->calculate = NULL;
return op;
}
/* Virtuelle Methoden */
int calculate_plus (int a, int b)
{
return a + b;
}
int calculate_minus (int a, int b)
{
return a - b;
}
int calculate_times (int a, int b)
{
return a * b;
}
/* Konstruktoren */
operation *new_plus ()
{
operation *op = malloc (sizeof (operation));
op->symbol = '+';
op->calculate = calculate_plus;
return op;
}
operation *new_minus ()
{
operation *op = malloc (sizeof (operation));
op->symbol = '-';
op->calculate = calculate_minus;
return op;
}
operation *new_times ()
{
operation *op = malloc (sizeof (operation));
op->symbol = '*';
op->calculate = calculate_times;
return op;
}
/* Besonders ordentlich: Speicher wieder freigeben - Destruktor */
void delete_operation (operation *op)
{
if (op)
free (op);
}
int main (void)
{
operation *op[4];
op[0] = new_plus ();
op[1] = new_minus ();
op[2] = new_times ();
op[3] = NULL;
for (int i = 0; op[i]; i++)
printf ("2 %c 3 = %d\n", op[i]->symbol, op[i]->calculate (2, 3));
for (int i = 0; op[i]; i++)
delete_operation (op[i]);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
char symbol;
int (*calculate) (int a, int b);
}
operation;
operation *new_operation (void)
{
operation *op = malloc (sizeof (operation));
op->symbol = '?';
op->calculate = NULL;
return op;
}
/* Virtuelle Methoden */
int calculate_plus (int a, int b)
{
return a + b;
}
int calculate_minus (int a, int b)
{
return a - b;
}
int calculate_times (int a, int b)
{
return a * b;
}
/* Konstruktoren */
operation *new_plus ()
{
operation *op = malloc (sizeof (operation));
op->symbol = '+';
op->calculate = calculate_plus;
return op;
}
operation *new_minus ()
{
operation *op = malloc (sizeof (operation));
op->symbol = '-';
op->calculate = calculate_minus;
return op;
}
operation *new_times ()
{
operation *op = malloc (sizeof (operation));
op->symbol = '*';
op->calculate = calculate_times;
return op;
}
int main (void)
{
operation *op[4];
op[0] = new_plus ();
op[1] = new_minus ();
op[2] = new_times ();
op[3] = NULL;
for (int i = 0; op[i]; i++)
printf ("2 %c 3 = %d\n", op[i]->symbol, op[i]->calculate (2, 3));
return 0;
}