diff --git a/20210204/loesung-3-1.c b/20210204/loesung-3-1.c new file mode 100644 index 0000000000000000000000000000000000000000..11ad08a28a2c16e645e4b55c1b0f4556246fd692 --- /dev/null +++ b/20210204/loesung-3-1.c @@ -0,0 +1,50 @@ +#include <stdio.h> +#include <stdint.h> + +uint8_t buffer = 0; + +void bit_array_set (int i, int value) +{ + uint8_t mask = 1 << i; + if (value) + buffer |= mask; + else + buffer &= ~mask; +} + +void bit_array_flip (int i) +{ + uint8_t mask = 1 << i; + buffer ^= mask; +} + +int bit_array_get (int i) +{ + uint8_t mask = 1 << i; + if (buffer & mask) + return 1; + else + return 0; +} + +void output (void) +{ + for (int i = 0; i < 8; i++) + { + if (i % 4 == 0) + printf (" "); + printf ("%d", bit_array_get (i)); + } + printf ("\n"); +} + +int main (void) +{ + output (); + bit_array_set (2, 1); + output (); + bit_array_flip (7); + output (); + bit_array_set (2, 0); + output (); +} diff --git a/20210204/loesung-3-2.c b/20210204/loesung-3-2.c new file mode 100644 index 0000000000000000000000000000000000000000..e510904b033cf7d55737cee55ad08ecb9510f324 --- /dev/null +++ b/20210204/loesung-3-2.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <stdint.h> + +#define LENGTH 32 + +uint8_t buffer[LENGTH / 8] = { 0, 0, 0, 0 }; + +void bit_array_set (int i, int value) +{ + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + if (value) + buffer[byte_index] |= mask; + else + buffer[byte_index] &= ~mask; +} + +void bit_array_flip (int i) +{ + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + buffer[byte_index] ^= mask; +} + +int bit_array_get (int i) +{ + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + if (buffer[byte_index] & mask) + return 1; + else + return 0; +} + +void output (void) +{ + for (int i = 0; i < LENGTH; i++) + { + if (i % 4 == 0) + printf (" "); + printf ("%d", bit_array_get (i)); + } + printf ("\n"); +} + +int main (void) +{ + output (); + bit_array_set (12, 1); + output (); + bit_array_flip (31); + output (); + bit_array_set (12, 0); + output (); +} diff --git a/20210204/loesung-3-3.c b/20210204/loesung-3-3.c new file mode 100644 index 0000000000000000000000000000000000000000..4177464aebf41205169a6bb02b27ac972e3a4f4e --- /dev/null +++ b/20210204/loesung-3-3.c @@ -0,0 +1,71 @@ +#include <stdio.h> +#include <stdint.h> +#include <error.h> + +#define LENGTH 29 +#define BYTES ((LENGTH + 7) / 8) + +uint8_t buffer[BYTES] = { 0, 0, 0, 0 }; + +void check_index (int i) +{ + if (i < 0 || i >= LENGTH) + error (1, 0, "index %d out of range (0, ..., %d)", i, LENGTH - 1); +} + +void bit_array_set (int i, int value) +{ + check_index (i); + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + if (value) + buffer[byte_index] |= mask; + else + buffer[byte_index] &= ~mask; +} + +void bit_array_flip (int i) +{ + check_index (i); + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + buffer[byte_index] ^= mask; +} + +int bit_array_get (int i) +{ + check_index (i); + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + if (buffer[byte_index] & mask) + return 1; + else + return 0; +} + +void output (void) +{ + for (int i = 0; i < LENGTH; i++) + { + if (i % 4 == 0) + printf (" "); + printf ("%d", bit_array_get (i)); + } + printf ("\n"); +} + +int main (void) +{ + output (); + bit_array_set (12, 1); + output (); + bit_array_flip (28); + output (); + bit_array_set (12, 0); + output (); + bit_array_flip (31); + output (); +} diff --git a/20210204/loesung-3-4.c b/20210204/loesung-3-4.c new file mode 100644 index 0000000000000000000000000000000000000000..1930580aae8e8b24528852d1dacf58051f6bd6cc --- /dev/null +++ b/20210204/loesung-3-4.c @@ -0,0 +1,101 @@ +#include <stdio.h> +#include <stdint.h> +#include <error.h> +#include <stdlib.h> + +int length = 0; +int bytes = 0; +uint8_t *buffer = NULL; + +void bit_array_init (int n) +{ + length = n; + bytes = (length + 7) / 8; + if (buffer) + free (buffer); + buffer = malloc (bytes * sizeof (uint8_t)); + for (int i = 0; i < bytes; i++) + buffer[i] = 0; +} + +void bit_array_resize (int new_n) +{ + length = new_n; + bytes = (length + 7) / 8; + buffer = realloc (buffer, bytes * sizeof (uint8_t)); +} + +void bit_array_done (void) +{ + free (buffer); + buffer = NULL; + length = 0; + bytes = 0; +} + +void check_index (int i) +{ + if (!buffer) + error (1, 0, "array not initialised"); + if (i < 0 || i >= length) + error (1, 0, "index %d out of range (0, ..., %d)", i, length - 1); +} + +void bit_array_set (int i, int value) +{ + check_index (i); + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + if (value) + buffer[byte_index] |= mask; + else + buffer[byte_index] &= ~mask; +} + +void bit_array_flip (int i) +{ + check_index (i); + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + buffer[byte_index] ^= mask; +} + +int bit_array_get (int i) +{ + check_index (i); + int byte_index = i / 8; + int bit_index = i % 8; + uint8_t mask = 1 << bit_index; + if (buffer[byte_index] & mask) + return 1; + else + return 0; +} + +void output (void) +{ + for (int i = 0; i < length; i++) + { + if (i % 4 == 0) + printf (" "); + printf ("%d", bit_array_get (i)); + } + printf ("\n"); +} + +int main (void) +{ + bit_array_init (29); + output (); + bit_array_set (12, 1); + output (); + bit_array_flip (28); + output (); + bit_array_set (12, 0); + output (); + bit_array_flip (31); + output (); + bit_array_done (); +} diff --git a/README.md b/README.md index 9b2ab1615331d353f9bc19e04e3f5395f8304420..34ebca6b0a5b636216c0817f7fead00b1e13f23e 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,7 @@ Vortragsfolien und Beispiele: * [21.01.2021: Hardwarenahe Programmierung: Interrupts, volatile-Variable, Byte-Reihenfolge – Endianness, Binärdarstellung negativer Zahlen, Speicherausrichtung – Alignment](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210121/hp-20210121.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20210121/) * [28.01.2021: Objektorientierte Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210128/hp-20210128.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20210128/) * [04.02.2021: Objektorientierte Programmierung: virtuelle Methoden](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210204/hp-20210204.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20210204/) + * [11.02.2021: Objektorientierte Programmierung: virtuelle Methoden](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210211/hp-20210211.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20210211/) * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/hp-slides-2020ws.pdf) Übungsaufgaben: @@ -45,6 +46,7 @@ Vortragsfolien und Beispiele: * [21.01.2021: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210121/hp-uebung-20210121.pdf) * [28.01.2021: Speicherformate von Zahlen, Personen-Datenbank, objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210128/hp-uebung-20210128.pdf) * [04.02.2021: Objektorientierte Tier-Datenbank (Neuauflage), Iterationsfunktionen, dynamisches Bit-Array](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210204/hp-uebung-20210204.pdf) + * [11.02.2021: Stack-Operationen, einfach und doppelt verkettete Listen, ternärer Baum](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210211/hp-uebung-20210211.pdf) Musterlösungen: --------------- @@ -59,6 +61,7 @@ Musterlösungen: * [21.01.2021: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210121/hp-musterloesung-20210121.pdf) * [28.01.2021: Speicherformate von Zahlen, Personen-Datenbank, objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210128/hp-musterloesung-20210128.pdf) * [04.02.2021: Objektorientierte Tier-Datenbank (Neuauflage), Iterationsfunktionen, dynamisches Bit-Array](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210204/hp-musterloesung-20210204.pdf) + * [11.02.2021: Stack-Operationen, einfach und doppelt verkettete Listen, ternärer Baum](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210211/hp-musterloesung-20210211.pdf) Tafelbilder: ------------ diff --git a/hp-slides-2020ws.pdf b/hp-slides-2020ws.pdf index 2a5d0ce9550c2e58f7edb021e84d836b00248e8c..a74ee6002f891133eb1b11e2d785db5644b347df 100644 Binary files a/hp-slides-2020ws.pdf and b/hp-slides-2020ws.pdf differ diff --git a/hp-slides-2020ws.tex b/hp-slides-2020ws.tex index 551b589a8c3104cec602367459df620f1167cdbb..a621d08bd4c5a7088814622ca5a4120663f7ff9c 100644 --- a/hp-slides-2020ws.tex +++ b/hp-slides-2020ws.tex @@ -34,4 +34,6 @@ \includepdf[pages=-]{20210128/hp-20210128.pdf} \pdfbookmark[1]{04.02.2021: Objektorientierte Programmierung: virtuelle Methoden}{20210204} \includepdf[pages=-]{20210204/hp-20210204.pdf} + \pdfbookmark[1]{11.02.2021: Objektorientierte Programmierung: virtuelle Methoden}{20210211} + \includepdf[pages=-]{20210211/hp-20210211.pdf} \end{document}