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 – 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

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; }

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

Ganzzahldivision Auf Ganzzahl-Division achten AusdruckWert 1/ / /

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)

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; }

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)

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 –...

WIEDERHOLUNG Vorlesung 5

VARIABLEN Einzelne Werte

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

Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt

Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x0000??? int x;

Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x int x; x = 10;

Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x y0001??? int x; x = 10; int y;

Variablen Variablen in Speicherzellen gespeichert Jede Speicherzelle hat Adresse und Inhalt NameAddresseInhalt x y int x; x = 10; int y; y = x;

ARRAYS Aufeinanderfolgende Werte

Arrays Mehrere aufeinanderfolgende Zellen NameAddresseInhalt x y z[0]0002??? z[1]0003??? int x = 10; int y = 10; int z[2];

Arrays Mehrere aufeinanderfolgende Zellen NameAddresseInhalt x y z[0] z[1] int x = 10; int y = 10; int z[2]; z[0] = 20; z[1] = 30;

POINTER (ZEIGER) Verweise auf Werte

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;

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;

Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x y p0002??? int x = 10; int y = 10; int* p;

Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x y p0002[0001] int x = 10; int y = 10; int* p; p = &y;

Pointer NULL bedeutet zeigt auf nichts NameAddresseInhalt x y p0002[NULL] int x = 10; int y = 10; int* p; p = NULL;

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

Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x y p0002[0001] int x = 10; int y = 10; int* p; p = &y;

Pointer Pointer verweisen auf andere Speicherzellen NameAddresseInhalt x y p0002[0001] int x = 10; int y = 10; int* p; p = &y; *p = 20;

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

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

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

ARRAYS UND ZEIGER Gemeinsamkeiten

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

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

LESEN VON ZEIGERN

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

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

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

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...

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...

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

DYNAMISCHER SPEICHER

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;

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

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;

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;

QUIZ

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

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

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

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

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;

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

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

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

STRUCTS Variablenverbunde

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;

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

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

Structs Elemente vom Struct in benachbarten Zellen Wie beim Array NameAddresseInhalt v.x0000??? v.y0001??? vector2D v;

Structs Elemente vom Struct in benachbarten Zellen Wie beim Array NameAddresseInhalt v.x v.y vector2D v; v.x = 10; v.y = 20;

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

ÜBUNG Serie 6