Informatik 1 Übung 7

Übung 6 Nachbesprechung

Scope

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

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

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

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

Referenzen

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;

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

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;

Funktionen

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

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

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

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

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

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

Speicher

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

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

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

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

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

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

Stack und Funktionen

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

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

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

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

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

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

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

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

Vorlesung 6 wiederholung

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Serie 7 Übung