Informatik 1 Übung 7.

Präsentation zum Thema: "Informatik 1 Übung 7."—  Präsentation transkript:

1 Informatik 1 Übung 7

2 Übung 6 Nachbesprechung

3 Scope

4 Variablen Lebensdauer/Sichtbarkeit (Scope)
bis zur schliessenden Klammer int g; int main() { int x = 0; for(int i = 0; i<10; i++) int y = i*2; x += y; }

5 Variablen Lebensdauer/Sichtbarkeit (Scope)
bis zur schliessenden Klammer int g; int main() { int x = 0; for(int i = 0; i<10; i++) int y = i*2; x += y; } g g, x g, x, i g, x, i, y

6 Variablen Gleicher Variablenname, anderer Scope
nur bei Zählvariablen verwenden int main() { int i = 0; }

7 Variablen Gleicher Variablenname, geschachtelter Scope nie verwenden
int main() { int i = 0; }

8 Referenzen

9 lvalue vs. rvalue lvalue rvalue
Alles was links von einer Zuweisung stehen kann Alles was eine Adresse im Speicher hat Variablen rvalue Ausdrücke int i; i = 100; i+1 = 100; int a[10]; a[1] = 100; 1*a[1] = 100;

10 Referenzen Referenzen sind wie Synonyme int i; int& r = i;
// r und i sind jetzt "die selbe Variable" i = 100; r = 100;

11 Referenzen Vergleich mit Zeigern Referenzen Zeiger Ziel änderbar Nein
Ja Wert vom Ziel änderbar Variablen typ& name = ziel; typ* name; Beispiel int x,y; int& z = x; z = 2; // z = y; nicht erlaubt int* z = &x; *z = 2; z = &y;

12 Funktionen

13 Funktionen Parameter sind neue Variablen
nur innerhalb der Funktion sichtbar Vor dem Aufruf werden die Werte kopiert

14 Funktionen int summe(int a, int b) { return a + b; } int main()
int i = summe(1,2);

