Übungsstunde: Informatik 1 D-MAVT

Size: px

Start display at page:

Download "Übungsstunde: Informatik 1 D-MAVT"

Philippa Burns
5 years ago
Views:

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 Sorting Multidimensionale Arrays und Vektoren Darstellung einer Matrix in einem Array Strings Lindenmayer Systems and Turtle graphics Pointer / Zeiger Übung 7 Vorstellung und Tipps Daniel Bogado Duffner

3 Arrays - Kurzübersicht Arrays sind 0 indexiert (Zählung fängt bei 0 an) Arrays können immer nur Ausdrücke von einem Typ (int, bool, ) speichern int test1[]; geht nicht. Grösse muss bei Compilezeit festliegen! 3

4 Algorithm Bubble Sort

5 Algorithm Bubble Sort int a[] = {6, 1, 3, 2, 1}; for (int i = 4; i >= 0; --i) for (int j = 0; j < i; ++j) if (a[j] > a[j+1]) { int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } 5

6 Algorithm Bubble Sort int a[] = {6, 1, 3, 2, 1}; for (int i = 4; i >= 0; --i) for (int j = 0; j < i; ++j) if (a[j] > a[j+1]) { int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } Note: Do not consider previous maxima

7 Nachtrag letzte Woche 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

8 Mehrdimensionale Arrays/Vektoren Mehrdimensionale Arrays: Mehrdimensionale Vektoren: int array[4][3] for (int i = 0; i < 4; i++) for (int j = 0; j < 3; j++) std::cin >> array[i][j]; int m = 4; int n = 3; std::vector< std::vector<int> > vector (m, std::vector<int>(n)); for (unsigned int i = 0; i < m; i++) for (unsigned int j = 0; j < n; j++) std::cin >> vector[i][j]; Daniel Bogado Duffner

9 Representation of a Matrix in an Array

10 Matrix in an Array Matrix (m x n) i i, j, k start from 0. j Index: k = i n + j k =? Array (length mn) 10

11 Strings Müssen mit #include <string> hinzugefügt werden Funktionieren wie Vektoren (.push_back(),.at() ) Besitzen einen += Operator, mit dem Text angefügt werden kann Können ohne Schleife ausgegeben werden Daniel Bogado Duffner

12 Strings 1 #include <iostream> 2 #include <string> 3 4 int main () { 5 6 std::string text; 7 std::cin >> text; // reads in a text of arbitrary length, for example "Hello" 8 9 text += " world!"; // appends text to the string, in this case changing it to 10 // "Hello world!" std::string text2 = text; // initialization also works with a string variable on 13 // the right hand side, in this case text2 = text std::cout << text2 << "\n"; // outputs whole text stored in text2, here 16 // "Hello world!" 17 return 0; 18 } Daniel Bogado Duffner

13 Strings 1 #include <iostream> 2 #include <string> 3 4 int main () { 5 6 std::string str ("The quick brown fox jumps over the lazy dog."); 7 8 std::cout << str.find("fox") << "\n"; // outputs 16 9 std::cout << str.find("fox", 30) << "\n"; // outputs std::string::npos 10 // (substring not found) 11 str.replace(10, 5, "red"); 12 std::cout << str << "\n"; //outputs "The quick red fox jumps over the lazy dog str.erase(10,4); 15 std::cout << str << "\n"; // outputs "The quick fox jumps over the lazy dog." return 0; 18 } Daniel Bogado Duffner

14 We have the following functions: Strings find (const string& string, int pos = 0), // gibt die Stelle in der das gesuchte Wort beginnt an replace (int pos, int count, const string& string) // ersetzt Wort im Bereich [pos, pos+count) erase (int pos, int count) // löscht den Bereich [pos, pos+count) Daniel Bogado Duffner

15 Lindenmayer Systems

16 Lindenmayer Systems Characterized by three parameters: 1. Alphabet - the allowed symbols 2. Production P - how to replace each symbol 3. Initial word s - the word to start with Example: 1. 1.

17 Lindenmayer Systems Characterized by three parameters: 1. Alphabet - the allowed symbols 2. Production P - how to replace each symbol 3. Initial word s - the word to start with lexamplele: 1. 1.

