Informatik 1 Übung 7. NACHBESPRECHUNG Übung 6 SCOPE.
-
Upload
berndt-winkler -
Category
Documents
-
view
143 -
download
2
Transcript of Informatik 1 Übung 7. NACHBESPRECHUNG Übung 6 SCOPE.
Informatik 1
Übung 7
NACHBESPRECHUNGÜbung 6
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; }}
gggg, xg, x, ig, x, ig, x, i, yg, x, i, yg, xg
Variablen
• Gleicher Variablenname, anderer Scope– nur bei Zählvariablen verwenden
int main() { { int i = 0; } { int i = 0; }}
Variablen
• Gleicher Variablenname, geschachtelter Scope– nie verwenden
int main() { { int i = 0; { int i = 0; } }}
REFERENZEN
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;
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 Ja Ja
Variablen typ& name = ziel; typ* name;
Beispiel int x,y;int& z = x;z = 2; // z = y; nicht erlaubt
int x,y;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
Funktionenint summe(int a, int b){ return a + b;}
int main(){ int i = summe(1,2);}
Funktionenint 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– 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 0
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 0
i 0001 0
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 0
i 0001 0
y 0002 0
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 0
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 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
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 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
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: }
WIEDERHOLUNGVorlesung 6
Ü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 1int 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 definierenstruct Vektor{ int x; int y;};
// Ein Objekt (Instanz) vom neuen Typ erstellenVektor v;
Klassen
• Class
// Neuen Typ definierenclass Vektor {private: int x; int y;};
// Ein Objekt (Instanz) vom neuen Typ erstellenVektor v;
Methoden
• Wie Funktionen– 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– spezielle Methode– wird automatisch aufgerufen, wenn Objekt erstellt
wird• Destruktor– spezielle Methode– wird automatisch aufgerufen, wenn Objekt
gelöscht wird
Konstruktoren
• Syntax Konstruktor– 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;}
Konstruktorenclass 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– jeder kann die Daten benutzen
• private– nur die eigene Klasse– z.B. in Methoden
• protected– kommt später
Zugriffsrechteclass Vektor {public: int x;private: int y;};
int main() { Vektor v; v.x = 1; // v.y = 2; nicht erlaubt}
ÜBUNGSerie 7