Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Informatik 1 Übung 7. NACHBESPRECHUNG Übung 6 SCOPE.

Ähnliche Präsentationen


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

1 Informatik 1 Übung 7

2 NACHBESPRECHUNG Übung 6

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 g, x g

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

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

8 REFERENZEN

9 lvalue vs. rvalue lvalue – 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 ReferenzenZeiger Ziel änderbarNeinJa Wert vom Ziel änderbarJa Variablentyp& name = ziel;typ* name; Beispielint x,y; int& z = x; z = 2; // z = y; nicht erlaubt int x,y; 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 – lokale Variablen – klein – automatische Reservierung und Freigabe Heap – mit new erstellte Objekte – gross – Reservierung und Freigabe mit new bzw delete

21 Stack NameAddresseInhalt : 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 NameAddresseInhalt x : 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 NameAddresseInhalt x00000 i : 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 NameAddresseInhalt x00000 i00010 y : 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 NameAddresseInhalt x : 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 NameAddresseInhalt i0000??? : 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 NameAddresseInhalt i0000??? return address result0002??? a00031 b : 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 NameAddresseInhalt i0000??? return address result0002??? a00031 b : 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 NameAddresseInhalt i0000??? return address result0002??? a00031 b00042 s : 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 NameAddresseInhalt i0000??? return address result00023 a00031 b00042 s : 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 NameAddresseInhalt i0000??? return address result : 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 NameAddresseInhalt i00003 return address result : 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 NameAddresseInhalt i : 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 WIEDERHOLUNG Vorlesung 6

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 – 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 – spezielle Methode – wird automatisch aufgerufen, wenn Objekt erstellt wird Destruktor – spezielle Methode – wird automatisch aufgerufen, wenn Objekt gelöscht wird

46 Konstruktoren Syntax Konstruktor – 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 – jeder kann die Daten benutzen private – 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 ÜBUNG Serie 7


Herunterladen ppt "Informatik 1 Übung 7. NACHBESPRECHUNG Übung 6 SCOPE."

Ähnliche Präsentationen


Google-Anzeigen