Notizen und Beispiele 16.1.2023

20230116/func-pointers-01.c

+#include <stdio.h>
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  hello ();
+  return 0;
+}

20230116/func-pointers-02.c

+#include <stdio.h>
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  /* h ist ein Zeiger auf eine Funktion;
+     h soll auf die Funktion hello() zeigen; */
+  /* Merken: "*h ist eine Funktion." */
+  /* void *h (void) wäre eine Funktion, die keine Parameter bekommt
+                    und einen Zeiger auf void zurückgibt. */
+  void (*h) (void) = hello;
+  h ();
+  return 0;
+}

20230116/func-pointers-03.c

+#include <stdio.h>
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  typedef void (*funcptr) (void);
+  funcptr h = hello;
+  h ();
+  return 0;
+}

20230116/func-pointers-04.c

+#include <stdio.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  object o;
+
+  o.greeting = hello;  // "Konstruktor" - Initiallisieren des Funktions-Zeigers
+                       //Ohne Klammerpaar: Adresse der Funktion
+  o.greeting ();       // mit Klammerpaar: Funktion aufrufen
+
+  return 0;
+}

20230116/func-pointers-05.c

+#include <stdio.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  object *o;
+                        // FEHLER: Verwendung von "o" ohne daß "o" auf etwas Sinnvolles zeigt!
+  o->greeting = hello;  // "Konstruktor" - Initiallisieren des Funktions-Zeigers
+                        // Ohne Klammerpaar: Adresse der Funktion
+  o->greeting ();       // mit Klammerpaar: Funktion aufrufen
+
+  return 0;
+}

20230116/func-pointers-06.c

+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  object *o;
+
+  o = malloc (sizeof (object));   // Speicherplatz dynamisch erzeugen
+
+  o->greeting = hello;  // "Konstruktor" - Initiallisieren des Funktions-Zeigers
+                        // Ohne Klammerpaar: Adresse der Funktion
+  o->greeting ();       // mit Klammerpaar: Funktion aufrufen
+
+  return 0;
+}

20230116/func-pointers-07.c

+#include <stdio.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello (void)
+{
+  printf ("Hello, world!\n");
+}
+
+int main (void)
+{
+  object *o;
+
+  object apfel;  // Speicherplatz innerhalb von main() reservieren
+  o = &apfel;    // Zeiger darauf zeigen lassen
+
+  o->greeting = hello;  // "Konstruktor" - Initiallisieren des Funktions-Zeigers
+                        // Ohne Klammerpaar: Adresse der Funktion
+  o->greeting ();       // mit Klammerpaar: Funktion aufrufen
+
+  return 0;
+}

20230116/func-pointers-08.c

+#include <stdio.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello_apple (void)
+{
+  printf ("Hello, apple!\n");
+}
+
+void hello_pear (void)
+{
+  printf ("Hello, pear!\n");
+}
+
+int main (void)
+{
+  object *a;
+  object *b;
+
+  object apfel;  // Speicherplatz innerhalb von main() reservieren
+  a = &apfel;    // Zeiger darauf zeigen lassen
+  a->greeting = hello_apple;   // "Konstruktor": virtuelle Methode initialisieren
+
+  object birne;  // Speicherplatz innerhalb von main() reservieren
+  b = &birne;    // Zeiger darauf zeigen lassen
+  b->greeting = hello_pear;    // "Konstruktor": virtuelle Methode initialisieren
+
+  a->greeting ();
+  b->greeting ();
+
+  return 0;
+}

20230116/func-pointers-09.c

+#include <stdio.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello_apple (void)
+{
+  printf ("Hello, apple!\n");
+}
+
+void hello_pear (void)
+{
+  printf ("Hello, pear!\n");
+}
+
+int main (void)
+{
+  object *o[2];  // Array mit 2 Zeigern auf Objekte
+
+  object apfel;  // Speicherplatz innerhalb von main() reservieren
+  o[0] = &apfel;    // Zeiger darauf zeigen lassen
+  o[0]->greeting = hello_apple;   // "Konstruktor": virtuelle Methode initialisieren
+
+  object birne;  // Speicherplatz innerhalb von main() reservieren
+  o[1] = &birne;    // Zeiger darauf zeigen lassen
+  o[1]->greeting = hello_pear;    // "Konstruktor": virtuelle Methode initialisieren
+
+  for (int i = 0; i < 2; i++)
+    o[i]->greeting ();
+
+  return 0;
+}

20230116/func-pointers-10.c