18 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++

19 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

20 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

21 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

22 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

23 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

24 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

25 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

26 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

27 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

28 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

29 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

30 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

31 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

32 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

33 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

34 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

35 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

36 Lindenmayer Systems How does it look after 3 rounds? s: w : 1 : w 2 w 3 : F F+F+ F+F++F+F++ F+F++F+F+++F+F++F+F+++ 1.

37 Draw Lindenmayer Systems

38 Two Step Procedure Goal: Draw n-th step of Lindenmayer system Done in 2 steps: 1. Obtain n-th step 2. Draw it

39 Step 1 Obtain n-th Word Write and use the following two functions std::string production (const char c) In: symbol e.g. F Out: its production e.g. F+F+

40 Step 1 Obtain n-th Word Write and use the following two functions std::string production (const char c) In: symbol e.g. F Out: its production e.g. F+F+ std::string next_word (std::string& word) In: w (Word of step n) e.g. FF Out: w (Word n of step n+1) e.g. F+F+F+F+ Applies production n+1 to each character in w and concatenates the results. n

41 Step 2 Draw It Idea: view alphabet as turtle commands Example: Alphabet: := { F, +, - } F: turtle::forward() +: turtle::left(90) - : turtle::right(90)

42 Turtle Commands (aus: Skriptaufgabe 5) 42

43 Moving the Turtle C++ Commands Step (drawn): Step (not drawn):turtle::jump(); Rotation left: turtle::left(my_angle); Rotation right: turtle::right(my_angle); Save position: turtle::save(); Load position: turtle::restore(); Color cycling: turtle::colorcycle(); Requires: #include "turtle.cpp" 43

44 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 44

45 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 45

46 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 46

47 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 47

48 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 48

49 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 49

50 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 50

51 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 51

52 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 52

53 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 53

54 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 54

55 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 55

56 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 56

57 Moving the Turtle turtle::save(); turtle::left(45); turtle::jump(); turtle::save(); turtle::right(45); turtle::forward(2); turtle::restore(); turtle::restore(); turtle::right(45); 57

58 Pointer / Zeiger Ähnlich wie Referenzen, aber können auch im Nachhinein verändert werden int i = 5; int j = 7; int& k = i; // k is initialized to reference i k = j; // the value of i is changed to 7 Damit das möglich ist, müssen wir die Speicheradresse unserer Variable kennen Pointer müssen immer einen Typ haben, obwohl sie auf eine Adresse zeigen Pointer müssen die Länge des Ziels kennen (wie viel Bytes) Daniel Bogado Duffner

59 Introduction to Pointers

60 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; 60

61 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; 61

62 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; 62

63 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; x Visualization 63

64 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; x 64

65 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; x 65

66 Pointer Program int a = 5; int* x = &a; char c = 'd'; char* z = &c; x z 66

67 Shifting Pointers

68 Pointer Program ++x; ++z; x z 68

69 Pointer Program ++x; ++z; ++x z 69

70 Pointer Program ++x; ++z; ++x ++z 70

71 Pointer Program ++x; ++z; Warning: We don t know the value at ++x ++z 71

72 Pointer / Zeiger Wie unterscheiden zwischen Adressänderung und Wertänderung? Zwei neue Operatoren: Referenz / Adress Operator & Dereferenzierung oder Wert Operator * Daniel Bogado Duffner

73 Pointer / Zeiger Referenz / Adress Operator & Dereferenzierung oder Wert Operator * int a = 5; int b = 7; int* x = 0; x = &a; std::cout << a << "\n"; // outputs 5 std::cout << *x << "\n"; // outputs 5 too // always initialize empty pointers to zero! // the address of a is written to x; x points to a std::cout << x << "\n"; // outputs 0x28fef8 (address of a) std::cout << &a << "\n"; // outputs 0x28fef8 (address of a) too x = &b; // x now points to b *x = 1; // changes value of b to 1 Daniel Bogado Duffner

