Informatik 1 Übung 5. NACHBESPRECHUNG Übung 5 Korrekturen Ich prüfe keine Syntax – schreibt wenn was nicht kompiliert Lösungen müssen nicht perfekt sein.

Präsentation zum Thema: "Informatik 1 Übung 5. NACHBESPRECHUNG Übung 5 Korrekturen Ich prüfe keine Syntax – schreibt wenn was nicht kompiliert Lösungen müssen nicht perfekt sein."—  Präsentation transkript:

1 Informatik 1 Übung 5

2 NACHBESPRECHUNG Übung 5

3 Korrekturen Ich prüfe keine Syntax – schreibt wenn was nicht kompiliert Lösungen müssen nicht perfekt sein – Testat gibt es für ernst gemeinte Lösungsversuche Formatiert euren Code schön – sonst geb ich mir auch keine Mühe Musterlösungen anschauen

4 Ich gebe nicht auf Code schön formatieren if (x > 0) { a = 1; b = 1; // Kommentar. if (y > 0) { c = 1; } else { d = 1; } e = 1; }

5 Variablentyp Richtige Typen verwenden TypVerwendungWerte boolWahrheitswerttrue, false char/wchar_tEin Zeichen'a', 'b',... intEine ganze Zahl0, 1,... float/doubleEine reelle Zahl0.0, 0.1,...

6 Ganzzahldivision Auf Ganzzahl-Division achten AusdruckWert 1/100 1.0/100.1 1/10.00.1

7 Charakter Buchstaben entsprechen Zahlen Wenn möglich Buchstaben verwenden bool isCapital = 'A' < c && c < 'Z';bool isCapital = 65 < c && c < 90; char c = 'A';char c = 65; if(antwort == 'y')if(antwort == 121)

8 Identische Blöcke Copy-Paste vermeiden if(i<10) { switch(i) { case 0: cout << "Null"; break; case 1: cout << "Eins"; break; } } else { switch(i%10) { case 0: cout << "Null"; break; case 1: cout << "Eins"; break; } string s; switch(i%10) { case 0: s = "Null"; break; case 1: s = "Eins"; break; } if(i<10) { cout << s; } else { cout << s; }

9 Division durch 0 Arithmetische Operationen prüfen – Division durch 0 – Logarithmus einer negativen Zahl –... In if-Bedingung: als erstes prüfen – Vorzeitiger Abbruch der Auswertung int x = 1; int y = 0; int z = x / y; if(y!=0 && x/y > 1)

10 Arithmetische Operationen CPU kann nur multiplizieren und addieren x y, sin(x), x,... müssen berechnet werden – Iterative multiplikation (siehe Übung 4) – Tabellierte Werte – Gleichungssystem lösen – Taylorreihe –...

11 WIEDERHOLUNG Vorlesung 5

12 VARIABLEN Einzelne Werte

13 Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt Vereinfachtes Bespiel – Nur integer – Nur 7 Speicherzellen

14 Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt 0000 0001 0002 0003 0004 0005 0006

15 Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x0000??? 0001 0002 0003 0004 0005 0006 int x;

16 Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x000010 0001 0002 0003 0004 0005 0006 int x; x = 10;

17 Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x000010 y0001??? 0002 0003 0004 0005 0006 int x; x = 10; int y;

18 Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x000010 y000110 0002 0003 0004 0005 0006 int x; x = 10; int y; y = x;

19 ARRAYS Aufeinanderfolgende Werte

20 Arrays Mehrere aufeinanderfolgende Zellen NameAddresseInhalt x000010 y000110 z[0]0002??? z[1]0003??? 0004 0005 0006 int x = 10; int y = 10; int z[2];

21 Arrays Mehrere aufeinanderfolgende Zellen NameAddresseInhalt x000010 y000110 z[0]000220 z[1]000330 0004 0005 0006 int x = 10; int y = 10; int z[2]; z[0] = 20; z[1] = 30;

22 POINTER (ZEIGER) Verweise auf Werte

23 Pointer Pointer verweisen auf andere Speicherzellen Wert vom Pointer – Adresse einer anderen Speicherzelle // Variablen, welche auf eine andere Speicherzelle zeigt, // welche wiederum den gegebenen Typ speichert. typ* name;

24 Pointer Pointer verweisen auf andere Speicherzellen Wert vom Pointer – Adresse einer anderen Speicherzelle int x; // x speichert eine ganze Zahl int* p; // p speichert die Adresse einer ganzen Zahl p = &x; // die Adresse von x wird in p gespeichert // Variablen, welche auf eine andere Speicherzelle zeigt, // welche wiederum den gegebenen Typ speichert. typ* name;

25 Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x000010 y000110 p0002??? 0003 0004 0005 0006 int x = 10; int y = 10; int* p;

26 Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x000010 y000110 p0002[0001] 0003 0004 0005 0006 int x = 10; int y = 10; int* p; p = &y;

27 Pointer NULL bedeutet zeigt auf nichts NameAddresseInhalt x000010 y000110 p0002[NULL] 0003 0004 0005 0006 int x = 10; int y = 10; int* p; p = NULL;

28 Pointer Pointer verweisen auf andere Speicherzellen Dereferenzieren – Zugriff auf die adressierte Speicherzelle int x; int* p = &x; *p = 10; // p zeigt auf x, also wird in x die 10 gespeichert

29 Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x000010 y000110 p0002[0001] 0003 0004 0005 0006 int x = 10; int y = 10; int* p; p = &y;

30 Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x000010 y000120 p0002[0001] 0003 0004 0005 0006 int x = 10; int y = 10; int* p; p = &y; *p = 20;

31 Pointer &x – Adresse der Variablen x *x – Wert der Zelle, auf welche x zeigt – dem Pfeil folgen

32 Pointer Beliebig viele Indirektionen NameAddresseInhalt x000010 px0001[0000] ppx0002[0001] pppx0003[0002] 0004 0005 0006 int x; int* px = &x; int** ppx = &px; int*** pppx = &ppx; ***pppx = 1;

33 Pointer-Arithmetik Addition auf Adressen Zeiger + konstante Zahl NameAddresseInhalt x[0]000010 x[1]000110 p0002[0000] q0003[0001] 0004 0005 0006 int x[2] = {10,10}; int* p = &x; int* q = p+1;

34 ARRAYS UND ZEIGER Gemeinsamkeiten

35 Arrays Name des Arrays = Zeiger auf die erste Zelle int x[2]; int* p = x; // p zeigt auf das erste Element in x int* p = &(x[0]); // p zeigt auf das erste Element in x

36 Arrays Array-Index = Pointer-Arithmetik int x[2]; int x1 = x[1]; // x1 wird das zweite Element von x zugewiesen int x1 = *(x+1); // x1 wird das zweite Element von x zugewiesen

37 LESEN VON ZEIGERN

38 Leseweise Beim Variablennamen starten Nach aussen arbeiten – nach rechts, dann nach links const int * const x[2]; x ist...

39 Leseweise Beim Variablennamen starten Nach aussen arbeiten – nach rechts, dann nach links const int * const x[2]; x ist ein Array von zwei...

40 Leseweise Beim Variablennamen starten Nach aussen arbeiten – nach rechts, dann nach links const int * const x[2]; x ist ein Array von zwei konstanten...

41 Leseweise Beim Variablennamen starten Nach aussen arbeiten – nach rechts, dann nach links const int * const x[2]; x ist ein Array von zwei konstanten Zeigern...

42 Leseweise Beim Variablennamen starten Nach aussen arbeiten – nach rechts, dann nach links const int * const x[2]; x ist ein Array von zwei konstanten Zeigern auf ein integer...

43 Leseweise Beim Variablennamen starten Nach aussen arbeiten – nach rechts, dann nach links const int * const x[2]; x ist ein Array von zwei konstanten Zeigern auf ein integer, der konstant ist

44 DYNAMISCHER SPEICHER

45 Speicher reservieren Operator new Erstellt eine neue Speicherzelle – Typ muss angegeben werden – Gibt Zeiger auf die neue Zelle zurück int* p; // Erstellt Speicherplatz für einen neuen integer // p zeigt auf die neu angelegte Speicherzelle p = new int;

46 Speicher freigeben Operator delete Löscht eine zuvor erstellte Speicherzelle – Achtung: Zeiger werden ungültig // Erstellt Speicherplatz für einen neuen integer int* p = new int; // Löscht die Speicherzelle, auf welche p zeigt delete p; // p zeigt hier immer noch auf die Speicherzelle, die nicht mehr gibt

47 Speicher freigeben Operator delete Löscht eine zuvor erstellte Speicherzelle – Achtung: Zeiger werden ungültig // Erstellt Speicherplatz für einen neuen integer int* p = new int; // Löscht die Speicherzelle, auf welche p zeigt delete p; // p zurücksetzen p = NULL;

48 Arrays Arrays anlegen und freigeben int N; // Erstellt Speicherplatz für N neue integer int* p = new int[N]; // Zugriff mit und ohne Array-Syntax p[1] = 10; *(p+1) = 10; // Löscht alle Speicherzellen delete[] p;

49 QUIZ

50 Quiz Was gibt das Programm aus? int x = 10; int y = 20; cout << x;

51 Quiz Was gibt das Programm aus? int x = 10; int y = 20; int* p = &y; cout << p;

52 Quiz Was gibt das Programm aus? int x = 10; int y = 20; int* p = &y; cout << *p;

53 Quiz Was gibt das Programm aus? int x = 10; int y = 20; int* p; cout << p;

54 Quiz Was gibt das Programm aus? int x = 10; int y = 20; int* p = &x; *p = 11; p = &y; *p = 21; cout << x; cout << y;

55 Quiz Was gibt das Programm aus? int x[2] = {10, 20}; cout << (x+1);

56 Quiz Was gibt das Programm aus? int x[2] = {10, 20}; cout << *x + 1;

57 Quiz Was gibt das Programm aus? int x[2] = {10, 20}; cout << *(x + 1);

58 STRUCTS Variablenverbunde

59 Structs Ein struct fasst mehrere Variablen zusammen Definiert einen neuen Typ // Definiere einen neuen Typ mit zwei integer-Elementen struct vector2D { int x; int y; }; vector2d v;

60 Structs Zugriff auf Elemente member auf Englisch vector2D v; v.x = 10; v.y = 10;

61 Structs Zuweisung kopiert alle Elemente – Anderst als bei Arrays vector2D v; vector2D w; v = w;

62 Structs Elemente vom Struct in benachbarten Zellen Wie beim Array NameAddresseInhalt v.x0000??? v.y0001??? 0002 0003 0004 0005 0006 vector2D v;

63 Structs Elemente vom Struct in benachbarten Zellen Wie beim Array NameAddresseInhalt v.x000010 v.y000120 0002 0003 0004 0005 0006 vector2D v; v.x = 10; v.y = 20;

64 Structs und Zeiger Zeiger auf structs möglich Verkürzte Syntax für Elementzugriff vector2D v; vector2D* pv = &v; (*pv).x = 10; // Setze Element x vom referenzierten Vektor auf 10 pv->x = 10; // Setze Element x vom referenzierten Vektor auf 10

65 ÜBUNG Serie 6