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