diff --git a/20230316/ad-20230316-1-array-und-pointer.png b/20230316/ad-20230316-1-array-und-pointer.png new file mode 100644 index 0000000000000000000000000000000000000000..70aeab6c1ea28a91395a9ecfa47426167d2bdca7 Binary files /dev/null and b/20230316/ad-20230316-1-array-und-pointer.png differ diff --git a/20230316/ad-20230316-2-pointer-auf-pointer.png b/20230316/ad-20230316-2-pointer-auf-pointer.png new file mode 100644 index 0000000000000000000000000000000000000000..8452e136dd86586862f241fc392f91905102cb39 Binary files /dev/null and b/20230316/ad-20230316-2-pointer-auf-pointer.png differ diff --git a/20230316/ad-20230316-3-array-von-arrays.png b/20230316/ad-20230316-3-array-von-arrays.png new file mode 100644 index 0000000000000000000000000000000000000000..b65ce42996eb6c55d7c916b1961bf2810509d463 Binary files /dev/null and b/20230316/ad-20230316-3-array-von-arrays.png differ diff --git a/20230316/ad-20230316.pdf b/20230316/ad-20230316.pdf index c372fe296d1a3024f5f1a6fa76a403c6eb152996..671534a740818a59de6e48ac0a011f96bd46a2f6 100644 Binary files a/20230316/ad-20230316.pdf and b/20230316/ad-20230316.pdf differ diff --git a/20230316/ad-20230316.tex b/20230316/ad-20230316.tex index db1740fe61de5331fd8255326d451c62761b2761..f2eef8519d4546a8f81767412d6a00483ec7e7f4 100644 --- a/20230316/ad-20230316.tex +++ b/20230316/ad-20230316.tex @@ -150,7 +150,7 @@ {\color{medgreen}\textbf{Differentialgleichungen}} \begin{itemize} \item Pendel - \item Basketball + \item Planetenbahnen \end{itemize} {\color{medgreen}\textbf{Rekursion}} @@ -627,6 +627,10 @@ \arrowitem Fazit:\\ Ein Hoch auf \lstinline{typedef}! + \arrowitem + Trotzdem: {\color{red}Vorsicht!}\\ + Ein \lstinline{p++} auf einen Zeiger vom Typ \lstinline{string5 *p}\\ + ergibt anscheinend undefiniertes Verhalten! \end{itemize} \end{frame} diff --git a/20230316/ad-20230316.xcf.gz b/20230316/ad-20230316.xcf.gz new file mode 100644 index 0000000000000000000000000000000000000000..d65a1b6380d20ec9ef9383e6b492a67d8efdcb97 Binary files /dev/null and b/20230316/ad-20230316.xcf.gz differ diff --git a/20230316/arrays-pointers-01.c b/20230316/arrays-pointers-01.c new file mode 100644 index 0000000000000000000000000000000000000000..808bf8f8f7a540e0dc44cd3d8d79e9a5011d9249 --- /dev/null +++ b/20230316/arrays-pointers-01.c @@ -0,0 +1,18 @@ +#include <stdio.h> + +char a[] = "Test"; +char *p = "Test"; + +int main (void) +{ + char *q; + q = a; + printf ("%016zx: %s\n", q, q); + q = &a; + printf ("%016zx: %s\n", q, q); + q = p; + printf ("%016zx: %s\n", q, q); + q = &p; + printf ("%016zx: %s\n", q, q); + return 0; +} diff --git a/20230316/arrays-pointers-02.c b/20230316/arrays-pointers-02.c new file mode 100644 index 0000000000000000000000000000000000000000..77568c6f42530fd66b1b0a0a907450e786c99da7 --- /dev/null +++ b/20230316/arrays-pointers-02.c @@ -0,0 +1,10 @@ +#include <stdio.h> + +char *a[] = { "Dies", "ist", "ein", "Test", NULL }; + +int main (void) +{ + for (char **p = a; *p; p++) + printf ("%s\n", *p); + return 0; +} diff --git a/20230316/arrays-pointers-03.c b/20230316/arrays-pointers-03.c new file mode 100644 index 0000000000000000000000000000000000000000..8d0aa3713602dd4d21813a9fbce0d0bfc170d81e --- /dev/null +++ b/20230316/arrays-pointers-03.c @@ -0,0 +1,10 @@ +#include <stdio.h> + +char a[][] = { "Dies", "ist", "ein", "Test", NULL }; + +int main (void) +{ + for (char **p = a; *p; p++) + printf ("%s\n", *p); + return 0; +} diff --git a/20230316/arrays-pointers-04.c b/20230316/arrays-pointers-04.c new file mode 100644 index 0000000000000000000000000000000000000000..9152cb56f3c73a96a280d1012a5c77413435435e --- /dev/null +++ b/20230316/arrays-pointers-04.c @@ -0,0 +1,10 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", NULL }; + +int main (void) +{ + for (char **p = a; *p; p++) + printf ("%s\n", *p); + return 0; +} diff --git a/20230316/arrays-pointers-05.c b/20230316/arrays-pointers-05.c new file mode 100644 index 0000000000000000000000000000000000000000..fa9232e839af74f0c7624c7e193d7576be2f666a --- /dev/null +++ b/20230316/arrays-pointers-05.c @@ -0,0 +1,10 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", NULL }; + +int main (void) +{ + for (char *p = a; *p; p++) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-06.c b/20230316/arrays-pointers-06.c new file mode 100644 index 0000000000000000000000000000000000000000..91b20d7311fa81da7cbb628eb2f126e2a9cd2acd --- /dev/null +++ b/20230316/arrays-pointers-06.c @@ -0,0 +1,10 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", NULL }; + +int main (void) +{ + for (char *p = a; *p; p += 5) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-07.c b/20230316/arrays-pointers-07.c new file mode 100644 index 0000000000000000000000000000000000000000..87edda5aa010fe1ab2be5797eff126f062ee0ea9 --- /dev/null +++ b/20230316/arrays-pointers-07.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", "" }; + + /* "NULL" ist ein Zeiger mit Wert 0 + und wird hier uminterpretiert zu + einer Speicherzelle mit Wert 0, + also zu einem Leerstring. */ +int main (void) +{ + for (char *p = a; *p; p += 5) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-08.c b/20230316/arrays-pointers-08.c new file mode 100644 index 0000000000000000000000000000000000000000..ce22f2b070a49b9875f7c09e0a93404f7058e624 --- /dev/null +++ b/20230316/arrays-pointers-08.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", "" }; + + /* "NULL" ist ein Zeiger mit Wert 0 + und wird hier uminterpretiert zu + einer Speicherzelle mit Wert 0, + also zu einem Leerstring. */ +int main (void) +{ + for (char *p = &a; *p; p += 5) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-09.c b/20230316/arrays-pointers-09.c new file mode 100644 index 0000000000000000000000000000000000000000..ad3b23c87b18c3bd1159bba1e8da0c349ee4ff28 --- /dev/null +++ b/20230316/arrays-pointers-09.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", "" }; + + /* "NULL" ist ein Zeiger mit Wert 0 + und wird hier uminterpretiert zu + einer Speicherzelle mit Wert 0, + also zu einem Leerstring. */ +int main (void) +{ + for (char *p[5] = a; *p; p += 5) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-10.c b/20230316/arrays-pointers-10.c new file mode 100644 index 0000000000000000000000000000000000000000..37040df6f8f19b299d9275baf7bd7aa3f31e3457 --- /dev/null +++ b/20230316/arrays-pointers-10.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +char a[][5] = { "Dies", "ist", "ein", "Test", "" }; + + /* "NULL" ist ein Zeiger mit Wert 0 + und wird hier uminterpretiert zu + einer Speicherzelle mit Wert 0, + also zu einem Leerstring. */ +int main (void) +{ + for (char *p = a[0]; *p; p += 5) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-11.c b/20230316/arrays-pointers-11.c new file mode 100644 index 0000000000000000000000000000000000000000..32c7fb6523161ebd44e455d589e1d5a56f0051bf --- /dev/null +++ b/20230316/arrays-pointers-11.c @@ -0,0 +1,12 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + for (short_string *p = a; *p; p++) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-12.c b/20230316/arrays-pointers-12.c new file mode 100644 index 0000000000000000000000000000000000000000..82d54af5db5ef5c7982950f2bb16f31e06e8f48c --- /dev/null +++ b/20230316/arrays-pointers-12.c @@ -0,0 +1,12 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + for (short_string *p = a; p[0]; p++) + printf ("%s\n", p); + return 0; +} diff --git a/20230316/arrays-pointers-13.c b/20230316/arrays-pointers-13.c new file mode 100644 index 0000000000000000000000000000000000000000..0eebcc7d69ef68a4c6e1498205f137a3326b7875 --- /dev/null +++ b/20230316/arrays-pointers-13.c @@ -0,0 +1,12 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + for (short_string *p = a; p[0]; p++) + printf ("%s\n", *p); + return 0; +} diff --git a/20230316/arrays-pointers-14.c b/20230316/arrays-pointers-14.c new file mode 100644 index 0000000000000000000000000000000000000000..35eebc42020363d3421afa733e895f6cd035ee54 --- /dev/null +++ b/20230316/arrays-pointers-14.c @@ -0,0 +1,12 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + for (short_string *p = a; p[0]; p++) + printf ("%016zx: %s\n", (size_t) p, *p); + return 0; +} diff --git a/20230316/arrays-pointers-15.c b/20230316/arrays-pointers-15.c new file mode 100644 index 0000000000000000000000000000000000000000..a97e711c46ed901c53912dc067eaa33bf99322b4 --- /dev/null +++ b/20230316/arrays-pointers-15.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + short_string *p = a; + for (; p[0]; p++) + printf ("%016zx: %s\n", (size_t) p, *p); + printf ("%016zx: %s\n", (size_t) p, *p); + return 0; +} diff --git a/20230316/arrays-pointers-16.c b/20230316/arrays-pointers-16.c new file mode 100644 index 0000000000000000000000000000000000000000..f90570ae24cf8e34e9e6f2adab40187be4237eb0 --- /dev/null +++ b/20230316/arrays-pointers-16.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + short_string *p = a; + for (; *p[0]; p++) + printf ("%016zx: %s\n", (size_t) p, *p); + printf ("%016zx: %s\n", (size_t) p, *p); + return 0; +} diff --git a/20230316/arrays-pointers-17.c b/20230316/arrays-pointers-17.c new file mode 100644 index 0000000000000000000000000000000000000000..c359745c50cb018ecac9a0ef239ab3721d50e367 --- /dev/null +++ b/20230316/arrays-pointers-17.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string a[] = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + volatile short_string *p = a; + for (; p[0]; p++) + printf ("%016zx: %s\n", (size_t) p, *p); + printf ("%016zx: %s\n", (size_t) p, *p); + return 0; +} diff --git a/20230316/arrays-pointers-17.s b/20230316/arrays-pointers-17.s new file mode 100644 index 0000000000000000000000000000000000000000..351604705315a7758d588035c9e02683d7929861 --- /dev/null +++ b/20230316/arrays-pointers-17.s @@ -0,0 +1,46 @@ + .file "arrays-pointers-17.c" + .text + .section .rodata.str1.1,"aMS",@progbits,1 +.LC0: + .string "%016zx: %s\n" + .text + .globl main + .type main, @function +main: +.LFB11: + .cfi_startproc + subq $8, %rsp + .cfi_def_cfa_offset 16 + leaq a(%rip), %rdx + movq %rdx, %rsi + leaq .LC0(%rip), %rdi + movl $0, %eax + call printf@PLT + movl $0, %edx + movl $0, %esi + leaq .LC0(%rip), %rdi + movl $0, %eax + call printf@PLT + movl $0, %eax + addq $8, %rsp + .cfi_def_cfa_offset 8 + ret + .cfi_endproc +.LFE11: + .size main, .-main + .globl a + .data + .align 16 + .type a, @object + .size a, 25 +a: + .string "Dies" + .string "ist" + .zero 1 + .string "ein" + .zero 1 + .string "Test" + .string "" + .zero 4 + .ident "GCC: (Debian 8.3.0-6) 8.3.0" + .section .note.GNU-stack,"",@progbits diff --git a/20230316/arrays-pointers-18.c b/20230316/arrays-pointers-18.c new file mode 100644 index 0000000000000000000000000000000000000000..58f04a4ec183be6837975eef1844b69129bd9d4f --- /dev/null +++ b/20230316/arrays-pointers-18.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string *a = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + volatile short_string *p = a; + for (; *p[0]; p++) + printf ("%016zx: %s\n", (size_t) p, *p); + printf ("%016zx: %s\n", (size_t) p, *p); + return 0; +} diff --git a/20230316/arrays-pointers-19.c b/20230316/arrays-pointers-19.c new file mode 100644 index 0000000000000000000000000000000000000000..d79a436e14e4736a7af0989ec12d18babd44626c --- /dev/null +++ b/20230316/arrays-pointers-19.c @@ -0,0 +1,13 @@ +#include <stdio.h> + +typedef char short_string[5]; + +short_string *p = { "Dies", "ist", "ein", "Test", "" }; + +int main (void) +{ + for (; *p[0]; p++) + printf ("%016zx: %s\n", (size_t) p, *p); + printf ("%016zx: %s\n", (size_t) p, *p); + return 0; +} diff --git a/20230316/arrays-pointers-19.s b/20230316/arrays-pointers-19.s new file mode 100644 index 0000000000000000000000000000000000000000..d5a0d378e2d3a996300f882b7b4ba991bec8119d --- /dev/null +++ b/20230316/arrays-pointers-19.s @@ -0,0 +1,52 @@ + .file "arrays-pointers-19.c" + .text + .section .rodata.str1.1,"aMS",@progbits,1 +.LC0: + .string "%016zx: %s\n" + .text + .globl main + .type main, @function +main: +.LFB11: + .cfi_startproc + pushq %rbx + .cfi_def_cfa_offset 16 + .cfi_offset 3, -16 + movq p(%rip), %rsi + cmpb $0, (%rsi) + je .L2 + leaq .LC0(%rip), %rbx +.L3: + movq %rsi, %rdx + movq %rbx, %rdi + movl $0, %eax + call printf@PLT + movq p(%rip), %rax + leaq 5(%rax), %rsi + movq %rsi, p(%rip) + cmpb $0, 5(%rax) + jne .L3 +.L2: + movq %rsi, %rdx + leaq .LC0(%rip), %rdi + movl $0, %eax + call printf@PLT + movl $0, %eax + popq %rbx + .cfi_def_cfa_offset 8 + ret + .cfi_endproc +.LFE11: + .size main, .-main + .globl p + .section .rodata.str1.1 +.LC1: + .string "Dies" + .section .data.rel.local,"aw" + .align 8 + .type p, @object + .size p, 8 +p: + .quad .LC1 + .ident "GCC: (Debian 8.3.0-6) 8.3.0" + .section .note.GNU-stack,"",@progbits diff --git a/20230316/aufgabe-4-gpt-pg-01.c b/20230316/aufgabe-4-gpt-pg-01.c new file mode 100644 index 0000000000000000000000000000000000000000..3ae7738ea18d4403b44fe3115dc80e96b162772c --- /dev/null +++ b/20230316/aufgabe-4-gpt-pg-01.c @@ -0,0 +1,38 @@ +#include <stdio.h> +#include <stdint.h> + +#define XBM_WIDTH 14 +#define XBM_HEIGHT 14 + +static unsigned char xbm_bits[] = { + 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13, + 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04, + 0xf0, 0x03, 0x00, 0x00 +}; + +int main(int argc, char **argv) +{ + // Öffne die Ausgabedatei + FILE *output_file = fopen("test.pbm", "w"); + if (output_file == NULL) { + printf("Fehler beim Öffnen der Ausgabedatei\n"); + return 1; + } + + // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei + fprintf(output_file, "P1\n%d %d\n", XBM_WIDTH, XBM_HEIGHT); + + // Iteriere über jedes Byte im XBM-Array + for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte + for (int j = 7; j >= 0; j--) { + // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei + uint8_t xbm_bit = (xbm_bits[i] >> j) & 1; + fprintf(output_file, "%c", xbm_bit ? '1' : '0'); + } + } + + // Schließe die Ausgabedatei + fclose(output_file); + + return 0; +} diff --git a/20230316/aufgabe-4-gpt-pg-02.c b/20230316/aufgabe-4-gpt-pg-02.c new file mode 100644 index 0000000000000000000000000000000000000000..5f12d5c4ca7fc64aac4b9aa6eccf90dcb0f7113b --- /dev/null +++ b/20230316/aufgabe-4-gpt-pg-02.c @@ -0,0 +1,38 @@ +#include <stdio.h> +#include <stdint.h> + +#define XBM_WIDTH 14 +#define XBM_HEIGHT 14 + +static unsigned char xbm_bits[] = { + 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13, + 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04, + 0xf0, 0x03, 0x00, 0x00 +}; + +int main(int argc, char **argv) +{ + // Öffne die Ausgabedatei + FILE *output_file = fopen("test.pbm", "w"); + if (output_file == NULL) { + printf("Fehler beim Öffnen der Ausgabedatei\n"); + return 1; + } + + // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei + fprintf(output_file, "P1\n%d %d\n", XBM_WIDTH, XBM_HEIGHT); + + // Iteriere über jedes Byte im XBM-Array + for (int i = 0; i < XBM_HEIGHT * (XBM_WIDTH + 7) / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte + for (int j = 7; j >= 0; j--) { + // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei + uint8_t xbm_bit = (xbm_bits[i] >> j) & 1; + fprintf(output_file, "%c", xbm_bit ? '1' : '0'); + } + } + + // Schließe die Ausgabedatei + fclose(output_file); + + return 0; +} diff --git a/20230316/aufgabe-4-gpt.c b/20230316/aufgabe-4-gpt.c new file mode 100644 index 0000000000000000000000000000000000000000..e93f72b9e4ed5eab57f31156ae880ab466cb1a8a --- /dev/null +++ b/20230316/aufgabe-4-gpt.c @@ -0,0 +1,38 @@ +#include <stdio.h> +#include <stdint.h> + +#define XBM_WIDTH 14 +#define XBM_HEIGHT 14 + +static unsigned char xbm_bits[] = { + 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13, + 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04, + 0xf0, 0x03, 0x00, 0x00 +}; + +int main(int argc, char **argv) +{ + // Öffne die Ausgabedatei + FILE *output_file = fopen("test.pbm", "w"); + if (output_file == NULL) { + printf("Fehler beim Öffnen der Ausgabedatei\n"); + return 1; + } + + // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei + fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT); + + // Iteriere über jedes Byte im XBM-Array + for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte + for (int j = 7; j >= 0; j--) { + // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei + uint8_t xbm_bit = (xbm_bits[i] >> j) & 1; + fprintf(output_file, "%c", xbm_bit ? '1' : '0'); + } + } + + // Schließe die Ausgabedatei + fclose(output_file); + + return 0; +} diff --git a/20230316/test.pbm b/20230316/test.pbm new file mode 100644 index 0000000000000000000000000000000000000000..7980589686ea49a4f37217b36624d6515632de57 --- /dev/null +++ b/20230316/test.pbm @@ -0,0 +1,3 @@ +P1 +14 14 +000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100111100000000001100000000000000000000000100011011000000110011101100111000000000000000000000000000 \ No newline at end of file diff --git a/20230323/Zeichen_123.pdf b/20230323/Zeichen_123.pdf new file mode 120000 index 0000000000000000000000000000000000000000..fdbc897227df059cfda790a16555e6e417682116 --- /dev/null +++ b/20230323/Zeichen_123.pdf @@ -0,0 +1 @@ +../common/Zeichen_123.pdf \ No newline at end of file diff --git a/20230323/ad-20230323.pdf b/20230323/ad-20230323.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6ecdfeb0c0151704df14f3a8ea5b018c89050ab8 Binary files /dev/null and b/20230323/ad-20230323.pdf differ diff --git a/20230323/ad-20230323.tex b/20230323/ad-20230323.tex new file mode 100644 index 0000000000000000000000000000000000000000..eb10a72ebae1bb319b7e9b83b32cabf566580bb5 --- /dev/null +++ b/20230323/ad-20230323.tex @@ -0,0 +1,1088 @@ +% ad-20230322.pdf - Lecture Slides on Algorithms and Data Structures in C/C++ +% Copyright (C) 2018, 2019, 2020, 2021, 2022, 2023 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: Einführung + +\documentclass[10pt,t]{beamer} + +\usepackage{pgslides} +\usepackage{tikz} +%\usepackage{rotating} + +\newcommand{\underconstruction}{% + \begin{picture}(0,0) + \color{black} + \put(6,-2.2){\makebox(0,0)[b]{\includegraphics[width=1.5cm]{Zeichen_123.pdf}}} + \put(6,-2.5){\makebox(0,0)[t]{\shortstack{Änderungen\\vorbehalten}}} + \end{picture}} + +\title{Algorithmen und Datenstrukturen in C/C++} +\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski} +\date{22.\ März 2023} + +\begin{document} + +\maketitleframe + +% \sectionnonumber{Vorab: Online-Werkzeuge} +% +% \begin{frame} +% +% \showsectionnonumber +% \begin{itemize} +% \item +% \textbf{Mumble}: Seminarraum 2\\ +% Fragen: Mikrophon einschalten oder über den Chat\\ +% Umfragen: über den Chat +% \smallskip +% \item +% \textbf{VNC}: Kanal 6, Passwort: \lstinline[style=cmd]{testcvh}\\ +% Eigenen Bildschirm freigeben: per VNC-Server oder Web-Interface\\ +% Kamerabild übertragen: Link zu Web-Interface auf Anfrage +% \smallskip +% \item +% Allgemeine Informationen: +% \url{https://www.cvh-server.de/online-werkzeuge/} +% \smallskip +% \item +% Notfall-Schnellzugang: \url{https://www.cvh-server.de/virtuelle-raeume/}\\ +% Seminarraum 2, VNC-Passwort: \lstinline[style=cmd]{testcvh} +% \smallskip +% \item +% Bei Problemen: bitte notieren:\\ +% Art des Problems, genaue Uhrzeit, JavaScript-Fehlermeldungen (F12) +% \bigskip +% \item +% GitLab: \url{https://gitlab.cvh-server.de/pgerwinski/ad}\\ +% Links auf die Datei klicken, nicht mittig auf den Kommentar. +% \end{itemize} +% +% \end{frame} + +\nosectionnonumber{Hardwarenahe Programmierung} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \color{gray} + \item[\textbf{1}] \textbf{Einführung} + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}} + \item[\textbf{2}] \textbf{Einführung in C} + \item[\textbf{3}] \textbf{Bibliotheken} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \item[\textbf{5}] \textbf{\color{black}Algorithmen} + \begin{itemize} + \color{medgreen} + \item[5.1] Differentialgleichungen + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen + \end{itemize} + \item[\textbf{6}] \textbf{Objektorientierte Programmierung} + \item[\textbf{7}] \textbf{\color{black}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*{-1cm} + +\end{frame} + +\nosectionnonumber{Algorithmen} + +\begin{frame} + + \shownosectionnonumber + + {\color{medgreen}\textbf{Differentialgleichungen}} + \begin{itemize} + \item Pendel + \item Planetenbahnen + \end{itemize} + + {\color{medgreen}\textbf{Rekursion}} + \begin{itemize} + \item Türme von Hanoi + \end{itemize} + + \smallskip + + \textarrow\ \emph{Wie rechnet man das überhaupt aus?} + + \bigskip + + {\color{medgreen}\textbf{Aufwandsabschätzungen}} + \begin{itemize} + \item Selectionsort + \item Bubblesort + \item Quicksort + \end{itemize} + + \smallskip + + \textarrow\ \emph{Wie rechnet man das möglichst effizient aus?} + \begin{itemize} + \item[\textbf{?}] möglichst schnell + \item[\textbf{?}] mit möglichst wenig Speicherplatzverbrauch + \item[\textbf{?}] unter Berücksichtigung gegebener Randbedingungen + \end{itemize} + +\end{frame} + +\nosectionnonumber{Datenstrukturen} + +\begin{frame} + + \shownosectionnonumber + + \addvspace{-3pt} + + \begin{visibleenv}<1-> + \textbf{Structs und Objekte} + \begin{itemize} + \item zusammengehörige Daten gemeinsam speichern + \end{itemize} + \end{visibleenv} + + {\color{medgreen}\textbf{Stack und FIFO}}\only<1->{\textbf{ -- Arrays}} + \begin{itemize} + \item effizientes Anfügen und Entfernen vorne und hinten + \item effizienter direkter Zugriff auf Elemente in der Mitte + \item ineffizientes Einfügen und Entfernen in der Mitte + \end{itemize} + + {\color{medgreen}\textbf{Verkettete Listen}}\only<1->{\textbf{ -- Structs mit Pointern}} + \begin{itemize} + \item effizientes Einfügen und Entfernen in der Mitte + \item ineffizienter direkter Zugriff auf Elemente in der Mitte + \end{itemize} + + {\color{medgreen}\textbf{Bäume}}\only<1->{\textbf{ -- Structs mit Pointern}} + \begin{itemize} + \item Kompromiß + \end{itemize} + + \smallskip + + \textarrow\ \emph{Wie speichert man das möglichst effizient?} + \begin{itemize} + \item[\textbf{?}] möglichst schnell + \item[\textbf{?}] mit möglichst wenig Speicherplatzverbrauch + \item[\textbf{?}] unter Berücksichtigung gegebener Randbedingungen + \end{itemize} + +\end{frame} + +\nosectionnonumber{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse} + +\begin{frame}[fragile] + +% \newcommand{\w}{\hspace*{0.75pt}} + + \shownosectionnonumber + + \begin{picture}(0,0) + \put(7.6,-0.5){% + \begin{minipage}[t]{5.3cm} +% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf} + \alt<3->{\vspace*{-0.93cm}\includegraphics{landau-symbols-3.pdf}}% + {\vspace*{-1.00cm}\includegraphics{landau-symbols.pdf}} + \small%\vspace*{-1.0cm} + \begin{description}\itemsep0pt\leftskip-0.5cm + \item[$n$:] Eingabedaten + \item[$g(n)$:] Rechenzeit + \end{description} + \end{minipage}} + \end{picture} + + \vspace*{-\bigskipamount} + + Wann ist ein Programm "`schnell"'? + + \medskip + + \begin{onlyenv}<1> + Türme von Hanoi: $\mathcal{O}(2^n)$ + \par\medskip + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + \begin{itemize} + \arrowitem + $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + + \bigskip + \end{onlyenv} + + \begin{onlyenv}<1-> + Faustregel:\\Schachtelung der Schleifen zählen\\ + $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$ + + \bigskip + \end{onlyenv} + + \begin{onlyenv}<2> + \textbf{Beispiel: Sortieralgorithmen} + + \smallskip + + Anzahl der Vergleiche bei $n$ Strings + \begin{itemize} + \item + Maximum suchen mit Schummeln: $\mathcal{O}(1)$ +% \pause + \item + Maximum suchen: $\mathcal{O}(n)$ +% \pause + \item + Selection-Sort: $\mathcal{O}(n^2)$ +% \pause + \item + Bubble-Sort: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$ +% \pause + \item + Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$ + \end{itemize} + + \end{onlyenv} + +% \begin{onlyenv}<3> +% \textbf{Wie schnell ist RSA-Verschlüsselung?} +% +% \smallskip +% +% \begin{math} +% c = m^e\,\%\,N +% \end{math} +% \quad +% ("`$\%$"' = "`modulo"') +% +% \medskip +% +% \begin{lstlisting}[gobble=6,xleftmargin=2em] +% int c = 1; +% for (int i = 0; i < e; i++) +% c = (c * m) % N; +% \end{lstlisting} +% +% \smallskip +% +% \begin{itemize} +% \item +% $\mathcal{O}(e)$ Iterationen +% % \item +% % wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist: +% % $\mathcal{O}(2^n)$ Iterationen +% \item +% mit Trick: +% $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$) +% \end{itemize} +% +% \smallskip +% +% Jede Iteration enthält eine Multiplikation und eine Division.\\ +% Aufwand dafür: $\mathcal{O}(\log e)$\\ +% \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$ +% +% \end{onlyenv} + + \begin{onlyenv}<3-> + + \textbf{Wie schnell ist RSA?}\\ + + \smallskip + + ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$) + + \begin{itemize} + \item + Ver- und Entschlüsselung (Exponentiation):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss} + \only<3->{{\color{magenta}$\mathcal{O}(n^2)$}} + \item + Schlüsselerzeugung (Berechnung von $d$):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss} + \only<3->{{\color{magenta}$\mathcal{O}(n^2)$}} + \item + Verschlüsselung brechen (Primfaktorzerlegung):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss} + \only<3->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}} + \end{itemize} + + \smallskip +% \vspace{0cm plus 1filll} + + \textbf{Die Sicherheit von RSA beruht darauf, + daß das Brechen der Verschlüsselung aufwendiger ist als + \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).} + +% \vspace*{0.65cm} + + \end{onlyenv} + +\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/ad.git}}} + \item[\textbf{2}] \textbf{\dots} + \end{itemize} + + \begin{picture}(0,0)(-2,-0.5) + \put(0.5,-1.0){\mbox{\Large$\mathcal{O}(n\log n)$}} + \put(0.6,-2.7){\mbox{\large\bf B-Baum}} + \put(-1.3,-3.4){\mbox{\small\it verkettete Liste}} + \put(1.5,-4.0){\mbox{\large Datenbanken}} + \put(-1.0,-1.9){\mbox{\large\tt struct}} + \put(3.0,-2.0){\mbox{\large Wegfindung}} + \put(4.0,-3.0){\mbox{Verschlüsseln}} + \put(5.7,-4.2){\mbox{\it Datenkompression}} + \put(6.0,-1.5){\mbox{CORDIC}} + \put(8.5,-2.0){\mbox{\small\bf FFT}} + \put(7.5,-2.9){\mbox{\small\tt pointer}} + \put(3.5,-0.5){\mbox{\it Rasterung}} + \put(7.7,-0.7){\mbox{\tt array}} + \put(-0.5,-5.0){\mbox{digitale Signatur}} + \put(3.5,-5.2){\mbox{\large Hash-Tabelle}} + \put(0.0,-6.3){\mbox{\small\bf kryptographische Hash-Funktion}} + \put(6.5,-6.0){\mbox{\it Prüfsumme}} +% \pause +% \put(4.0,-2.7){\begin{rotate}{18} +% \makebox(0,0){\LARGE\color{red}\shortstack{% +% Online-Werkzeuge für Home Office, Lehre\\ +% und Kommunikation mit Unterdrückten}} +% \end{rotate}} + \end{picture} + +\end{frame} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \underconstruction + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/ad.git}}} +% \item[\textbf{\color{red}i}] {\color{red}Online-Werkzeuge für Home Office, Lehre\\ +% und Kommunikation mit Unterdrückten} + \item[\textbf{2}] \textbf{Datenorganisation} + \item[\textbf{3}] \textbf{Optimierung} + \item[\textbf{4}] \textbf{Hardwarenahe Algorithmen} + \item[\textbf{5}] \textbf{Datenkodierung} + \color{gray} + \item[\textbf{6}] \textbf{Numerik} + \end{itemize} + +\end{frame} + +\subsectionnonumber{C: Arrays und Zeiger für Fortgeschrittene} + +\begin{frame}[fragile] + \showsubsectionnonumber + + \begin{minipage}[t]{6cm} + Array: + \smallskip + \begin{lstlisting}[gobble=6] + char a[] = "Test"; + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{6cm} + Zeiger: + \smallskip + \begin{lstlisting}[gobble=6] + char *p = "Test"; + \end{lstlisting} + \end{minipage} + + \bigskip + + \begin{itemize} + \item + In beiden Fällen wird ein Array von ganzen Zahlen\\ + (5 \lstinline{char}-Variable mit den Werten 84, 101, 115, 116 und 0)\\ + im Speicher angelegt. + \medskip + \item + Links heißt das Array \lstinline{a}; + rechts ist es "`anonym"'. + \item + Rechts wird zusätzlich ein Zeiger \lstinline{p} im Speicher angelegt,\\ + der auf das (anonyme) Array zeigt. + \medskip + \item + \lstinline{&a} ist dasselbe wie \lstinline{a}, + nämlich die Adresse des Arrays. + \item + \lstinline{&p} ist die Adresse des Zeigers. + \item + \lstinline{p} ist der Wert des Zeigers,\\ + momentan also die Adresse des (anonymen) Arrays. + \end{itemize} + +\end{frame} + +\begin{frame}[fragile] + \showsubsectionnonumber + + \begin{minipage}[t]{6cm} + Array: + \smallskip + \begin{lstlisting}[gobble=6] + char a[] = "Test"; + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{6cm} + Zeiger: + \smallskip + \begin{lstlisting}[gobble=6] + char *p = "Test"; + \end{lstlisting} + \end{minipage} + + \bigskip + + \begin{itemize} + \item + In beiden Fällen wird ein Array von ganzen Zahlen\\ + (5 \lstinline{char}-Variable mit den Werten 84, 101, 115, 116 und 0)\\ + im Speicher angelegt. + \medskip + \item + Links heißt das Array \lstinline{a}; + rechts ist es "`anonym"'. + \item + Rechts wird zusätzlich ein Zeiger \lstinline{p} im Speicher angelegt,\\ + der auf das (anonyme) Array zeigt. + \medskip + \item + \lstinline{&a} ist {\color{red}fast} dasselbe wie \lstinline{a},\\ + nämlich die Adresse des Arrays {\color{red}bzw.\ das Array selbst,\\ + das zuweisungskompatibel zu einem Zeiger auf Elemente des Arrays ist.\\ + \lstinline{&} bewirkt hier eine (nicht explizite!) Typumwandlung.} + \item + \lstinline{&p} ist die Adresse des Zeigers. + \item + \lstinline{p} ist der Wert des Zeigers,\\ + momentan also die Adresse des (anonymen) Arrays. + \end{itemize} + + \vspace*{-1cm} + +\end{frame} + +\begin{frame}[fragile] + \showsubsectionnonumber + + \begin{minipage}[t]{7cm} + Array: + \smallskip + \begin{lstlisting}[gobble=6] + char *a[] = { "Dies", "ist", "ein", "Test" }; + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{5cm} + Zeiger: + \smallskip + \begin{lstlisting}[gobble=6] + char **p = a; + \end{lstlisting} + \end{minipage} + + \bigskip + + \begin{itemize} + \item + Array von Zeigern auf \lstinline{char}-Variable + \item + Zeiger auf das Array = Zeiger auf Zeiger auf \lstinline{char}-Variable + \item + Schleife durch äußeres Array mit \lstinline{p++} möglich + \end{itemize} + +\end{frame} + +\begin{frame}[fragile] + \showsubsectionnonumber + + \begin{minipage}[t]{7cm} + Array: + \smallskip + \begin{lstlisting}[gobble=6] + char a[][5] = { "Dies", "ist", "ein", "Test" }; + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{5cm} + Zeiger: + \smallskip + \begin{lstlisting}[gobble=6] + char *p = a[0]; + \end{lstlisting} + \end{minipage} + + \bigskip + + \begin{itemize} + \item + zweidimensionales Array von \lstinline{char}-Variablen + \item + Zeiger auf Array-Komponente\\ + = Zeiger auf eindimensionales Array\\ + = Zeiger auf \lstinline{char}-Variable + \item + Schleife durch äußeres Array mit Zeiger-Arithmetik nicht möglich + \end{itemize} + + \begin{picture}(0,0) + \color{red} + \thicklines + \put(8.6,0.63){\line(1,0){0.85}} + \put(9.05,0.4){\makebox(0,0)[t]{$\overbrace{\mbox{nur mit Trick: + \lstinline{p += 5}}}$}} + \end{picture} + +\end{frame} + +\begin{frame}[fragile] + \showsubsectionnonumber + + \begin{lstlisting} + typedef char string5[5]; + string5 a[] = { "Dies", "ist", "ein", "Test" }; + string5 *p = a; + \end{lstlisting} + + \bigskip + + \begin{itemize} + \item + Array von Array von \lstinline{char}-Variablen\\ + = zweidimensionales Array von \lstinline{char}-Variablen + \item + Zeiger auf zweidimensionales Array + \item + Schleife durch äußeres Array mit \lstinline{p++} möglich + \bigskip + \arrowitem + Fazit:\\ + Ein Hoch auf \lstinline{typedef}! + \arrowitem + Trotzdem: {\color{red}Vorsicht!}\\ + Ein \lstinline{p++} auf einen Zeiger vom Typ \lstinline{string5 *p}\\ + ergibt anscheinend undefiniertes Verhalten! + \end{itemize} + +\end{frame} + +\begin{frame}[fragile] + \showsubsectionnonumber + + \begin{lstlisting} + typedef char string5[5]; + string5 *p = { "Dies", "ist", "ein", "Test" }; + \end{lstlisting} + + \bigskip + + \begin{itemize} + \item + anonymes Array von Array von \lstinline{char}-Variablen\\ + = anonymes zweidimensionales Array von \lstinline{char}-Variablen + \item + Zeiger auf zweidimensionales Array + \item + Schleife durch äußeres Array mit \lstinline{p++} möglich + \end{itemize} + +% \pause + + \begin{picture}(0,0)(-2,-0.4) + \color{red} + \thicklines + \put(0,0){\line(2,1){4}} + \put(0,2){\line(2,-1){4}} + \end{picture} + + Das Konstrukt \lstinline|{ "Dies", "ist", "ein", "Test" }|\\ + steht für ein Array von 4 Zeigern auf \lstinline{char}-Variable. + + \smallskip + + \lstinline{string5 *p} hingegen erwartet einen Zeiger auf ein Array + von 5 \lstinline{char}-Variablen. + + \smallskip + + Es bekommt die Adresse von \lstinline{"Dies"} zugewiesen. + + \smallskip + + Durch das Erhöhen von \lstinline{p} (um 5) zeigt es danach + \emph{zufällig\/} auf das \lstinline{"ist"}. + + Bei nochmaligem Erhöhen zeigt es auf das \lstinline{"in"} von \lstinline{"ein"}. + + \smallskip + + (Auch ohne Optimierung werden die Strings \lstinline{"ist"}, \lstinline{"ein"} + und \lstinline{"Test"}\\ + u.\,U.\ wegoptimiert.) + +\end{frame} + +\nosectionnonumber{\large\bf Übungsaufgabe: Verkettete Listen} + +\begin{frame} + + \shownosectionnonumber + + \begin{enumerate}[\quad(a)] + \item + Schreiben Sie eine Funktion, die eine verkettete Liste\\ + in die umgekehrte Reihenfolge bringt. + \item + Schreiben Sie eine Funktion, die eine verkettete Liste\\ + in eine doppelt verkettete Liste umwandelt. + \item + Wieviel Rechenzeit (Landau-Symbol) benötigen Ihre Funktionen? + \item + Wieviel Speicherplatz (Landau-Symbol) benötigen Ihre Funktionen? + \end{enumerate} + +\end{frame} + +\nosectionnonumber{\inserttitle} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \underconstruction + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/ad.git}}} +% \item[\textbf{i}] \textbf{Gesellschaftliche Auswirkungen\\ +% von Algorithmen und Datenstrukturen} + \item[\textbf{2}] \textbf{Datenorganisation} + \item[\textbf{3}] \textbf{Optimierung} + \item[\textbf{4}] \textbf{Hardwarenahe Algorithmen} + \item[\textbf{5}] \textbf{Datenkodierung} + \color{gray} + \item[\textbf{6}] \textbf{Numerik} + \end{itemize} + +\end{frame} + +\section{Einführung in C++} +\addtocounter{subsection}{-1} +\subsection{Was ist C?} + +\begin{frame} + + \showsection + \showsubsection + + Etabliertes Profi-Werkzeug + \begin{itemize} + \item + kleinster gemeinsamer Nenner für viele Plattformen\\ + \begin{picture}(0,1) + \color{red} + \put(7.2,0.6){\tikz{\draw[-latex](0.0,0.0)--(0.0,0.4);}} + \put(7.2,0.5){\makebox(0,0)[t]{\color{black}Hardware und/oder Betriebssystem}} + \end{picture} + \item + Hardware direkt ansprechen und effizient einsetzen + \item + \dots\ bis hin zu komplexen Software-Projekten + \medskip + \arrowitem + Man kann Computer vollständig beherrschen. + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsection + \showsubsection + + \begin{picture}(0,0) + \put(5.3,-2.5){\makebox(0,0)[tl]{\begin{minipage}{7cm} + \emph{C makes it easy to shoot yourself in the foot.} + \begin{flushright} + Bjarne Stroustrup, ca.~1986\\ + \href{http://www.stroustrup.com/bs_faq.html\#really-say-that}% + {\nolinkurl{http://www.stroustrup.com/bs_faq.html}\\ + \nolinkurl{\#really-say-that}} + \end{flushright} + \end{minipage}}} + \end{picture}% + Etabliertes Profi-Werkzeug + \begin{itemize} + \item + kleinster gemeinsamer Nenner für viele Plattformen + \item + Hardware direkt ansprechen und effizient einsetzen + \item + \dots\ bis hin zu komplexen Software-Projekten + \item + leistungsfähig, aber gefährlich + \end{itemize} + + \medskip + "`High-Level-Assembler"' + \begin{itemize} + \item + kein "`Fallschirm"' + \item + kompakte Schreibweise + \end{itemize} + + \medskip + Unix-Hintergrund + \begin{itemize} + \item + Baukastenprinzip + \item + konsequente Regeln + \item + kein "`Fallschirm"' + \end{itemize} + +\end{frame} + +\subsection{Was ist C++?} + +\begin{frame} + + \showsection + \showsubsection + + \begin{picture}(0,0) + \put(6.3,-0.2){\makebox(0,0)[tl]{\begin{minipage}{6cm} + \emph{C++ is a better C.} + \begin{flushright} + Bjarne Stroustrup, Autor von C++\\ + \url{http://www.stroustrup.com/C++.html} + \end{flushright} + \end{minipage}}} + \put(5.3,-2.5){\makebox(0,0)[tl]{\begin{minipage}{7cm} + \emph{C makes it easy to shoot yourself in the foot;\\ + C++ makes it harder, but when you do\\ + it blows your whole leg off.} + \begin{flushright} + Bjarne Stroustrup, Autor von C++, ca.~1986\\ + \href{http://www.stroustrup.com/bs_faq.html\#really-say-that}% + {\nolinkurl{http://www.stroustrup.com/bs_faq.html}\\ + \nolinkurl{\#really-say-that}} + \end{flushright} + \end{minipage}}} + \end{picture}% + Etabliertes Profi-Werkzeug + \begin{itemize} + \item + kompatibel zu C + \end{itemize} + + \medskip + + C++ unterstützt + \begin{itemize} + \item + \newterm{objektorientierte\\ + Programmierung} + \item + \newterm{Datenabstraktion} + \item + \newterm{generische\\ + Programmierung} + \end{itemize} + + \vspace{0cm plus 1 filll} + + \textbf{Motivation:}\\[\smallskipamount] + Vermeidung unsicherer Techniken,\\ + insbesondere von Präprozessor-Konstruktionen und Zeigern,\\ + unter Beibehaltung der Effizienz + +\end{frame} + +\subsection{Elementare Neuerungen in C++ gegenüber C} + +\begin{frame}[fragile] + \showsubsection + \begin{itemize} + \pause + \item + Kommentare mit \lstinline{//} + \pause + \item + Konstante: +% \begin{onlyenv}<3> +% \begin{lstlisting}[gobble=10] +% const int answer = 42; +% \end{lstlisting} +% \end{onlyenv} + \begin{lstlisting}[gobble=8] + const int n = 5; + int prime[n] = { 2, 3, 5, 7, 11 }; + \end{lstlisting} + \pause + \item + Ab C++11: \lstinline{constexpr}-Funktionen\\ +% \only<1->{{\color{red}\dots\ anscheinend auch ohne "`constexpr"' \dots}\\} + C++11: darf nur aus einem einzigen \lstinline{return}-Statement bestehen\\ + \textarrow\ \lstinline{?:} statt \lstinline{if}, Rekursion statt Schleife\\ + C++-14: auch Verzweigungen und Schleifen erlaubt + \pause + \item + leere Parameterliste: \lstinline{void} optional\\ + in C: ohne \lstinline{void} = Parameterliste wird nicht geprüft + \pause + \item + Operatoren \lstinline{new} und \lstinline{delete}\\ + als Alternative zu den Funktionen \lstinline{malloc()} und \lstinline{free()} + \end{itemize} +\end{frame} + +\subsection{Referenz-Typen} + +\begin{frame}[fragile] + \showsubsection + \begin{lstlisting} + void calc_answer (int &answer) + { + answer = 42; + } + \end{lstlisting} + \medskip + \dots\ als Alternative zu \dots + \medskip + \begin{lstlisting} + void calc_answer (int *answer) + { + *answer = 42; + } + \end{lstlisting} + \begin{itemize} + \item + Zeiger "`verborgen"', übersichtlicher und sicherer + \item + Es gibt keinen \lstinline{NULL}-Wert.\\ + \textarrow\ Für verkettete Listen u.\,ä.: Tricks erforderlich + \end{itemize} +\end{frame} + +\subsection{Überladbare Operatoren und Funktionen} + +\begin{frame}[fragile] + \showsubsection + \begin{lstlisting} + #include <iostream> + + int main () + { + std::cout << "Hello, world!" << std::endl; + return 0; + } + \end{lstlisting} + + \pause + \bigskip + + Bemerkungen: + \begin{itemize} + \item + Compilieren mit \lstinline[style=cmd]{g++} + statt \lstinline[style=cmd]{gcc}:\\ + C++-Bibliotheken mit einbinden + \item + Der Operator \lstinline{<<} hat normalerweise keinen Seiteneffekt, + hier schon. + \end{itemize} +\end{frame} + +\begin{frame}[fragile] + \showsubsection + \begin{lstlisting} + #include <iostream> + + struct vector + { + double x, y, z; + }; + + vector operator + (vector u, vector v) + { + vector w = { u.x + v.x, u.y + v.y, u.z + v.z }; + return w; + } + \end{lstlisting} + + \begin{itemize} + \item + \lstinline{++} wird zum Präfix-Operator. + \item + \lstinline{++} mit zusätzlichem (ungenutzten) \lstinline{int}-Parameter\\ + wird zum Postfix-Operator. + \end{itemize} +\end{frame} + +\begin{frame}[fragile] + \showsubsection + \begin{lstlisting} + void print (const char *s) + { + printf ("%s", s); + } + + void print (int i) + { + printf ("%d", i); + } + \end{lstlisting} + \pause + \bigskip + Optionale Parameter: + \medskip + \begin{lstlisting} + void print (const char *s = "\n") + { + printf ("%s", s); + } + \end{lstlisting} + \pause + \begin{picture}(0,0) + \color{red} + \put(5.50,5.40){\makebox(0,0)[br]{\tikz{\draw[-latex](0.0,0.0)--(-2.0,0.6);}}} + \put(5.50,4.85){\makebox(0,0)[tr]{\tikz{\draw[-latex](0.0,0.0)--(-2.0,-0.2);}}} + \put(5.6,5.0){\begin{minipage}{5cm} + Für den Linker:\\ + veränderte, eindeutige Namen + \end{minipage}} + \put(5.50,1.55){\makebox(0,0)[tr]{\tikz{\draw[-latex](0.0,0.0)--(-0.6,0.4);}}} + \put(5.6,1.0){\begin{minipage}{5cm} + wird vom Compiler erledigt + \end{minipage}} + \pause + \put(7.0,3.6){\makebox(0,0)[b]{\tikz{\draw[-latex](0.0,0.0)--(0.0,0.9);}}} + \put(5.6,3.0){\begin{minipage}{5cm} + Wenn man das nicht will:\\ + extern \char`"C\char`"\ \{ \dots \} + \end{minipage}} + \end{picture} +\end{frame} + +\subsection{Namensräume} + +\begin{frame}[fragile] + \showsubsection + \begin{lstlisting} + #include <iostream> + + using namespace std; + + int main () + { + cout << "Hello, world!" << endl; + return 0; + } + \end{lstlisting} + + \pause + \bigskip + + \begin{lstlisting} + namespace my_output + { + ... + } + + using namespace my_output; + \end{lstlisting} +\end{frame} + +\subsection{Objekte} + +\begin{frame}[fragile] + \showsubsection + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡struct TBase + { + };¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{6cm} + \begin{lstlisting}[gobble=8] + ¡struct TInteger: public TBase + { + int content; + };¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡struct TString: public TBase + { + char *content; + };¿ + \end{lstlisting} + \end{minipage} + \end{center} +\end{frame} + +\addtocounter{subsection}{-1} +\subsection{Objekte: Zugriffsrechte} + +\begin{frame}[fragile] + \showsubsection + \begin{itemize} + \item + \lstinline{public}, \lstinline{private}, \lstinline{protected}\\[\smallskipamount] + nicht nur Bürokratie, sondern auch Kapselung\\ + (Maßnahme gegen "`Namensraumverschmutzung"') + \medskip + \item + \lstinline{struct}: standardmäßig \lstinline{public}\\[\smallskipamount] + \lstinline{class}: standardmäßig \lstinline{private} + \medskip + \item + \dots + \end{itemize} +\end{frame} + +\end{document} diff --git a/20230323/landau-symbols-2.pdf b/20230323/landau-symbols-2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4 --- /dev/null +++ b/20230323/landau-symbols-2.pdf @@ -0,0 +1 @@ +../common/landau-symbols-2.pdf \ No newline at end of file diff --git a/20230323/landau-symbols-3.pdf b/20230323/landau-symbols-3.pdf new file mode 120000 index 0000000000000000000000000000000000000000..46efa409b35ff5df763c744a423599cba515d886 --- /dev/null +++ b/20230323/landau-symbols-3.pdf @@ -0,0 +1 @@ +../common/landau-symbols-3.pdf \ No newline at end of file diff --git a/20230323/landau-symbols.pdf b/20230323/landau-symbols.pdf new file mode 120000 index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565 --- /dev/null +++ b/20230323/landau-symbols.pdf @@ -0,0 +1 @@ +../common/landau-symbols.pdf \ No newline at end of file diff --git a/20230323/logo-hochschule-bochum-cvh-text.pdf b/20230323/logo-hochschule-bochum-cvh-text.pdf new file mode 120000 index 0000000000000000000000000000000000000000..a05946126bc0ce6a2818740da2893f59eb0c659c --- /dev/null +++ b/20230323/logo-hochschule-bochum-cvh-text.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum-cvh-text.pdf \ No newline at end of file diff --git a/20230323/logo-hochschule-bochum.pdf b/20230323/logo-hochschule-bochum.pdf new file mode 120000 index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1 --- /dev/null +++ b/20230323/logo-hochschule-bochum.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum.pdf \ No newline at end of file diff --git a/20230323/pgslides.sty b/20230323/pgslides.sty new file mode 120000 index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64 --- /dev/null +++ b/20230323/pgslides.sty @@ -0,0 +1 @@ +../common/pgslides.sty \ No newline at end of file