Übungsstunde: Informatik 1 D-MAVT

Transkript

1 Übungsstunde: Informatik 1 D-MAVT Daniel Bogado Duffner Übungsslides unter: n.ethz.ch/~bodaniel Bei Fragen: bodaniel@student.ethz.ch Daniel Bogado Duffner

2 Ablauf Self-Assessment Pointer Iterators for Vectors Typedef const Pointers Übung 8 Vorstellung und Tipps Daniel Bogado Duffner

3 Pointers Recap Vektoren können nicht zu Beginn unterschiedliche Zahlen zugewiesen bekommen int a[]={1,4,5; // Als Array geht das std::vector<int> numbers (n, 0); // Als Vektor geht das nicht Daniel Bogado Duffner

4 Pointer Program

5 Pointer Program Find and fix at least 3 problems in the following program. #include <iostream> int main () { int a[7] = {0, 6, 5, 3, 2, 4, 1; // static array int b[7]; int* c = b; // copy a into b using pointers for (int* p = a; p <= a+7; ++p) *c++ = *p; // cross-check with random access for (int i = 0; i <= 7; ++i) if (a[i]!= c[i]) std::cout << "Oops, copy error...\n"; return 0; (From: Script Exercise 117) 5

6 Pointer Program #include <iostream> int main () { int a[7] = {0, 6, 5, 3, 2, 4, 1; // static array int b[7]; int* c = b; p = a+7 is dereferenced // copy a into b using pointers for (int* p = a; p <= a+7; ++p) *c++ = *p; // cross-check with random access for (int i = 0; i <= 7; ++i) if (a[i]!= c[i]) std::cout << "Oops, copy error...\n"; Solution: Use < instead of <= return 0; (From: Script Exercise 117) 6

7 Pointer Program #include <iostream> int main () { int a[7] = {0, 6, 5, 3, 2, 4, 1; // static array int b[7]; int* c = b; p = a+7 is dereferenced // copy a into b using pointers for (int* p = a; p <= a+7; ++p) *c++ = *p; Solution: Use < instead of <= // cross-check with random access for (int i = 0; i <= 7; ++i) if (a[i]!= c[i]) std::cout << "Oops, copy error...\n"; Same problem as above return 0; (From: Script Exercise 117) 7

8 Pointer Program c doesn t point to a[0] anymore. Solution: Use b instead of c #include <iostream> int main () { int a[7] = {0, 6, 5, 3, 2, 4, 1; // static array int b[7]; int* c = b; p = a+7 is dereferenced // copy a into b using pointers for (int* p = a; p <= a+7; ++p) *c++ = *p; Solution: Use < instead of <= // cross-check with random access for (int i = 0; i <= 7; ++i) if (a[i]!= c[i]) std::cout << "Oops, copy error...\n"; Same problem as above return 0; (From: Script Exercise 117) 8

9 Operator ++ for Pointers

10 ++ for Pointers Same idea... 10

11 ++ for Pointers Same idea... but: value of pointer is an address. 11

12 ++ for Pointers Same idea... but: value of pointer is an address. Shift pointer to next object. ptr ptr

13 ++ptr ptr ptr 13

14 ++ptr ++ptr ptr ptr 14

15 Exercise Applying Pointers

16 Exercise Applying Pointers Apply this function // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; to this example-array: b e o o+(e-b) (From: Script Exercise 113) 16

17 Exercise Applying Pointers void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; b e o (From: Script Exercise 113) 17

18 Exercise Applying Pointers true void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; b e o (From: Script Exercise 113) 18

22 Exercise Applying Pointers true void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; b e o (From: Script Exercise 113) 22

23 Exercise Applying Pointers void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; b o (From: Script Exercise 113) 23

26 Exercise Applying Pointers false void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; b o (From: Script Exercise 113) 26

27 Exercise Applying Pointers Now determine a POST-condition for the function. // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 27

28 Exercise Applying Pointers Something like this: // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges // POST: The range [b, e) is copied in reverse // order into the range [o, o+(e-b)) void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 28

29 Exercise Valid Inputs

30 Exercise Valid Inputs Which of these inputs are valid? int a[5] = {1, 2, 3, 4, 5; a) f(a, a+5, a+5); b) f(a, a+2, a+3); c) f(a, a+3, a+2); // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 30

31 Exercise Valid Inputs Which of these inputs are valid? int a[5] = {1, 2, 3, 4, 5; a) f(a, a+5, a+5); b) f(a, a+2, a+3); c) f(a, a+3, a+2); [o,o+(e-b)) is out of bounds // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 31

32 Exercise Valid Inputs Which of these inputs are valid? int a[5] = {1, 2, 3, 4, 5; a) f(a, a+5, a+5); b) f(a, a+2, a+3); c) f(a, a+3, a+2); [o,o+(e-b)) is out of bounds // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 32

33 Exercise Valid Inputs Which of these inputs are valid? int a[5] = {1, 2, 3, 4, 5; a) f(a, a+5, a+5); b) f(a, a+2, a+3); c) f(a, a+3, a+2); // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; [o,o+(e-b)) is out of bounds Ranges not disjoint (From: Script Exercise 113) 33