74 Pointer und/auf Arrays Pointer und Arrays sind sich ähnlich bzw können ineinander konvertiert werden int arr[] = {7,1,0,2,5}; int* point = arr; std::cout << *point << "\n"; // outputs 7 std::cout << *(point + 3) << "\n"; // outputs 2 // arr gets converted to the address of the // first array element a[0] (arr == &arr[0]) int arr[] = {9,2,4,5,1,2,6}; for (int i = 0; i < 7; ++i) std::cout << arr[i] << "\n"; for (int* i = arr; i < arr + 7; ++i) std::cout << *i << "\n"; Daniel Bogado Duffner

75 Pointers on Arrays

76 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers

77 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers a

78 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr a

79 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr a

80 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr a my_int 80

81 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr a my_int 81

82 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr a my_int 82

83 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr past a my_int 83

84 Pointer Program Output: true int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers Because ptr is "to the left" of past. ptr past a my_int 84

85 Pointer Program "To the left" means: smaller index of element Output: true int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; pointed to // array-to-pointer conv ++ptr; in array // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers Because ptr is "to the left" of past. ptr past a my_int 85

Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a;

shift to the right int my_int = *ptr; // read target ptr

$target int* past = a+5; std::cout << (ptr < past) << "\n";$ means: smaller index of element Output: true Because ptr

86 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; pointed to // array-to-pointer conv ++ptr; in array // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers Here: Index 3 < Index 5 "To the left" means: smaller index of element Output: true Because ptr is "to the left" of past. ptr past a my_int 86

87 Pointer Program int a[5] = {0, 8, 7, 2, -1}; int* ptr = a; // array-to-pointer conv ++ptr; // shift to the right int my_int = *ptr; // read target ptr += 2; // shift by 2 elements *ptr = 18; // overwrite target int* past = a+5; std::cout << (ptr < past) << "\n"; // compare pointers ptr past a my_int 87

88 Übung 7 - Tipps und Tricks Aufgabe 1: Ziel: Matrix und Vector Operationen (Kreuzprodukt, ) schreiben Tipp: Schreibt für das einlesen und ausgeben der Arrays eine Funktion + Schreibt für jede Operation eine Funktion + Schreibt für jeden Aufruf einer der Aufgaben eine Funktion Aufgabe 2: Ziel: Decoden eines Zeitungsartikels in Binär System Tipp: Stumpf Übersetzung von 8 bit Binärzahl zu Char, Filestream Aufgabe 3 (optional): Ziel: Eine Schöne Zeichnung aus Turtle durch Lindenmayer System Tipp: probiert ein wenig rum (Demo siehe slides), nicht zu viel Zeit darauf verwenden Daniel Bogado Duffner

89 Streams and Files <fstream> Streaming data from/to files (read/write) Almost identical to console I/O Except file streams have to be instantiated and opened by the user program // Instantiate ofstream object "fout" ofstream fout; fout.open("myfile.dat"); fout << var; // writing to file cout << var; // writing to screen 89 M. Gross, ETH Zürich, 2017

90 Step-by-Step Streaming to Files 1. Include header #include <fstream> 2. Create fstream instance ofstream fout; 3. Open file fout.open("mydat"); 4. Transfer data from/to file fout << "Hello!\n"; 5. Close file fout.close(); 90 M. Gross, ETH Zürich, 2017

$is_open()) { cerr << "IO error\n"; return 1; } int a = 12345; #include <iostream> #include <fstream> using namespace std; int$

91 Example: Simple Write and Read #include <iostream> #include <fstream> using namespace std; int main() { ofstream fout; fout.open("mydat"); if(!fout.is_open()) { cerr << "IO error\n"; return 1; } int a = 12345; #include <iostream> #include <fstream> using namespace std; int main() { ifstream fin; fin.open("mydat"); if(!fin.is_open()) { cerr << "IO error\n"; return 1; } int a; fout << a; fout.close(); // Write to file fin >> a; fin.close(); // Read from file } return 0; } return 0; 91 M. Gross, ETH Zürich, 2017

File I/O Christian Schumacher, Info1 D-MAVT 2013

File I/O Christian Schumacher, chschuma@inf.ethz.ch Info1 D-MAVT 2013 Input and Output in C++ Stream objects Formatted output Writing and reading files References General Remarks I/O operations are essential