+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct
+{
+  void (*greeting) (void);  // Zeiger auf Funktion, nicht initialisiert
+}
+object;
+
+void hello_apple (void)
+{
+  printf ("Hello, apple!\n");
+}
+
+void hello_pear (void)
+{
+  printf ("Hello, pear!\n");
+}
+
+int main (void)
+{
+  object *o[2];  // Array mit 2 Zeigern auf Objekte
+
+  o[0] = malloc (sizeof (object));  // "Konstrutor": Speicherplatz dynamisch reservieren
+  o[0]->greeting = hello_apple;     // "Konstruktor": virtuelle Methode initialisieren
+
+  o[1] = malloc (sizeof (object));  // "Konstrutor": Speicherplatz dynamisch reservieren
+  o[1]->greeting = hello_pear;      // "Konstruktor": virtuelle Methode initialisieren
+
+  for (int i = 0; i < 2; i++)
+    o[i]->greeting ();
+
+  return 0;
+}

20230116/hp-20230116.txt

+Klausur-Themen, 16.01.2023, 13:57:20
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ - Seiteneffekte
+ - Arrays, Zeiger, Strings
+ - Speicherzellen
+ - Bit-Manipulation
+ - Endianness
+ - Alignment
+ - Algorithmen, Landau-Symbol
+ - Objekte, Zeiger auf Funktionen
+
+--> Es ist mal wieder Zeit für:
+     - Seiteneffekte
+     - Mikrocontroller
+
+Zeiger, 16.01.2023, 11:30:23
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ - auf Funktionen
+ - auf Structs und Unions

20230116/pointers-01.c

+#include <stdio.h>
+
+int main (void)
+{
+  int a = 7;
+  int b = 13;
+  int *p = &a;
+  printf ("*p = %d\n", *p);
+  p = &b;
+  printf ("*p = %d\n", *p);
+  return 0;
+}

20230116/pointers-01.pas

+program Pointers;
+
+var
+  a: Integer = 7;
+  b: Integer = 13;
+  p: ^Integer = @a;
+
+begin
+  WriteLn ('p^ = ', p^);
+  p := @b;
+  WriteLn ('p^ = ', p^)
+end.

20230116/pointers-02.c

+#include <stdio.h>
+
+int main (void)
+{
+  int a = 7;
+  int b = 13;
+  int *p = &a;
+  printf ("*p = %d\n", *p);
+  *p = &b;  /* falsch */
+  printf ("*p = %d\n", *p);
+  return 0;
+}

20230116/pointers-03.c

+#include <stdio.h>
+
+int main (void)
+{
+  int a = 7;
+  int b = 13;
+  int *p;
+  p = &a;
+  printf ("*p = %d\n", *p);
+  *p = &b;  /* falsch: Zuweisung der Speicheradresse von b an die Zahl a,
+                       weil p zu diesem Zeitpunkt auf a zeigt */
+  printf ("*p = %d\n", *p);
+  printf ("a = %d\n", a);
+  return 0;
+}

20230116/struct-pointers-01.c

+#include <stdio.h>
+
+typedef struct
+{
+  int a;
+  int b;
+}
+data;
+
+int main (void)
+{
+  data d;
+  d.a = 7;
+  d.b = 13;
+  data *p = &d;
+  printf ("*p = { %d, %d }\n", *p.a, *p.b);
+  return 0;
+}

20230116/struct-pointers-02.c

+#include <stdio.h>
+
+typedef struct
+{
+  int a;
+  int b;
+}
+data;
+
+int main (void)
+{
+  data d;
+  d.a = 7;
+  d.b = 13;
+  data *p = &d;
+  printf ("*p = { %d, %d }\n", (*p).a, (*p).b);
+  return 0;
+}

20230116/struct-pointers-03.c

+#include <stdio.h>
+
+typedef struct
+{
+  int a;
+  int b;
+}
+data;
+
+int main (void)
+{
+  data d;
+  d.a = 7;
+  d.b = 13;
+  data *p = &d;
+  printf ("*p = { %d, %d }\n", p->a, p->b);
+  return 0;
+}

20230116/struct-pointers-03.pas

+program StructPointers;
+
+type
+  data = record
+    a, b: Integer
+  end;
+
+var
+  d: data;
+  p: ^data;
+
+begin
+  d.a := 7;
+  d.b := 13;
+  p := @d;
+  WriteLn ('p^ = { ', p^.a, ', ', p^.b, ' }')
+end.

20230116/struct-pointers-04.c

+#include <stdio.h>
+
+typedef struct
+{
+  int a;
+  int b;
+}
+data;
+
+int main (void)
+{
+  data d;
+  d.a = 7;
+  d.b = 13;
+  printf ("d = { %d, %d }\n", d->a, d->b);
+  return 0;
+}