34 Overview call by Call by Value void swapv(int a, int b){... int main(){ swapv(wallet1, wallet2); // Funktionsvariablen enthalten nur die Werte der ursprünglichen Variablen (Kopie der Werte) Call by Reference - References void swapr(int &a, int &b){ int i=a; int main(){ swapv(wallet1, wallet2); // Funktionsvariablen sind wie die ursprünglichen Variablen (Kopie der Variablen) Call by Reference - Pointers void swapp(int *p, int *q) { int a=*p; int main(){ swapp(&wallet1, &wallet2); // Funktionsvariablen zeigen (Pointer) auf die ursprünglichen Variablen (Kopie der Variablenadresse) 34 M. Gross, ETH Zürich, 2017

35 Call by reference Es gibt zwei Arten von Call by reference Lieber Call by reference reference statt Call by reference pointers Referenz ist weniger Fehleranfällig (keine Dereferenzierung / kein Wert Operator * nötig) Ausnahme: Wenn auf bestimmte Elemente/Teile eines Arrays Bezug genommen wird (Pointer a zeigt auf 3. Element, Pointer b auf 8. El.) Daniel Bogado Duffner

36 Iterators for Vectors Vektoren kennen ein ähnliches Konzept wie Pointer, namens Iterators Vektoren und Iteratoren sind zueinander fast wie Arrays zu Pointern Man kann vector.begin() und vector.end() schreiben -> kein & nötig für die Adresse Daniel Bogado Duffner

37 Iterators for Vectors Man kann vector.begin() und vector.end() schreiben -> kein & nötig für die Adresse + leichter lesbar #include <vector> // (for reference: the corresponding pointer example) // int array[] = {8,3,1,4,6,9; // for (int* p = array; p!= array + 6; ++p) // std::cout << *p; std::vector<int> vec = {8,3,1,4,6,9; // C++11 syntax! for (std::vector<int>::iterator it = vec.begin(); it < vec.end(); ++it) std::cout << *it; Daniel Bogado Duffner

38 Iterator Program

39 Iterator Program Given a vector std::vector<int> a = {1,2,3,4,5,6,7; Output this vector in the following alternating fashion using iterators: first, last, second, second-to-last, third, third-to-last,... i.e

40 Iterator Program using Intvec = std::vector<int>; using const_intvecit = std::vector<int>::const_iterator; Intvec a = {1, 2, 3, 4, 5, 6, 7; // Define Iterators const_intvecit front = a.begin(); // Iterator (read-only) to 1 const_intvecit back = a.end() - 1; // Iterator (read-only) to 7 while (front <= back) { // Special Case if (front == back) { // prevents outputting middle element twice std::cout << *front << " "; break; // Output std::cout << *front << " " << *back << " "; // Advance Iterators ++front; --back; 40

41 Using Für komplizierte Typen wie std::vector<int>::iterator kann man den Befehl using verwenden Umbennenung des Typs: using intvec = std::vector<int>; using intvecit = std::vector<int>::iterator; intvec vec = {7,3,5,2,7,9; for (intvecit it = vec.begin(); it < vec.end(); ++it) std::cout << *it; Vorteile: Besser lesbar + Wir können Typen allgemein ändern Daniel Bogado Duffner

42 Const pointers Pointer sind wie veränderbare Referenzen aber: Auch Pointer können const sein Frage: Ist dann der Wert an der Stelle auf die der Pointer zeigt const oder die Stelle auf die der Pointer zeigt? Beides geht! Daniel Bogado Duffner

43 Const pointers int x = 7; int y = 5; const int* i = &x; ++(*i); i = &y; int* const j = &x; ++(*j); j = &y; const int* const k = &x; ++(*k); k = &y; // does not compile, value stored in x cannot // be changed via this pointer access // works // works // does not compile, address stored in j is const // one can also do both // does not compile, value stored in x cannot // be changed via this pointer access // does not compile, address stored in k is const Daniel Bogado Duffner

44 Const pointers Wenn const vor dem Typ (z.b. int) steht, dann kann der Wert an der Stelle auf die der Pointer zeigt nicht verändert werden Wenn const nach dem Typ (z.b. int) steht, dann kann die Adresse/der Ort auf den der Pointer zeigt nicht verändert werden Iteratoren können auch in beiden Punkten const sein Pointer auf eine const Variable müssen selbst auch const sein: const int a = 5; int* a_ptr = &a; // Error: must be: const int* a_ptr = a; Daniel Bogado Duffner

45 Exercise const Correctness

46 Exercise const Correctness Make the function const-correct. // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 46

47 Exercise const Correctness Make the function const-correct. const: no write-access to target const: no shifts of pointer // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (const int* const b, const int* e, int* o) { while (b!= e) { --e; *o = *e; ++o; (From: Script Exercise 113) 47

48 By the way

49 By the way that s the same function: // PRE: [b, e) and [o, o+(e-b)) are disjoint // valid ranges void f (int* b, int* e, int* o) { while (b!= e) *(o++) = *(--e); (From: Script Exercise 113) 49

50 Übung 8 - Tipps und Tricks Aufgabe 1: Ziel: zeigt ob ihr Pointer wirklich verstanden habt! Tipp: Versucht es so gut es geht zu lösen und notiert euch alle Fragen bzw schickt sie mir an bodaniel@ethz.ch Aufgabe 2: Aufgabe 3: Ziel: Sortieren von Zahlen in Array durch Pointer, ein bisschen wie in exercise 6, task 5 Tipp: Orientiert euch für die Sortieralgorithmen am Prinzip von letzter Woche für sorting und an Übung 6,5, ihr müsst nichts neu erfinden Ziel: Anwedung von Iteratoren (Vergleich der Wortreihenfolge) Tipp: Schaut euch die Funktionsweise von Strings an (siehe letzte Woche) Daniel Bogado Duffner