15 Funktionen int summe(int a, int b) { return a + b; } int main()
int i = summe(1,2); int main() { // summe – anfang int param_a; int param_b; param_a = 1; param_b = 2; int result = param_a + param_b; // summe – ende int i = result; }

16 Funktionen Referenzen für Call by Reference void increase(int& a) {
a = a + 1; } int main() { int x = 1; increase(x); int increase(int a) { return a + 1; } int main() { int x = 1; x = increase(x);

17 Funktionen Referenzen für Call by Reference
float intersect(ray strahl, Vector3f& normale) { normale = Vector3f(0,0,0); return 0; } int main() { Vector3f normale; float distance; ray strahl; distance = intersect(strahl, normale);

18 Funktionen Array ausgeben Zeiger = Array
Referenz, um den Zeiger zu ändern void createArray(int*& result, int size) { result = new int[size]; } int main() int* array; createArray(array, 10);

19 Speicher

20 Speicher Stack Heap lokale Variablen klein
automatische Reservierung und Freigabe Heap mit new erstellte Objekte gross Reservierung und Freigabe mit new bzw delete

21 Stack Name Addresse Inhalt 0000 0001 0002 0003 0004 0005 0006
01: int main() 02: { 03: int x = 0; 04: for(int i = 0; i<10; i++) 05: { 06: int y = i*2; 07: x += y; 08: } 09: }

22 Stack Name Addresse Inhalt x 0000 0001 0002 0003 0004 0005 0006
0001 0002 0003 0004 0005 0006 01: int main() 02: { 03: int x = 0; 04: for(int i = 0; i<10; i++) 05: { 06: int y = i*2; 07: x += y; 08: } 09: }

23 Stack Name Addresse Inhalt x 0000 i 0001 0002 0003 0004 0005 0006
i 0001 0002 0003 0004 0005 0006 01: int main() 02: { 03: int x = 0; 04: for(int i = 0; i<10; i++) 05: { 06: int y = i*2; 07: x += y; 08: } 09: }

24 Stack Name Addresse Inhalt x 0000 i 0001 y 0002 0003 0004 0005 0006
i 0001 y 0002 0003 0004 0005 0006 01: int main() 02: { 03: int x = 0; 04: for(int i = 0; i<10; i++) 05: { 06: int y = i*2; 07: x += y; 08: } 09: }

25 Stack Name Addresse Inhalt x 0000 0001 0002 0003 0004 0005 0006
0001 0002 0003 0004 0005 0006 01: int main() 02: { 03: int x = 0; 04: for(int i = 0; i<10; i++) 05: { 06: int y = i*2; 07: x += y; 08: } 09: }

26 Stack und Funktionen

27 Stack und Funktionen Name Addresse Inhalt i 0000 ??? 0001 0002 0003
0004 0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

28 Stack und Funktionen Name Addresse Inhalt i 0000 ??? return address
0001 08 result 0002 a 0003 1 b 0004 2 0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

29 Stack und Funktionen Name Addresse Inhalt i 0000 ??? return address
0001 08 result 0002 a 0003 1 b 0004 2 0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

30 Stack und Funktionen Name Addresse Inhalt i 0000 ??? return address
0001 08 result 0002 a 0003 1 b 0004 2 s 0005 3 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

31 Stack und Funktionen Name Addresse Inhalt i 0000 ??? return address
0001 08 result 0002 3 a 0003 1 b 0004 2 s 0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

32 Stack und Funktionen Name Addresse Inhalt i 0000 ??? return address
0001 08 result 0002 3 0003 0004 0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

33 Stack und Funktionen Name Addresse Inhalt i 0000 3 return address 0001
08 result 0002 0003 0004 0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

34 Stack und Funktionen Name Addresse Inhalt i 0000 3 0001 0002 0003 0004
0005 0006 01: int summe(int a, int b) 02: { 03: int s = a + b; 03: return s; 04: } 05: 06: int main() 07: { 08: int i = summe(1,2); 09: }

35 Vorlesung 6 wiederholung

36 Überladen von Funktionen
Erlaubt: selber Funktionsname andere Parameter-Typen "function overloading" Auswahl der verwendeten Version Bestimmt der Compiler Die Version wo alle Typen übereinstimmen

37 Überladen von Funktionen
float summe(float a, float b) { return a + b; } // Version 1 int summe(int a, int b) { return a + b; } // Version 2 int main() { cout << summe(1, 2); // Version 2 aufgerufen cout << summe(1.0f, 2.0f); // Version 1 aufgerufen }

38 Klassen Wie stuct, zusätzlich Zugriffsart Member-Funktionen*
Konstruktoren/Destruktoren* * theoretisch auch für structs verfügbar

39 Klassen Struct // Neuen Typ definieren struct Vektor { int x; int y;
}; // Ein Objekt (Instanz) vom neuen Typ erstellen Vektor v;

40 Klassen Class // Neuen Typ definieren class Vektor { private: int x;
int y; }; // Ein Objekt (Instanz) vom neuen Typ erstellen Vektor v;

41 Methoden Wie Funktionen Deklaration in der Klasse
arbeiten auf einem Objekt this: Zeiger auf bearbeitetes Objekt Deklaration in der Klasse Definition innerhalb oder ausserhalb

42 Methoden class Vektor { public: float get_norm() { return x + y };
private: int x; int y; }; int main() { Vektor v; float f = v.get_norm(); }

43 Methoden class Vektor { public: float get_norm(); private: int x;
int y; }; float Vektor::get_norm() { return x + y} int main() { Vektor v; float f = v.get_norm(); }

44 Methoden class Vektor { public: float get_norm(); private: int x;
int y; }; float Vektor::get_norm() { return this->x + this->y} int main() { Vektor v; float f = v.get_norm(); }

45 Konstruktoren Konstruktor Destruktor spezielle Methode
wird automatisch aufgerufen, wenn Objekt erstellt wird Destruktor wird automatisch aufgerufen, wenn Objekt gelöscht wird

46 Konstruktoren Syntax Konstruktor Syntax Destruktor Wie Funktion
kein Rückgabewert Name gleich wie Klasse Syntax Destruktor Tilde (~) vor dem Namen

47 Konstruktoren class Vektor { public: Vektor(); ~Vektor(); private:
int x, y; };

48 Konstruktoren class Vektor { public: Vektor(); private: int x, y; };
float Vektor::Vektor() { x = 0; y = 0; } int main() { Vektor v;

49 Konstruktoren class Vektor { public: Vektor(int a, int b); private:
int x, y; }; float Vektor::Vektor(int a, int b) { x = a; y = b; } int main() { Vektor v(1, 2);

50 Zugriffsrechte public private protected jeder kann die Daten benutzen
nur die eigene Klasse z.B. in Methoden protected kommt später

51 Zugriffsrechte class Vektor { public: int x; private: int y; };
int main() { Vektor v; v.x = 1; // v.y = 2; nicht erlaubt }

52 Serie 7 Übung