WEBVTT 00:10.140 --> 00:14.720 Also letztes Mal haben wir uns die ersten Schritte gewagt, uns 00:14.720 --> 00:17.620 herangetastet an C++, haben unsere ersten Programme geschrieben, 00:17.780 --> 00:21.620 sozusagen unsere erste Erfahrung gemacht mit C++. 00:23.860 --> 00:26.220 Hier sind noch ein paar Geräte für diejenigen, die keine haben. 00:27.700 --> 00:29.620 Kann man sich auch hier abholen, falls noch jemand kommt. 00:31.620 --> 00:37.500 Und unser Beispiel letzte Woche war Umrechnung von Temperaturwerten. 00:38.000 --> 00:40.620 Da haben wir also insbesondere gelernt, was überhaupt eine Variable 00:40.620 --> 00:40.960 ist. 00:41.940 --> 00:44.200 Wie gesagt, für diejenigen unter Ihnen, die schon mal programmiert 00:44.200 --> 00:47.560 haben, das war ja nach unserer Umfrage ungefähr ein Drittel, ist das 00:47.560 --> 00:50.080 natürlich in Fleisch und Blut übergegangen. 00:50.180 --> 00:52.640 Was ist eine Variable, was kann ich mit der tun, was muss ich da 00:52.640 --> 00:52.900 machen? 00:53.460 --> 00:57.160 Und zwar haben wir erstmal festgestellt, dass wir Variablen in C++ 00:57.160 --> 00:58.200 definieren müssen. 00:58.400 --> 01:01.000 Das heißt, wir müssen den Compiler, bevor wir eine Variable benutzen, 01:01.780 --> 01:07.320 mitteilen, dass diese Variable existiert, welchen Namen die hat, weil 01:07.320 --> 01:10.260 mit dem Namen sprechen wir dann als Programmierer den Wert an. 01:10.780 --> 01:13.900 Und wir mussten dem Compiler mitteilen, welchen Datentyp die Variable 01:13.900 --> 01:14.160 hat. 01:14.540 --> 01:16.800 Das heißt, was möchten wir speichern in dieser Variable? 01:17.660 --> 01:18.980 Und das hat natürlich Konsequenzen. 01:19.080 --> 01:21.860 Wir haben uns überlegt, was heißt das eigentlich, Daten zu speichern? 01:22.160 --> 01:25.500 Datenspeichern heißt ja, im Hauptspeicher des Rechners Platz zu 01:25.500 --> 01:26.000 reservieren. 01:26.920 --> 01:29.520 Und um zu wissen, wie viel Platz reserviert werden muss, muss der 01:29.520 --> 01:32.540 Compiler wissen, welche Daten wir da speichern möchten. 01:32.540 --> 01:35.420 Es ist also nicht das gleiche, ob wir eine Ganzzahl speichern oder 01:35.420 --> 01:40.020 eine Gleitkommazahl oder ein Zeichen oder eben andere Dinge. 01:41.920 --> 01:44.940 Bevor wir das erste Mal mit einer Variable arbeiten, das heißt sie 01:44.940 --> 01:47.140 aufrufen oder den Wert ändern, müssen wir sie definieren. 01:48.200 --> 01:49.080 Das kann ich Ihnen schon mal sagen. 01:49.180 --> 01:51.380 Es gibt auch Programmiersprachen, bei denen man das nicht machen muss. 01:52.820 --> 01:53.840 C++ gehört aber nicht dazu. 01:53.940 --> 01:56.160 Das ist eine Sprache, bei der man immer den Typ angeben muss und die 01:56.160 --> 01:58.760 Variable immer erst definieren muss, bevor man sie benutzt. 02:00.000 --> 02:02.040 Und danach, wenn man die einmal definiert hat, kann man die im 02:02.040 --> 02:05.080 Programmlauf so oft wie man möchte benutzen. 02:05.180 --> 02:08.860 Das heißt die Werte benutzen, in weiteren Ausdrücken ausgeben, die 02:08.860 --> 02:10.620 Werte ändern, Zuweisungen und so weiter. 02:11.840 --> 02:14.300 Dann hatten wir auch kennengelernt, einfache Ein- und 02:14.300 --> 02:16.060 Ausgabeoperationen. 02:16.280 --> 02:19.400 Und da hatten wir gesehen, dass wir dazu eine Bibliothek brauchen. 02:19.600 --> 02:23.120 Das heißt in C++ selber ist eigentlich diese Ein- und Ausgabe, das 02:23.120 --> 02:24.880 heißt die Kommunikation mit dem Programm, z.B. 02:24.980 --> 02:29.220 per Tastatur oder dann umgekehrt das Lesen auf dem Bildschirm, nicht 02:29.220 --> 02:32.200 direkt eingebaut, sondern dazu lädt man eine Bibliothek hinzu, die 02:32.200 --> 02:33.740 nennt sich Iostream. 02:35.240 --> 02:38.080 Da das immer der Fall sein wird, dass Sie mit Ihrem Programm irgendwie 02:38.080 --> 02:40.360 kommunizieren, können Sie sich schon mal direkt angewöhnen, diese 02:40.360 --> 02:42.280 Bibliothek praktisch standardmäßig zu laden. 02:42.900 --> 02:45.160 Werden wir gleich nochmal sehen, da gibt es eine Zeile in Ihrem 02:45.160 --> 02:47.440 Programm am Anfang, die Ihnen zur Verfügung steht. 02:48.500 --> 02:51.420 Und dann hatten wir kennengelernt, ganz einfache arithmetische 02:51.420 --> 02:54.580 Operationen, das heißt Operationen mit Zahlenwerten. 02:56.700 --> 02:58.780 Da wären wir gleich nochmal zu kommen, weil wir da nicht ganz 02:58.780 --> 02:59.520 durchgekommen sind. 03:00.980 --> 03:02.960 Jetzt starten wir vielleicht mit unserem beliebten Quiz. 03:03.900 --> 03:05.000 Quiz 1 steht hier. 03:05.280 --> 03:06.880 Die meisten von Ihnen haben wahrscheinlich jetzt so ein Gerät. 03:07.740 --> 03:10.040 Wer keins hat und unbedingt mitwählen will, hier unten sind noch ein 03:10.040 --> 03:10.240 paar. 03:11.480 --> 03:14.420 Also das erste Quiz lautet wie hier dargestellt. 03:14.520 --> 03:18.400 Hier ist so ein kleiner Programm-Ausschnitt mit zwei Zeilen. 03:19.600 --> 03:22.960 Und die Frage ist, welchen Wert hat die Variable E nach der Zeile 2? 03:27.770 --> 03:32.310 Sie können schon gerne wählen, wir starten das jetzt. 03:35.850 --> 03:38.590 Wir müssten etwa bei 160 Teilnehmern heute sein. 03:39.250 --> 03:41.130 Also das ist eigentlich okay, ich glaube wir können weitergehen. 03:46.430 --> 03:49.650 56, das ist die überwältigende Mehrheit, die da antwortet. 03:50.650 --> 03:52.070 Und das ist natürlich korrekt. 03:52.590 --> 03:57.010 Gehen wir nochmal kurz zurück auf den anderen Anschluss. 04:00.620 --> 04:03.840 Also Sie haben natürlich korrekt gesehen, so wie Sie es aus der 04:03.840 --> 04:06.520 Mathematik erwarten würden, dass die Punktrechnung, also hier die 04:06.520 --> 04:09.360 Multiplikation, Vorrang hat vor der Strichrechnung, also vor der 04:09.360 --> 04:09.960 Subtraktion. 04:10.640 --> 04:13.240 Das heißt Sie multiplizieren 3 mal 20 und ziehen dann die 4 ab. 04:13.340 --> 04:14.300 Es gibt also eine 56. 04:15.400 --> 04:16.980 Und wir haben direkt noch ein zweites Quiz. 04:18.260 --> 04:20.100 Hier haben wir jetzt zwei Divisionen drin. 04:20.200 --> 04:22.880 Sie erinnern sich, dieses nach vorne geneigte Schrägstrich ist die 04:22.880 --> 04:23.260 Division. 04:24.560 --> 04:26.160 Und die Frage ist jetzt die gleiche. 04:26.240 --> 04:29.100 Wie lautet der Wert von g nach der zweiten Zeile? 04:38.640 --> 04:40.820 Also die meisten von Ihnen haben auf die 3 getippt. 04:41.040 --> 04:42.120 Das ist in der Tat korrekt. 04:43.840 --> 04:48.160 Gehen wir nochmal kurz zurück und schauen uns an, wieso das so ist. 04:58.350 --> 05:00.890 Also die Frage ist ja im Prinzip, in welcher Reihenfolge wird das 05:00.890 --> 05:01.510 ausgewertet. 05:02.790 --> 05:04.050 Sie haben also eine Division. 05:04.610 --> 05:06.590 Sie haben hier 27 durch 3 durch 3. 05:06.690 --> 05:09.230 Die Frage ist, wird das jetzt von links nach rechts oder von rechts 05:09.230 --> 05:10.210 nach links ausgewertet. 05:10.750 --> 05:15.030 Und in der Tat ist es so, dass es für jeden Operator feste Regeln 05:15.030 --> 05:18.530 gibt, in der Sprache C++ und auch in anderen Sprachen natürlich, die 05:18.530 --> 05:21.630 in so einer Situation oder nach der, in so einer Situation der 05:21.630 --> 05:22.590 Compiler das entscheidet. 05:22.590 --> 05:27.110 Also hier ist die Frage, setzen wir praktisch die Klammern um den 05:27.110 --> 05:29.830 ersten Ausdruck oder setzen wir die um den zweiten Ausdruck. 05:35.380 --> 05:38.860 Wir haben also diesen Ausdruck und in der Tat setzt der Compiler die 05:38.860 --> 05:42.960 Klammern so, dass er zuerst hier auswertet und dann nochmal durch 3 05:42.960 --> 05:43.760 teilt. 05:44.960 --> 05:46.740 Und das ist festgelegt für die Division. 05:46.980 --> 05:49.440 Das heißt bei der Division, wenn die mehrfach auftaucht in einem 05:49.440 --> 05:52.910 Ausdruck hintereinander, dann wird von links nach rechts ausgewertet. 05:53.800 --> 05:54.700 War also korrekt. 06:02.010 --> 06:05.950 So, jetzt hatten wir einige arithmetische Operationen noch 06:05.950 --> 06:06.650 ausgelassen. 06:11.400 --> 06:12.920 Das sind nochmal die Folien vom letzten Mal. 06:12.960 --> 06:14.120 Ganz am Schluss ging es dann ein bisschen schnell. 06:14.940 --> 06:19.140 Also die Grundrechenarten sozusagen haben Sie jetzt schon drauf 06:19.140 --> 06:19.580 natürlich. 06:20.220 --> 06:23.200 Und insbesondere haben wir diese komischen doppelten Operatoren, diese 06:23.200 --> 06:26.900 doppelten Plus- und doppelten Minuszeichen noch nicht kennengelernt 06:26.900 --> 06:27.440 letztes Mal. 06:27.580 --> 06:28.780 Und die möchte ich Ihnen jetzt noch kurz erklären. 06:30.180 --> 06:31.080 Soweit waren wir schon gekommen. 06:32.520 --> 06:36.100 Also die nennen sich Inkrement-Operatoren oder Dekrement-Operatoren. 06:36.980 --> 06:40.360 Das sind im Endeffekt Abkürzungen, die dem Programmierer ein bisschen 06:40.360 --> 06:41.220 das Leben erleichtern. 06:41.920 --> 06:44.600 Das heißt, wenn Sie Programme schreiben, brauchen Sie die eigentlich 06:44.600 --> 06:45.080 nicht zu kennen. 06:46.140 --> 06:49.920 Da aber diese Operatoren sehr oft benutzt werden, das heißt, wenn Sie 06:49.920 --> 06:53.020 Programme von anderen bekommen oder vorgesetzt bekommen, werden da 06:53.020 --> 06:54.340 fast immer diese Operatoren drin sein. 06:54.420 --> 06:57.440 Und Sie werden sehen, sobald Sie die einmal sich gemerkt haben, sind 06:57.440 --> 06:58.100 die sehr praktisch. 06:58.100 --> 06:59.480 Also was macht das? 07:00.020 --> 07:01.620 Nehmen wir an, wir haben eine Ganzzahl a. 07:02.600 --> 07:04.500 Dann kann man schreiben plus plus a. 07:05.140 --> 07:08.380 Das ist jetzt nicht zweimal das positive Vorzeichen, was ja sozusagen 07:08.380 --> 07:12.540 nichts ändern würde, sondern das ist in C++ dieses plus plus 07:12.540 --> 07:15.220 zusammengenommen ein Operator, obwohl das zwei Zeichen auf Ihrer 07:15.220 --> 07:16.740 Tastatur sind, nämlich zweimal das plus. 07:17.180 --> 07:21.240 Und bedeutet, inkrementiere, das heißt erhöhe den Wert von diesem a um 07:21.240 --> 07:21.600 eins. 07:22.560 --> 07:23.620 Also zähle einfach eins dazu. 07:24.180 --> 07:28.060 Also plus plus a ist das gleiche wie a gleich a plus eins. 07:29.640 --> 07:33.000 Also eine Zuweisung, der Wert selber, plus ein eins dazu. 07:33.780 --> 07:36.760 Und minus minus ist das Umgekehrte, das heißt man zieht einen ab. 07:37.300 --> 07:40.640 Das heißt, dieses a dahinter muss also eine Ganzzahl sein und man kann 07:40.640 --> 07:42.040 eben einen dazuzählen, einen abzählen. 07:42.700 --> 07:45.000 Sie können sich jetzt schon vorstellen, wann braucht man das ganz oft, 07:45.480 --> 07:47.860 diejenigen, die vielleicht schon mal programmiert haben, in einer 07:47.860 --> 07:48.300 Schleife. 07:48.660 --> 07:53.200 Eine Schleife ist typischerweise eine Operation, also eine Konstrukt, 07:53.240 --> 07:56.860 bei der man eine Operation oft durchführt und bei der irgendwie so ein 07:56.860 --> 07:58.500 Laufindex hochgezählt wird. 07:59.300 --> 08:02.460 Zum Beispiel, Sie werten eine Summe aus, das Summenzeichen in der 08:02.460 --> 08:02.900 Mathematik. 08:03.580 --> 08:06.760 Da wird irgendwie über einen Ausdruck summiert und bei jedem Durchlauf 08:06.760 --> 08:10.120 dieser Summe, also jeder Summand hat irgendeinen Index, der um einen 08:10.120 --> 08:10.820 hochgezählt wird. 08:12.080 --> 08:14.740 So, jetzt gibt es davon zwei Geschmacksrichtungen von diesen 08:14.740 --> 08:17.240 Inkrementoperatoren und Dekrementoperatoren. 08:18.180 --> 08:21.280 Nämlich, man kann entweder dieses doppelte Plus oder doppelte Minus 08:21.280 --> 08:25.200 davor stellen oder danach stellen, nach dem Operand. 08:27.640 --> 08:33.540 Der Unterschied ist, dass die Operation selber, dieses Inkrementieren 08:33.540 --> 08:37.120 oder Dekrementieren, entweder vor dem weiteren Auswerten des 08:37.120 --> 08:39.260 Ausdruckes ausgeführt wird oder danach. 08:40.020 --> 08:42.620 Also es hat also nur eine Bedeutung bei zusammengesetzten Ausdrücken. 08:42.840 --> 08:44.740 Also hier unten ist das Beispiel, das macht die Sache, glaube ich, ein 08:44.740 --> 08:45.360 bisschen klarer. 08:45.360 --> 08:49.700 Wir haben hier irgendwie ein paar Ganzzahlen, nämlich i wird zu 1 08:49.700 --> 08:51.300 gesetzt und dann haben wir noch ein j und ein k. 08:51.740 --> 08:53.160 Die sind erstmal nicht initialisiert. 08:54.060 --> 08:57.340 So, hier steht auf einer Zeile einfach nur plus plus i und dann 08:57.340 --> 08:57.800 Semikolon. 08:57.920 --> 08:59.740 Das sieht sehr komisch aus, plus plus i. 09:00.380 --> 09:01.440 Daran muss man sich erstmal gewöhnen. 09:01.560 --> 09:04.840 Heißt im Endeffekt, i gleich i plus 1. 09:05.000 --> 09:05.820 Ist eigentlich nur eine Abkürzung. 09:08.140 --> 09:09.580 Gut, ich schalte jetzt nicht um. 09:10.100 --> 09:13.820 Also nach der Zeile 2, also in der Zeile 1 hat dieses i den Wert 1. 09:13.960 --> 09:15.620 Nach der Zeile 2 hat das i den Wert 2. 09:16.260 --> 09:17.640 Hier steht es nochmal, i gleich i plus 1. 09:18.360 --> 09:22.980 So, hier kommt jetzt ein Beispiel von einem zusammengesetzten Ausdruck 09:22.980 --> 09:25.800 und da spielt das eben eine Rolle, ob dieses plus plus vorgestellt ist 09:25.800 --> 09:26.700 oder nachgestellt ist. 09:27.340 --> 09:31.260 Also hier steht, j soll gleich etwas zugewiesen werden. 09:31.660 --> 09:34.020 Erinnern wir uns, da wird erstmal die rechte Seite ausgewertet und 09:34.020 --> 09:35.060 dann wird das dem j zugewiesen. 09:35.980 --> 09:37.820 Also machen wir es jetzt genau wie der Compiler. 09:37.820 --> 09:39.500 Wir werten erstmal die rechte Seite aus. 09:40.000 --> 09:42.480 Da steht jetzt i plus plus und dann plus 1. 09:43.160 --> 09:47.280 i plus plus heißt, schauen wir mal hier, wir hängen um den Wert 1 nach 09:47.280 --> 09:48.020 Weiterverwendung. 09:48.120 --> 09:52.460 Das heißt, zuerst wird der Wert von i genommen, plus 1 gezählt. 09:53.140 --> 09:57.040 Wir hatten hier eine 2, dann wird eine 1 dazugezählt, ergibt eine 3, 09:57.580 --> 09:58.600 das wird dem j zugewiesen. 09:59.040 --> 10:03.320 Also j wird 3 und danach wird erst das i selber um 1 hochgezählt. 10:03.320 --> 10:07.540 Das heißt, nach der Zeile 3 hat j den Wert 3 und i den Wert 3. 10:09.060 --> 10:13.800 Hätten wir das plus plus vor das i gestellt, wäre i erst hochgezählt 10:13.800 --> 10:16.140 worden, somit wäre j zu 4 geworden. 10:18.340 --> 10:20.700 Das hört sich jetzt sehr nach Haarspalterei an, Sie müssen das auch 10:20.700 --> 10:21.220 nicht benutzen. 10:21.780 --> 10:24.180 Es wird aber in Programmen, wenn Sie Programme von anderen bekommen, 10:24.260 --> 10:25.380 werden solche Dinge da drin sein. 10:25.640 --> 10:26.680 Einfach weil es existiert. 10:27.040 --> 10:28.140 Von daher sollten Sie es auch wissen. 10:29.520 --> 10:31.540 In der nächsten Zeile ist es dann umgekehrt. 10:31.600 --> 10:34.320 Da haben wir k, diese dritte Variable, die nicht gesetzt ist. 10:34.640 --> 10:35.680 Wollen wir auch ausrechnen. 10:36.200 --> 10:38.940 Da nehmen wir jetzt eben minus minus i plus 1. 10:39.100 --> 10:39.860 Also was wird gemacht? 10:40.400 --> 10:43.340 Das steht davor, dieses Minus, also wird es zuerst ausgewertet. 10:44.260 --> 10:47.720 Also wird von dem i, das hat den momentanen Wert 3, einer abgezogen, 10:47.820 --> 10:48.580 wird also zu 2. 10:49.200 --> 10:52.560 Danach wird die 1 dazugezählt, kriegen wir also eine 3, also wird k 10:52.560 --> 10:52.960 gleich 3. 10:54.000 --> 10:57.100 Also in dieser Stelle, wenn das so zusammengesetzt ist, spielt das 10:57.100 --> 11:01.240 eine Rolle, ob diese doppelten Inkrement- oder Dekrement-Ausdrücke vor 11:01.240 --> 11:03.060 dem Operanten stehen oder danach. 11:04.360 --> 11:09.020 Und das Ganze nennt man einen unnäheren Operatoren. 11:09.220 --> 11:10.880 Unnäher heißt, der hat nur einen Operanten. 11:11.480 --> 11:13.300 Und die meisten anderen haben zwei Operanten, zum Beispiel die 11:13.300 --> 11:14.760 Addition a plus b. 11:14.940 --> 11:17.560 Die zwei Operanten sind a und b und der Operator ist das Plus. 11:18.180 --> 11:21.800 Und das Plusplus ist ein unnäherer, da steht eben plus plus a, da ist 11:21.800 --> 11:22.460 nur ein Operant. 11:23.180 --> 11:24.020 Oder a plus plus. 11:25.180 --> 11:29.080 Das Vorzeichen ist auch ein unnäherer Operator, da steht eben minus 11:29.080 --> 11:32.260 Variable v oder plus Variable sonst. 11:34.020 --> 11:37.180 Also Inkrementierung und Dekrementierung erfolgt eben mit diesem 11:37.180 --> 11:38.360 doppelten Plus- oder Minuszeichen. 11:41.140 --> 11:43.680 Das war die eine Sache, die wir letztes Mal übersprungen haben. 11:45.240 --> 11:47.480 Wir werden sehen, wenn wir zu Schleifen kommen, das ist in der 11:47.480 --> 11:51.000 nächsten Vorlesung, also in zwei Wochen, dann werden Sie sehen, dass 11:51.000 --> 11:53.200 wir diesen Operator da sehr gut gebrauchen können. 11:56.180 --> 11:58.660 Hier war das Quiz vom letzten Mal, hatten wir schon. 12:00.260 --> 12:02.860 Wenn Sie wollen, können Sie sich mal an diesem Quiz testen, bzw. 12:02.860 --> 12:03.580 haben Sie jetzt schon gesehen. 12:04.240 --> 12:05.200 Mal gehen wir es einfach so durch. 12:05.660 --> 12:10.300 Hier wäre das Beispiel gewesen, Variable g wird zu 1 gesetzt. 12:10.740 --> 12:13.920 Dann steht hier plus plus g und dann wird g gleich g mal 3 genommen. 12:16.580 --> 12:17.700 Welches Endresultat haben wir? 12:21.080 --> 12:22.980 Ich bin jetzt schon einmal durchgeklickt, aber wir können es ja 12:22.980 --> 12:24.040 trotzdem mal machen zum Spaß. 12:24.980 --> 12:26.200 Sie dürfen gerne... 12:30.320 --> 12:31.860 Ist egal, das ist vom letzten Mal. 12:31.920 --> 12:32.760 Wir machen es nur so. 12:33.760 --> 12:35.800 Gehen Sie mal durch, schauen Sie mal, ob Sie es rauskriegen. 12:37.380 --> 12:41.480 g ist 1, dann wird der plus plus Operator angewendet und dann wird es 12:41.480 --> 12:42.100 mal 3 genommen. 12:42.260 --> 12:42.840 Was kommt raus? 12:53.550 --> 12:56.930 Wir gehen hier mit 1 rein, zählen 1 dazu, kommt 2 raus, stimmt's? 12:57.650 --> 13:00.650 Erstmal hier und dann gehen wir hier rein, dann steht hier eine 2 mal 13:00.650 --> 13:01.550 3 gibt eine 6. 13:03.770 --> 13:04.750 So läuft das. 13:06.510 --> 13:07.790 Okay, das war noch vom letzten Mal. 13:09.310 --> 13:10.670 Also 6 wäre hier richtig gewesen. 13:13.810 --> 13:16.470 So, jetzt kommt noch ein weiteres Thema, was wir letztes Mal auch 13:16.470 --> 13:16.950 übersprungen haben. 13:17.050 --> 13:19.950 Das war das letzte, was ich noch wiederholen wollte vom letzten Mal 13:19.950 --> 13:21.170 oder eigentlich aufarbeiten möchte. 13:21.970 --> 13:27.750 Und zwar, viele mathematische Funktionen sind auch nicht direkt in C++ 13:27.750 --> 13:29.110 eingebaut, sozusagen. 13:29.770 --> 13:31.310 Da muss man auch wieder eine Bibliothek laden. 13:31.830 --> 13:34.550 Das ist auch wieder eine Bibliothek, die Sie in fast jedem Programm 13:34.550 --> 13:36.170 benutzen werden, zumindest als Ingenieure. 13:36.310 --> 13:39.370 Von daher ist es auch eine, die Sie sich praktisch angewöhnen können, 13:39.490 --> 13:40.650 direkt immer einzubinden. 13:41.070 --> 13:43.890 Und zwar hatten wir schon eine Bibliothek kennengelernt, die heißt 13:43.890 --> 13:44.570 Iostream. 13:45.250 --> 13:48.890 Und diese Bibliothek, die wir heute kennenlernen, heißt CMath, sowie 13:48.890 --> 13:50.410 mathematische Bibliothek. 13:50.510 --> 13:53.530 Und das C davor deutet typischerweise an, dass die schon aus der 13:53.530 --> 13:54.710 Programmiersprache C kommt. 13:54.890 --> 13:57.930 Das heißt, es ist sozusagen eine Bibliothek, die es schon immer gab 13:57.930 --> 14:00.270 und die von C in C++ vererbt wurde, sozusagen. 14:00.870 --> 14:07.630 Also, wenn Sie diese Zeilen in Ihr Programm einbinden, dann kennt Ihr 14:07.630 --> 14:11.430 Programm eine ganze Reihe von Funktionen. 14:11.970 --> 14:15.270 Ich sage mal, die üblichen mathematischen Funktionen. 14:16.430 --> 14:18.270 Hier ist mal eine Auswahl davon. 14:18.410 --> 14:20.650 Trigonometrische Funktionen, wie Sinus, Cosinus und so weiter. 14:22.030 --> 14:26.750 Exponentialfunktion, Logarithmus, auch Rundungsfunktionen. 14:26.750 --> 14:27.210 Z.B. 14:28.930 --> 14:33.370 Seal für Ceiling, also sozusagen für Dach, heißt nach oben aufrunden, 14:33.430 --> 14:35.850 zunächst gelegenen Ganztag aufrunden. 14:35.990 --> 14:36.710 Das kommt z.B. 14:36.770 --> 14:37.450 in der Übung vor. 14:38.970 --> 14:43.650 Eine Sache ist erwähnenswert, C++ selber kennt noch nicht mal einen 14:43.650 --> 14:46.890 Operator für die Potenz. 14:47.590 --> 14:49.150 Also 10 hoch 5 z.B. 14:49.350 --> 14:51.390 können Sie eigentlich in C++ selber nicht ausdrücken. 14:51.390 --> 14:54.770 Es gibt Programmiersprachen, da gibt es ein Zeichen für die Potenz, z 14:54.770 --> 14:54.990 .B. 14:55.730 --> 14:58.530 ein Häkchen nach oben oder einen doppelten Stern. 14:58.990 --> 15:02.350 Aber in C++ gibt es eigentlich kein Zeichen, kein Symbol für die 15:02.350 --> 15:03.010 Potenzierung. 15:03.890 --> 15:08.490 Also 10 hoch 5 oder 7 hoch 23 können Sie nicht direkt darstellen. 15:08.590 --> 15:12.030 Dafür gibt es die Funktion POW für Power. 15:13.110 --> 15:16.910 Die nimmt dann zwei Operanten, die Basis und die Potenz. 15:17.950 --> 15:18.990 Das nur mal zur Erinnerung. 15:19.150 --> 15:22.010 Auf jeden Fall, Sie haben eine ganze Menge mathematische Funktionen, 15:22.050 --> 15:24.330 die Sie eben mit dieser Funktion dazuladen. 15:24.490 --> 15:25.250 Und wir kommen noch dazu. 15:25.650 --> 15:29.570 Das ist schon mal direkt zu erwähnen, dass Sie hier eigentlich alles 15:29.570 --> 15:30.270 haben, was Sie brauchen. 15:35.990 --> 15:38.550 Das war eigentlich alles, was ich noch sagen wollte vom letzten Mal. 15:48.670 --> 15:55.420 Dieses Mal haben wir das Thema Kontrolle des Programmflusses. 15:56.140 --> 15:56.920 Was bedeutet das? 15:57.480 --> 16:00.280 Wir hatten ja bisher eigentlich gesagt, wenn wir Programme schreiben, 16:00.420 --> 16:04.160 dann werden die während der Laufzeit sozusagen Zeile für Zeile 16:04.160 --> 16:04.360 abgearbeitet. 16:05.420 --> 16:07.800 Zumindest war das bei unseren bisher einfachen Programmen so. 16:08.900 --> 16:11.760 Sie schreiben Zeile für Zeile Anweisungen und die werden abgearbeitet. 16:12.100 --> 16:12.860 Schritt für Schritt. 16:13.300 --> 16:15.040 Das könnten Sie vielleicht schon ausprobieren in der Schnupperübung 16:15.040 --> 16:15.720 oder mal zu Hause. 16:15.720 --> 16:18.960 Sie können durch die Programme sogar in diesem Debugmodus von Ihrer 16:18.960 --> 16:21.860 Entwicklungsumgebung Schritt für Schritt durchklicken. 16:22.060 --> 16:24.020 Und immer stoppen, die Variablen untersuchen und so weiter. 16:24.880 --> 16:29.000 Es gibt da viele Gründe, dass man diesen Programmfluss ändert und 16:29.000 --> 16:32.300 vielleicht Sprünge einbaut oder sich wiederholende Programmteile oder 16:32.300 --> 16:35.780 Teile eben nur ausführt, wenn gewisse Bedingungen erfüllt sind. 16:36.060 --> 16:36.900 Und wenn nicht, dann eben nicht. 16:37.020 --> 16:38.240 Oder dann andere Teile ausführt. 16:38.560 --> 16:41.360 Das heißt typischerweise will man das sein Programm oder möchte man 16:41.360 --> 16:43.920 oder braucht man Möglichkeiten, sein Programm zu verzweigen. 16:43.920 --> 16:46.920 Und da starten wir heute mit den sogenannten Auswahlanweisungen. 16:47.680 --> 16:50.800 Das heißt Anweisungen, die uns Teile überspringen lassen, wenn gewisse 16:50.800 --> 16:51.980 Bedingungen erfüllt sind oder nicht. 16:53.740 --> 16:59.880 Hier nochmal der Tipp der Woche von dem C++-Guru Jan Strostrup. 17:01.260 --> 17:02.780 Avoid complicated expressions. 17:02.920 --> 17:06.200 Das heißt, wenn Sie irgendwelche Ausdrücke haben, die fünf Zeilen lang 17:06.200 --> 17:09.160 sind und viele, viele Operationen und Operanten beinhalten und viele 17:09.160 --> 17:13.760 Klammern benötigen, ist es oftmals sinnvoller, die in mehrere 17:13.760 --> 17:18.000 Teiloperationen runterzubrechen, sodass das Programm lesbarer ist. 17:18.600 --> 17:19.340 Das ist hier gemeint. 17:21.480 --> 17:23.620 Okay, also Fragen heute. 17:24.680 --> 17:26.820 Wie kann man überhaupt den Programmfluss von seinem Programm durch 17:26.820 --> 17:27.880 Verzweigungen ändern? 17:28.320 --> 17:33.200 Das heißt eben, während der Laufzeit auf gewisse Situationen reagieren 17:33.200 --> 17:35.100 und eben Entscheidungen treffen. 17:36.980 --> 17:39.840 Dann mehr spezifischer, wie kann man solche Bedingungen formulieren? 17:40.060 --> 17:41.480 Was für Arten von Bedingungen gibt es? 17:42.120 --> 17:45.080 Und das Beispiel, das wir heute machen, ist ein Taschenrechner zu 17:45.080 --> 17:45.620 programmieren. 17:49.020 --> 17:51.800 Starten wir vielleicht nochmal mit dem einfach visuell, von dem 17:51.800 --> 17:53.900 Flussdiagramm her, was der Unterschied ist. 17:54.220 --> 17:58.100 Wir hatten bisher erst ein kleineres Beispielprogramm oder zwei und 17:58.100 --> 18:00.480 die waren alle von so einer einfachen, relativ simplen Art. 18:00.620 --> 18:02.480 Das heißt, unser Flussdiagramm war eigentlich ziemlich langweilig. 18:02.480 --> 18:04.800 Wir hatten irgendwo einen Start und ein Ende und dazwischen war 18:04.800 --> 18:07.120 eigentlich nicht viel mehr als ein großer Block von Anweisungen, die 18:07.120 --> 18:08.380 Schritt für Schritt abgearbeitet wurden. 18:09.340 --> 18:11.640 Das ist selten der Fall, nur bei ganz einfachen Programmen. 18:12.280 --> 18:15.700 Typischer Fall ist eher so, das hatten wir auch mal als Beispiel in so 18:15.700 --> 18:16.200 einem Quiz. 18:16.980 --> 18:21.520 Das war im Endeffekt Auswertung des Betrages, einer Gleitkommazahl. 18:22.300 --> 18:24.920 Und hier haben wir zumindest eine Auswahlanweisung drin, mit einer 18:24.920 --> 18:25.280 Bedingung. 18:25.340 --> 18:27.860 Das heißt, wir hatten hier irgendwie einen Start des Programmes mit 18:27.860 --> 18:31.340 einer Eingabe und dann sehen Sie, die Bedingung stand immer in so 18:31.340 --> 18:34.780 einer Raute mit einer Verzweigung. 18:35.220 --> 18:39.080 Je nachdem, ob dieser Ausdruck hier wahr ist oder nicht, ja oder nein 18:39.080 --> 18:41.620 ergibt, tut das Programm unterschiedliche Dinge. 18:43.080 --> 18:45.340 Also hier ist da irgendwo unsere Verzweigung. 18:46.680 --> 18:48.980 Also nach heute lernen wir kennen, wie wir das in C++ realisieren. 18:49.520 --> 18:51.620 Wir hatten also schon gesehen, dass man das in vielen Algorithmen 18:51.620 --> 18:52.080 braucht. 18:53.020 --> 18:54.180 Man muss irgendwann eine Entscheidung treffen. 18:57.200 --> 19:00.300 Beispiel ist, einen Taschenrechner zu entwerfen. 19:00.960 --> 19:01.920 Der soll folgendes können. 19:03.100 --> 19:06.680 Natürlich haben Sie schon einen Taschenrechner, aber man muss ja mit 19:06.680 --> 19:07.380 irgendwas anfangen. 19:07.900 --> 19:09.320 Also unser Taschenrechner soll folgendes können. 19:10.040 --> 19:13.260 Der soll erstmal zwei reelle Zahlen einlesen vom Benutzer. 19:14.540 --> 19:15.680 Einlesen haben wir schon gelernt. 19:15.920 --> 19:17.440 Sie erinnern sich mit diesem C-In-Objekt. 19:19.500 --> 19:23.860 Das sind also die Operanten von der Operation, die der Taschenrechner 19:23.860 --> 19:24.360 ausführen soll. 19:24.980 --> 19:29.640 Als nächstes soll er, er oder sie, ein Symbol einlesen für den 19:29.640 --> 19:30.400 Operator. 19:31.400 --> 19:33.620 Und wir stellen jetzt die Grundrechenarten zur Verfügung. 19:34.940 --> 19:37.520 Multiplikation, Division, Addition, Subtraktion. 19:39.340 --> 19:41.720 Und dann sollen wir natürlich, können Sie sich jetzt schon vorstellen, 19:41.840 --> 19:44.920 je nachdem welches Symbol wir eingeben, plus, minus, mal, geteilt, 19:44.920 --> 19:47.540 sollen natürlich unterschiedliche Operationen ausgeführt werden. 19:47.980 --> 19:50.280 Unser Programm soll erkennen, das ist jetzt das Symbol für die 19:50.280 --> 19:50.960 Multiplikation. 19:51.700 --> 19:54.940 In dem Fall wird eine Multiplikation ausgeführt zwischen den beiden 19:54.940 --> 19:55.880 Zahlen, die wir eingegeben haben. 19:56.240 --> 19:58.400 Das ist jetzt das Symbol für die Division, also wird eine andere 19:58.400 --> 19:59.180 Operation ausgeführt. 19:59.300 --> 20:00.640 Also da kommen die Verzweigungen rein. 20:03.520 --> 20:06.240 Dann hätten wir unsere Operation, da soll das Resultat berechnet 20:06.240 --> 20:10.000 werden, je nach Eingabe des Operatorsymbols. 20:10.560 --> 20:12.240 Und dann sollen wir am Schluss natürlich das Resultat auf dem 20:12.240 --> 20:12.720 Bildschirm sehen. 20:13.140 --> 20:14.720 Also Sie sehen, wir haben die typischen Elemente. 20:15.940 --> 20:19.240 Einlesen, das ist eine Eingabe, dann eine Ausgabe, wir haben 20:19.240 --> 20:19.720 Rechenoperationen. 20:20.700 --> 20:23.080 In diesem Fall haben wir auch noch eine Entscheidung, eine 20:23.080 --> 20:24.220 Fallunterscheidung. 20:25.040 --> 20:26.380 Und das ist jetzt sozusagen das neue Element. 20:28.700 --> 20:31.060 Dann können wir hier mal starten. 20:35.530 --> 20:40.590 Dann brauchen wir als allererstes ein neues Element, was wir bisher 20:40.590 --> 20:41.550 noch nicht kennengelernt haben. 20:47.540 --> 20:52.900 Wir brauchen eine Verarbeitung von Zeichenketten, weil wir 20:52.900 --> 20:55.620 irgendwelche Operatorsymbole haben und die müssen wir darstellen. 20:57.700 --> 20:59.640 Das heißt, wir fangen jetzt einfach mal an mit einem leeren Programm. 21:06.660 --> 21:09.540 Typischerweise fangen wir fast immer so an. 21:09.660 --> 21:11.420 Sie können das natürlich auch mit Copy-Paste machen in Ihrer 21:11.420 --> 21:12.220 Entwicklungsumgebung. 21:12.700 --> 21:14.700 Aber das sind die Dinge, die wir eigentlich fast immer brauchen. 21:15.920 --> 21:18.040 Sie erinnern sich an die Zeile 2, die hatten wir schon in unserem 21:18.040 --> 21:18.720 Programm entstehen. 21:18.720 --> 21:21.600 Das war dieses Laden der Bibliothek für die Ein- und Ausgabe, 21:21.660 --> 21:22.220 Iostream. 21:22.980 --> 21:27.180 Das ermöglicht uns die Eingabe mit der Tastatur und die Ausgabe über 21:27.180 --> 21:27.620 den Bildschirm. 21:28.680 --> 21:30.580 Die erste Zeile hat ich Ihnen gerade erklärt. 21:30.980 --> 21:33.520 Das ist das Laden von der mathematischen Bibliothek, damit wir 21:33.520 --> 21:37.420 überhaupt viele der Funktionen zur Verfügung haben, die wir brauchen. 21:39.140 --> 21:42.280 Die Zeile 3 war eigentlich nur eine Abkürzung, damit wir bei der Ein- 21:42.280 --> 21:45.400 und Ausgabe eben nicht unnötig tippen müssen. 21:46.660 --> 21:49.640 Dann hatten wir gesagt, eine Funktion namens main müssen wir in jedem 21:49.640 --> 21:50.400 Programm drin haben. 21:51.160 --> 21:53.340 Das ist sozusagen Pflicht, das ist sozusagen der Eintrittspunkt 21:53.340 --> 21:56.060 unseres C++-Programms. 21:56.900 --> 21:58.840 Danach lernen wir dann in der vierten Vorlesung, wir können auch 21:58.840 --> 22:00.840 mehrere Funktionen haben, das haben wir erstmal nicht. 22:02.500 --> 22:05.700 Also int main, geschweifte Klammer auf und zu. 22:06.380 --> 22:08.420 Zwischen diesen beiden geschweiften Klammern steht dann unser 22:08.420 --> 22:08.720 Programm. 22:10.080 --> 22:11.520 Wieso steht da return null? 22:11.520 --> 22:15.760 Ich würde die Frage einfach mal ein bisschen zurückstellen, wie genau 22:15.760 --> 22:18.660 eine Funktion aussehen muss, damit wir die selber definieren können. 22:19.380 --> 22:20.400 Kommt auch noch später. 22:23.080 --> 22:24.680 Auf diese Weise können wir erstmal anfangen. 22:26.340 --> 22:30.020 Was wir jetzt brauchen, ist irgendwie eine Funktionalität, dass wir 22:30.020 --> 22:31.520 mit Zeichenketten umgehen. 22:32.260 --> 22:35.020 Und da gibt es eine Bibliothek, die sehr sinnvoll ist bei C++. 22:37.920 --> 22:41.460 Die String heißt eigentlich nichts anderes als Zeichenkette. 22:42.040 --> 22:44.100 Von daher kann man sich das merken. 22:44.360 --> 22:45.920 Also der englische Wort für Zeichenkette ist String. 22:46.220 --> 22:50.580 Und die String-Bibliothek erlaubt uns, Dinge mit Zeichenketten 22:50.580 --> 22:53.860 anzustellen, die auch ein bisschen über diese Vorlesung hinausgehen. 22:53.960 --> 22:55.540 Aber auf jeden Fall das, was wir brauchen, haben wir da. 22:58.340 --> 23:01.680 Und wir versuchen jetzt erstmal nur eine Zeichenkette einzulesen. 23:01.680 --> 23:05.120 Das ist unsere allererste Handlung hier. 23:05.740 --> 23:07.360 Was können wir mit der Bibliothek anfangen? 23:07.520 --> 23:10.060 Wir können neue Datentypen benutzen. 23:10.940 --> 23:12.300 Oder Objekte eigentlich. 23:12.500 --> 23:13.400 Die heißen String. 23:13.560 --> 23:15.580 Das heißt, wir können jetzt hier ein String-Objekt definieren. 23:15.980 --> 23:18.020 Zum Beispiel, wir können das Operator nennen. 23:19.820 --> 23:20.640 Oder OP. 23:21.280 --> 23:22.600 Ich vereinfache mir einfach mal das Tippen. 23:23.000 --> 23:26.200 Das heißt, wir definieren hier eine Variable vom Typ String, vom Typ 23:26.200 --> 23:26.820 Zeichenkette. 23:26.820 --> 23:29.660 Und diesen neuen Typ wird hier in diese Bibliothek zur Verfügung 23:29.660 --> 23:30.040 gestellt. 23:31.300 --> 23:34.220 Jetzt fordern wir zum Beispiel den Benutzer auf, einen solchen 23:34.220 --> 23:35.240 Operator einzugeben. 23:36.220 --> 23:37.680 Wie fordern wir den Benutzer auf? 23:39.620 --> 23:41.940 Sie sitzen vor dem Bildschirm, Sie starten dieses Programm. 23:43.040 --> 23:46.260 Und das Programm soll Sie jetzt dazu auffordern, etwas einzugeben. 23:46.780 --> 23:47.960 Das Programm kommuniziert Ihnen. 23:48.840 --> 23:51.320 Ich erwarte von dir jetzt einen Operator. 23:57.400 --> 23:59.120 CIN wäre jetzt die Eingabe. 23:59.720 --> 24:01.560 Sie möchten also jetzt schon die Zeichenkette einlesen. 24:02.180 --> 24:05.300 Ich würde vorschlagen, bevor wir die einlesen, teilen wir dem Benutzer 24:05.300 --> 24:07.460 erstmal mit, bitte gebe das und das ein. 24:07.700 --> 24:09.240 Also es war nicht falsch, was Sie sagen. 24:09.760 --> 24:12.840 Aber ich würde jetzt persönlich erstmal mit COUT starten. 24:13.700 --> 24:19.180 Sie erinnern sich, COUT ist die Ausgabe auf dem Bildschirm. 24:20.420 --> 24:23.380 Das heißt, wir haben COUT verknüpft mit diesem doppelten kleiner als 24:23.380 --> 24:23.840 Zeichen. 24:24.280 --> 24:28.480 Das heißt, wir schicken sozusagen etwas auf dieses Ausgabegerät. 24:29.140 --> 24:30.200 Und was geben wir da aus? 24:30.680 --> 24:34.180 Erstmal einfach nur eine Zeichenkette, eine Aufforderung, das heißt 24:34.180 --> 24:34.980 einen gewissen Text. 24:35.560 --> 24:37.580 Den schreibe ich gleich da rein in diese Hochkommas. 24:37.780 --> 24:39.140 Und danach möchte ich die Zeile beenden. 24:40.300 --> 24:41.400 Also eine neue Zeile anfangen. 24:41.500 --> 24:43.260 Das war mit diesem ENDL für Endline. 24:43.980 --> 24:45.540 Und da können wir jetzt irgendeine Aufforderung reinschreiben. 24:45.540 --> 24:49.100 Bitte Operator eingeben. 24:53.840 --> 24:56.640 Jetzt kam hier Ihr Beitrag. 24:56.780 --> 24:59.040 Jetzt möchten wir diesen Operator einlesen. 24:59.660 --> 25:02.420 Und den möchten wir jetzt in diese neuen Variable speichern. 25:02.820 --> 25:04.500 Sie schlagen uns jetzt vor, CIN zu benutzen. 25:06.720 --> 25:08.360 CIN habe ich da schon stehen und dann weiter. 25:17.760 --> 25:20.260 Ja, habe ich auf der Zeile 7 schon gemacht. 25:20.260 --> 25:23.220 Ich schreibe noch einen Kommentar dahinter, damit das klarer ist. 25:25.700 --> 25:31.980 Diese Variable soll das Symbol speichern. 25:33.120 --> 25:35.580 Typischerweise würde man nicht so viele Kommentare schreiben an der 25:35.580 --> 25:37.740 Stelle, aber jetzt für ein erstes Programm ist das sehr wichtig. 25:38.500 --> 25:40.800 Also dieses OP, wir können das auch länger nennen. 25:40.980 --> 25:44.420 Wir können das auch Operator-Symbol nennen. 25:46.340 --> 25:49.080 Irgendwann wird man ein bisschen müde, das zu tippen, aber ist okay. 25:49.080 --> 25:52.000 Das soll jetzt das Operator-Symbol beinhalten. 25:53.280 --> 25:53.560 Und jetzt? 25:58.410 --> 25:59.330 Und dazwischen? 26:12.430 --> 26:16.950 Wie wir schon mal im Beispielprogramm hatten, COUT ist die Ausgabe. 26:17.030 --> 26:18.770 Man schickt also Daten praktisch auf das COUT. 26:18.910 --> 26:22.230 Von daher kann man sich merken, die sind kleiner als Zeichen. 26:22.230 --> 26:25.990 Der Pfeil geht sozusagen von dem, was ich rausschicke, auf den 26:25.990 --> 26:28.530 Bildschirm, wenn COUT sozusagen das Ausgabegerät ist. 26:29.070 --> 26:30.010 Bei CIN ist es umgekehrt. 26:30.030 --> 26:32.270 Ich möchte was von der Tastatur einlesen und in die Variable 26:32.270 --> 26:32.770 speichern. 26:32.830 --> 26:35.530 Da zeigt sozusagen dieses CIN auf die Variable. 26:38.090 --> 26:41.290 Das ist sozusagen der C++-Syntax, um Sachen einzulesen und 26:41.290 --> 26:42.230 herauszugeben. 26:43.590 --> 26:46.570 So, jetzt hätte ich, wenn alles gut geht, in dieser Variable Operator 26:46.570 --> 26:50.130 -Symbol ein Symbol gespeichert oder was auch immer der Benutzer dann 26:50.130 --> 26:50.710 eingegeben hat. 26:51.570 --> 26:53.790 Und jetzt würde ich mal vorschlagen, wir geben das wenigstens noch 26:53.790 --> 26:58.030 aus, damit wir wenigstens eine Antwort haben und sehen auf dem 26:58.030 --> 27:04.910 Bildschirm, was der Benutzer eingegeben hat. 27:15.640 --> 27:17.340 Sie sehen, mit der Maus muss man viel arbeiten. 27:18.800 --> 27:20.440 Also, was möchte ich hier auf der Zeile 10 machen? 27:20.520 --> 27:26.680 Auf der Zeile 10 möchte ich eigentlich dem Benutzer antworten und 27:26.680 --> 27:29.020 sagen sozusagen noch mitteilen, okay, wir haben verstanden, was du 27:29.020 --> 27:29.580 eingegeben hast. 27:30.680 --> 27:32.740 Weiter soll das jetzt eigentlich in dem allerersten Programm gar nicht 27:32.740 --> 27:33.040 gehen. 27:38.780 --> 27:40.180 Sollen wir versuchen, ob das kompiliert? 27:41.740 --> 27:44.180 Also, man muss jetzt das Programm natürlich erstmal übersetzen. 27:47.560 --> 27:48.700 Wir haben das TR genannt. 27:49.820 --> 27:50.740 Das sieht man hier unten. 27:51.700 --> 27:54.560 Das Programm heißt hier tr.cpp, TR für Taschenrechner. 27:55.280 --> 27:56.460 Und wir können das übersetzen. 27:58.180 --> 28:00.600 Ich benutze jetzt hier in diesem Fall nicht Visual Studio, spielt aber 28:00.600 --> 28:01.000 keine Rolle. 28:01.000 --> 28:02.640 Das Resultat ist jetzt a.out. 28:04.500 --> 28:05.700 Bitte Operator eingeben. 28:05.860 --> 28:07.740 Nehmen wir an, wir geben jetzt hier den Stern oder so. 28:08.620 --> 28:11.440 Okay, also das Programm hat zumindest verstanden, was wir da 28:11.440 --> 28:13.980 eingegeben haben und kann uns sozusagen antworten. 28:16.360 --> 28:18.580 Wir haben jetzt noch nicht so viel gewonnen, aber wir haben jetzt 28:18.580 --> 28:20.960 immerhin schon mal eine Methode kennengelernt, wie wir eine 28:20.960 --> 28:23.360 Zeichenkette oder in diesem Fall nur ein Zeichen, das könnte jetzt 28:23.360 --> 28:26.960 auch eine längere Kette sein, eingeben können, in einer Variable 28:26.960 --> 28:27.580 speichern können. 28:28.860 --> 28:33.660 Diese String-Methode ist jetzt für diesen einfachen Fall, das kann 28:33.660 --> 28:36.800 sozusagen schon fast zu viel, ist sehr praktisch, deswegen möchte ich 28:36.800 --> 28:38.080 Ihnen das auf diese Weise beibringen. 28:38.340 --> 28:40.980 Man kann auf diese Weise zum Beispiel Zeichenketten zusammenfügen, man 28:40.980 --> 28:42.600 kann die Länge von der Zeichenkette bestimmen. 28:43.120 --> 28:45.980 Man muss zum Beispiel an dieser Stelle, Sie sehen, wir geben hier gar 28:45.980 --> 28:47.740 nicht an, wie viele Zeichen wir eingeben wollen. 28:47.820 --> 28:48.920 Das können beliebig viele sein. 28:49.760 --> 28:53.420 Diese String-Objekte, die dimensionieren sich von alleine. 28:53.420 --> 28:56.480 Das heißt, bei der Eingabe wird dann erst festgelegt, ich brauche hier 28:56.480 --> 29:00.020 so und so viel Speicherplatz und die sind sehr komfortabel. 29:00.600 --> 29:04.980 Da wir hier, sage ich mal, im Ingenieurkurs nicht viel mit 29:04.980 --> 29:07.340 Zeichenketten arbeiten werden, ist das eigentlich auch fast schon 29:07.340 --> 29:09.000 alles, was wir über Zeichenketten wissen müssen. 29:11.180 --> 29:13.020 Was uns mehr interessiert, ist unser Taschenrechner. 29:14.180 --> 29:18.260 Wir hatten also jetzt soweit, dass wir mit diesen Zeichenketten 29:18.260 --> 29:21.420 arbeiten können und die brauchen wir für unseren Taschenrechner. 29:22.000 --> 29:22.400 Taschenrechner. 29:30.570 --> 29:33.790 Wir sind ungefähr so weit gekommen, wie auf dieser Folie hier. 29:34.150 --> 29:37.450 Nochmal kurz die Erinnerung, wenn Sie auf den magentafarbenen Text 29:37.450 --> 29:39.970 klicken, dann bekommen Sie die Langversion von diesem 29:39.970 --> 29:40.730 Beispielprogramm. 29:41.410 --> 29:42.570 Oftmals sind das hier nur Ausschnitte. 29:43.350 --> 29:47.490 Ich versuche, dass das, was hier auf der Folie steht, auch legaler 29:47.490 --> 29:49.390 Text ist, sodass es ein echtes Programm ergibt, was Sie auch 29:49.390 --> 29:49.950 kompilieren können. 29:49.950 --> 29:52.830 Wenn Sie das aber komplett sehen wollen, mit allen Kommentaren, dann 29:52.830 --> 29:56.670 klicken Sie hier drauf und dann ist sozusagen die Langversion im Netz 29:56.670 --> 29:56.950 verlinkt. 29:59.210 --> 30:01.110 Hier sind manchmal auch noch so interne Links. 30:01.290 --> 30:04.050 Wenn Sie hier drauf klicken, kommen Sie zum Anhang der Folien und da 30:04.050 --> 30:09.350 sind dann nochmal die Funktionalitäten dieser String-Objekte erklärt, 30:09.430 --> 30:10.890 was Sie alles noch damit anstellen können. 30:15.790 --> 30:17.630 Jetzt kommt der nächste Schritt, den wir machen wollen. 30:17.630 --> 30:19.950 Im Moment haben wir noch nicht viel gewonnen, wir haben ein Zeichen 30:19.950 --> 30:21.350 oder ein Symbol eingelesen. 30:22.170 --> 30:24.210 Sie erinnern sich, wir wollen eigentlich dahin, dass wir einen 30:24.210 --> 30:30.110 Taschenrechner so programmieren, dass das Programm merkt, dass da eine 30:30.110 --> 30:32.310 Addition oder eine Multiplikation ausgeführt wird. 30:32.870 --> 30:33.670 Wie merkt er das? 30:33.910 --> 30:38.110 Klar, wir benutzen andere Operatorsymbole, Stern, Plus, Minus, 30:38.250 --> 30:39.210 Schrägstrich und so weiter. 30:39.950 --> 30:42.410 Also müssen wir die Symbole nicht nur einlesen, sondern wir müssen die 30:42.410 --> 30:43.270 auch vergleichen. 30:43.270 --> 30:46.310 Das heißt, wir geben uns selber eine Liste von Symbolen vor oder wir 30:46.310 --> 30:49.970 wissen, dass die Addition ein Pluszeichen ist, oder das Programm 30:49.970 --> 30:50.570 sollte das wissen. 30:51.410 --> 30:54.930 Und je nachdem, was der Benutzer eingibt, müssen wir dann reagieren. 30:55.210 --> 30:58.130 Das heißt, wir müssen also die Eingabe vergleichen mit irgendwelchen 30:58.130 --> 30:59.530 vordefinierten Symbolen. 31:00.050 --> 31:03.890 Wir müssen also dem Programm beibringen, dass es erkennt, ob ein 31:03.890 --> 31:07.110 Symbol, das gerade eingegeben wurde, gleich ist einem aus unserer 31:07.110 --> 31:10.990 Kartei, aus unserer vorhandenen Kartei von Symbolen, Plus, Minus, Mal 31:10.990 --> 31:11.450 geteilt. 31:11.450 --> 31:14.170 Oder vielleicht sogar eine falsche Eingabe ist und dementsprechend 31:14.170 --> 31:14.570 reagiert. 31:15.930 --> 31:19.610 Also bevor wir sozusagen zu der Verzweigung kommen, wollen wir uns 31:19.610 --> 31:20.790 erst mal den Vergleich anschauen. 31:21.930 --> 31:26.510 Also jetzt ist die Frage, wie vergleicht man Werte von zwei Variablen 31:26.510 --> 31:29.570 oder eine Variable mit einer Konstanten. 31:30.550 --> 31:33.350 Und die Antwort ist mit dem Symbol gleich gleich. 31:34.030 --> 31:38.070 Und das ist ein beliebter Fehler, das gleich gleich mit dem gleich zu 31:38.070 --> 31:38.450 verwechseln. 31:40.330 --> 31:42.430 Das hört sich jetzt auch wieder nach Haarspalterei an, aber der 31:42.430 --> 31:43.330 Compiler ist halt so. 31:44.850 --> 31:47.630 Ein doppeltes Gleich ist nicht das gleiche wie ein einfaches Gleich. 31:48.970 --> 31:49.710 Denken Sie daran. 31:50.210 --> 31:53.550 Ein einfaches Gleich, das Gleichheitszeichen, ist eine Zuweisung. 31:54.190 --> 31:56.190 Ein doppeltes Gleichheitszeichen ist ein Vergleich. 31:57.450 --> 32:00.070 Und wir kommen gleich auch nochmal zu typischen und beliebten Fehlern. 32:01.010 --> 32:03.310 Der Compiler merkt auch nicht unbedingt, dass es an der Stelle 32:03.310 --> 32:05.870 vielleicht ein doppeltes Gleichheitszeichen sein soll, sondern der 32:05.870 --> 32:06.870 macht dann etwas ganz anderes. 32:06.870 --> 32:08.150 Und Sie wundern sich, was passiert. 32:08.570 --> 32:09.190 Kommen wir noch zu. 32:09.690 --> 32:10.590 Also jetzt soweit erstmal. 32:10.890 --> 32:13.530 Wenn Sie zwei Variablen vergleichen wollen oder eine Variable mit 32:13.530 --> 32:16.370 einer Konstanten vergleichen wollen, benutzen Sie bitte das doppelte 32:16.370 --> 32:17.070 Gleichheitszeichen. 32:21.390 --> 32:24.170 Wir können jetzt einen Schritt weitergehen in unserem Testprogramm 32:24.170 --> 32:24.390 hier. 32:29.060 --> 32:33.680 Wir haben hier unser Programm und haben das Symbol eingelesen und 32:33.680 --> 32:34.260 ausgegeben. 32:34.800 --> 32:40.860 Und was wir noch zusätzlich ausgeben, ist sowas 32:44.820 --> 32:45.100 hier. 32:48.670 --> 32:52.510 Wir geben jetzt einfach mal das Resultat von einem Vergleich aus. 32:57.190 --> 32:58.390 Also ich schreibe da jetzt mal... 33:00.090 --> 33:00.890 Was habe ich jetzt gemacht? 33:00.950 --> 33:02.130 Ich habe nur die Zeile 11 geändert. 33:02.870 --> 33:04.330 Ich habe die Zeile 11 hinzugefügt. 33:04.450 --> 33:06.190 Das war jetzt erstmal kopiert von der Zeile 10. 33:06.490 --> 33:08.710 Und in der Zeile 11 steht jetzt irgendwie ein anderer Kommentar. 33:09.130 --> 33:12.230 Das heißt, alles was in Hochkommazeichen gestellt ist, wird einfach 33:12.230 --> 33:14.090 nur wörtlich wieder ausgegeben. 33:14.290 --> 33:16.390 Damit wir wissen, da ist jetzt die andere Zeile. 33:17.430 --> 33:18.950 Was gebe ich danach dann aus? 33:19.090 --> 33:20.710 Ich habe jetzt hier in Klammern gesetzt Operatorsymbol. 33:21.850 --> 33:24.110 Das ist unsere Variable hier oben vom Typ String. 33:24.290 --> 33:27.330 Also dieses Zeichen, was wir da gerade eingegeben haben. 33:27.870 --> 33:31.310 Dann gleich, gleich und dann in Hochkommas eine Konstante. 33:33.050 --> 33:35.090 Also dieses Plus ist in der Tat eine Konstante. 33:35.090 --> 33:38.770 Das steht jetzt wörtlich gesehen, übersetzt, steht in dieser Klammer. 33:40.630 --> 33:43.990 Ist dieses Operatorsymbol, also der Wert dieser Variable in diesem 33:43.990 --> 33:46.190 Moment, gleich dem Pluszeichen? 33:47.910 --> 33:52.070 Wenn diese Klammer ausgewertet wird, kommt da entweder raus Ja oder 33:52.070 --> 33:52.330 Nein. 33:53.070 --> 33:56.670 Das heißt, wenn das Operatorsymbol in der Tat das Pluszeichen ist, 33:57.190 --> 33:57.850 kommt daraus Ja. 33:58.530 --> 34:00.670 Ist das Resultat dieser Auswertung in der Klammer Ja? 34:01.110 --> 34:03.370 Wenn nicht, ist die Antwort Nein. 34:03.810 --> 34:05.650 Oder anders gesagt True und False. 34:08.830 --> 34:11.610 So, jetzt kann man diese Antwort True und False sich auf 34:11.610 --> 34:13.150 unterschiedliche Arten ausgeben lassen. 34:13.550 --> 34:15.670 Wenn wir das jetzt so machen, kommt wahrscheinlich 0 oder 1 raus. 34:16.250 --> 34:17.190 Das kann man auch umstellen. 34:17.290 --> 34:17.930 Das schauen wir jetzt mal. 34:18.810 --> 34:19.770 Also wir probieren das jetzt mal aus. 34:20.250 --> 34:22.230 Erstmal sehen, ob das... das mag er nicht. 34:23.190 --> 34:24.250 Das habe ich falsch gemacht. 34:25.770 --> 34:26.630 Kann mir jemand helfen? 34:33.110 --> 34:34.530 Wir machen es jetzt andersrum. 34:35.410 --> 34:36.070 Das ist eine Konstante. 34:39.810 --> 34:43.950 Man kann sich konstante Variablen definieren, symbolische Konstanten 34:43.950 --> 34:47.130 definieren, die eben so einen Typ haben müssen wie Variablen, die sich 34:47.130 --> 34:50.870 auch verändern können, die aber eben im Unterschied zu normalen 34:50.870 --> 34:53.110 Variablen ihren Wert nicht während der Laufzeit ändern können. 34:53.510 --> 34:56.030 Das heißt, wir müssen bei der Definition schon einen Wert vorgeben. 34:56.810 --> 34:59.490 Das heißt, wir definieren jetzt hier das Pluszeichen und nennen das 34:59.490 --> 35:00.410 Plus in Worten. 35:02.050 --> 35:04.570 Wir vergleichen jetzt dieses Operatorsymbol mit dem Plus. 35:05.610 --> 35:07.430 Schauen, ob der Compiler das lieber mag. 35:09.950 --> 35:11.130 Oh, mag er auch nicht. 35:11.510 --> 35:12.530 Mag er gar nicht. 35:13.590 --> 35:14.470 Was ist hier passiert? 35:19.300 --> 35:19.880 Wie bitte? 35:21.680 --> 35:22.900 Hat jemand einen Vorschlag? 35:28.330 --> 35:29.230 Das ändert nichts. 35:29.690 --> 35:32.190 Der Unterschied ist eine globale oder eine lokale Variable. 35:32.310 --> 35:35.590 In diesem Fall, wenn ich es draußen reinschreibe, ist es eine globale 35:35.590 --> 35:41.590 Variable, die in allen Funktionen Gültigkeit hat, die in dieser Datei 35:41.590 --> 35:41.930 stehen. 35:42.770 --> 35:43.710 Wir sehen, es ändert nichts. 35:46.130 --> 35:46.610 Erstaunlich. 35:46.950 --> 35:47.870 Es ändert doch was. 35:51.560 --> 35:52.520 Sehr erstaunlich. 35:54.440 --> 35:55.460 Wir probieren es mal. 35:55.540 --> 35:58.000 Wir machen jetzt mal hier unser Nicht-Zeichen. 35:58.100 --> 35:59.060 Jetzt kommt ein Null raus. 35:59.800 --> 36:04.960 In diesem Beispiel wäre es so gewesen, dass der Benutzer einen Stern 36:04.960 --> 36:05.400 eingegeben hat. 36:05.400 --> 36:07.540 Nehmen wir an, er wollte eine Multiplikation durchführen. 36:07.760 --> 36:09.520 Das wird hier nochmal wiedergegeben. 36:10.380 --> 36:13.040 Und wir haben jetzt hier getestet... Moment, ich blende nochmal das 36:13.040 --> 36:13.640 Programm ein. 36:14.900 --> 36:21.540 An dieser Stelle getestet an der Zeile 11, ob diese Variable, die in 36:21.540 --> 36:23.800 diesem Fall den Wert Stern hat, gleich ist dem Plus-Symbol. 36:24.600 --> 36:25.820 Und die Antwort ist Null. 36:27.640 --> 36:30.460 Heißt in C++-Sprache falsch. 36:30.580 --> 36:31.840 Können wir aber gleich nochmal anders ausgeben. 36:32.220 --> 36:33.200 Wir machen jetzt den Gegentest. 36:33.640 --> 36:36.540 Wir geben jetzt mal das Plus-Zeichen aus und jetzt kam eine Eins raus. 36:36.700 --> 36:37.480 Das heißt wahr. 36:40.840 --> 36:45.700 Jetzt gibt es eine Möglichkeit, das in True oder False ausgeben zu 36:45.700 --> 36:46.040 lassen. 36:48.020 --> 36:49.000 Das wäre so. 36:56.700 --> 36:58.040 Müssen Sie sich nicht unbedingt merken. 36:59.860 --> 37:03.320 Durch diese Zeile sollte man erwirken, ich hoffe, das klappt jetzt 37:03.320 --> 37:06.140 gleich, dass eben dieses wahr oder falsch nicht als Null oder Eins 37:06.140 --> 37:08.800 ausgeben wird, sondern als True oder False, also in Worten. 37:10.380 --> 37:13.620 Das beeinflusst nur die Ausgabe, das heißt dieses Cout-Objekt. 37:15.220 --> 37:16.500 Probieren wir das nochmal mit dem Plus. 37:16.940 --> 37:18.140 Jetzt müsste True da stehen, genau. 37:18.360 --> 37:19.940 Lassen wir nochmal laufen mit irgendwas anderem. 37:20.240 --> 37:22.500 Können wir auch mal irgendeine Zeichenkette einschieben, dann steht da 37:22.500 --> 37:22.760 False. 37:23.360 --> 37:28.400 Also ich habe jetzt mit der allerletzten Manipulation eigentlich nur 37:28.400 --> 37:30.480 diesem Cout-Objekt mitgeteilt. 37:31.280 --> 37:34.360 Das ist eine starke Abkürzung, die weiß auch keiner wirklich 37:34.360 --> 37:34.880 auswendig. 37:35.520 --> 37:41.020 Die heißt, wenn jetzt ein Wahrheitswert ausgegeben wird, so wie wahr 37:41.020 --> 37:43.420 oder falsch, so wie wir das hier an dieser Stelle machen, in der Zeile 37:43.420 --> 37:50.340 12 jetzt, dann geben wir den bitte in Worten aus und eben nicht in 37:50.340 --> 37:50.920 Null oder Eins. 37:56.720 --> 38:00.240 Mich erstaunt aber trotzdem jetzt die Tatsache, dass das einen 38:00.240 --> 38:03.020 Unterschied gemacht hat, dass ich diese Zeile 6 hier in dieses Main, 38:03.100 --> 38:04.760 so wie hier vorgeschlagen ist, reingezogen habe. 38:08.760 --> 38:10.040 Ja, erstaunlich, tut mir leid. 38:10.640 --> 38:16.100 Ich habe ehrlich gesagt einen kleinen Verdacht. 38:18.500 --> 38:20.680 Ich gebe dir mal einen anderen Namen, ich hatte nämlich schon mal so 38:20.680 --> 38:23.620 ein Problem, dass es eigentlich was mit vordefinierten Variablen zu 38:23.620 --> 38:24.020 tun hat. 38:25.180 --> 38:26.040 Ich probiere das mal so rum. 38:26.380 --> 38:27.740 Ich benutze einfach ein anderes Symbol dafür. 38:31.040 --> 38:32.800 Sorry, nochmal kompilieren. 38:33.920 --> 38:37.900 Also es hat wahrscheinlich was damit zu tun, dass dieses Plus ein 38:37.900 --> 38:39.780 Schlüsselwort ist, was an anderer Stelle benutzt wird. 38:40.880 --> 38:42.480 So wollte ich das eigentlich geschrieben haben. 38:43.600 --> 38:45.260 Jetzt haben wir einfach ein anderes Wort gewählt, eine andere 38:45.260 --> 38:48.760 Variablen -Namen gewählt für Add, für Addition und können das so 38:48.760 --> 38:49.260 vergleichen. 38:49.720 --> 38:50.680 Also was haben wir jetzt gewonnen? 38:51.220 --> 38:52.000 Wir sind jetzt soweit. 38:52.480 --> 38:55.340 Wir können ein Zeichen einlesen oder auch eine Zeichenkette, wenn wir 38:55.340 --> 38:55.640 wollen. 38:55.640 --> 39:01.040 Wir können schauen, also sozusagen uns ausrechnen, bestimmen, ob diese 39:01.040 --> 39:04.000 Zeichenkette gleich einem von uns vorgegebenen Wert ist. 39:04.100 --> 39:05.000 Meinetwegen nach Konstanten. 39:06.000 --> 39:09.880 So, jetzt können wir uns eine Liste aufbauen von Operatoren, also von 39:09.880 --> 39:12.640 Operationen, die wir zur Verfügung stellen wollen in unserem 39:12.640 --> 39:13.100 Taschenrechner. 39:13.160 --> 39:16.900 Der soll mindestens Plus, Minus, Multiplikation und Division können. 39:17.060 --> 39:18.380 Also brauchen wir, nehmen wir an, vier Symbole. 39:19.220 --> 39:22.360 Für die können wir jeweils solche Konstanten definieren. 39:23.440 --> 39:26.060 Add, Subtract, Mult, Divide. 39:26.900 --> 39:31.840 Und können jetzt abfragen, ob eben das, was eingegeben wurde, einem 39:31.840 --> 39:34.820 dieser Einträge in unserem Katalog entspricht. 39:36.840 --> 39:39.360 So, was jetzt als nächstes noch fehlt, ist... 39:40.340 --> 39:42.780 Okay, jetzt weiß ich eben, das ist jetzt eine Addition oder eben 39:42.780 --> 39:43.040 nicht. 39:43.700 --> 39:46.440 Ja und, wie kann ich jetzt sozusagen darauf reagieren? 39:48.300 --> 39:54.100 Wie kann ich die Verzweigung realisieren, die aus dieser Bedingung 39:54.100 --> 39:54.620 dann folgt? 39:55.060 --> 39:56.840 Das wäre jetzt sozusagen hier unser nächster Punkt. 40:00.060 --> 40:02.480 Soweit waren wir gekommen, soweit waren wir hier auch schon gekommen. 40:04.260 --> 40:05.840 Jetzt käme die erste Verzweigung. 40:08.100 --> 40:10.540 Also, wie Sie sich vielleicht vorstellen können und alle, die jetzt 40:10.540 --> 40:12.000 schon mal programmiert haben, wissen das natürlich. 40:12.440 --> 40:14.800 Eine Verzweigung wird in den meisten Sprachen durch das Schlüsselwort 40:14.800 --> 40:15.700 If eingeleitet. 40:16.620 --> 40:17.480 Wenn, ja. 40:18.320 --> 40:19.440 Wenn, dann sozusagen. 40:21.520 --> 40:23.160 Also, hier haben wir jetzt so ein kleines Beispiel. 40:23.420 --> 40:25.360 Jetzt lernen wir das erste Mal ein neues Schlüsselwort kennen. 40:25.520 --> 40:30.900 If, also in Worten heißt das, Sie führen die folgende Anweisung nur 40:30.900 --> 40:34.520 dann aus, wenn die Bedingung, die auf das If folgt, wahr ist. 40:36.120 --> 40:38.180 Also, jetzt werden wir in der Zeile 12 stehen. 40:38.320 --> 40:40.260 Sonst ist das Programm mehr oder weniger das, was wir schon da stehen 40:40.260 --> 40:40.520 haben. 40:40.980 --> 40:43.940 Da steht jetzt If, dann steht in Klammern irgendeine Bedingung. 40:43.940 --> 40:47.280 Das heißt, irgendein Ausdruck, der wahr oder falsch ergibt. 40:47.600 --> 40:49.840 Später unterhalten wir uns nochmal genau, was das für Ausdrücke sein 40:49.840 --> 40:50.040 können. 40:50.660 --> 40:52.340 Wir haben jetzt hier schon einen kennengelernt, das haben wir uns 40:52.340 --> 40:52.860 ausgegeben. 40:54.660 --> 40:57.240 Operator, gleich, gleich, irgendeine Konstante. 40:57.640 --> 40:59.820 Da kam eben wahr oder falsch raus, 0 oder 1. 41:00.880 --> 41:04.340 So, und das If ist jetzt so gestrickt, dass die nachfolgende 41:04.340 --> 41:07.900 Operation, also hier ist diese Zeile 13, die wird dann ausgeführt, 41:08.140 --> 41:10.880 wenn diese Bedingung zu wahr evaluiert wird. 41:11.440 --> 41:13.100 In allen anderen Fällen wird die einfach übersprungen. 41:23.680 --> 41:25.880 Das können wir jetzt hier in unserem Beispielprogramm natürlich sofort 41:25.880 --> 41:26.480 nachvollziehen. 41:28.360 --> 41:31.500 Also wir schreiben jetzt hier If hin, dann kommt unsere Bedingung. 41:32.940 --> 41:35.540 Die können wir hier schon kopieren, die haben wir ja schon formuliert. 41:36.680 --> 41:43.620 Und jetzt käme meinetwegen unsere Anweisung, die wir dann überspringen 41:43.620 --> 41:44.260 wollen oder nicht. 41:45.120 --> 41:45.940 Und die wäre 42:02.570 --> 42:06.570 so in der Art. 42:09.450 --> 42:10.690 So, jetzt geben wir irgendwas ein. 42:12.490 --> 42:16.930 Gut, da steht jetzt nichts, das heißt die Zeile 14 wurde übersprungen. 42:17.070 --> 42:18.670 Hier erscheint keine Ausgabe. 42:19.290 --> 42:21.310 Die letzte Ausgabe ist hier von der Zeile 12. 42:22.150 --> 42:23.070 Da steht dieses False. 42:25.110 --> 42:26.170 Wenn ich das nochmal übersetze. 42:27.290 --> 42:28.690 Sorry, hätte ich gar nicht machen müssen, wenn ich das nochmal 42:28.690 --> 42:29.130 ausführe. 42:29.130 --> 42:30.930 Und jetzt gebe ich in der Tat so ein Plus ein. 42:32.090 --> 42:37.050 Dann reagiert die Ausgabe auf diese Eingabe, merkt, dass es in der Tat 42:37.050 --> 42:39.670 eine Gleichheit ist und führt diese eine Anweisung aus. 42:40.750 --> 42:42.450 Also das ist die Idee von einer Verzweigung. 42:42.910 --> 42:45.510 Hier an dieser Stelle ist jetzt eine Verzweigung, 13, ausgerückt durch 42:45.510 --> 42:45.910 das If. 42:46.370 --> 42:49.690 Das heißt, Sie merken jetzt, die Ausführung dieses Programms ist jetzt 42:49.690 --> 42:51.330 nicht mehr so linear, Zeile für Zeile. 42:51.770 --> 42:53.330 Die hängt jetzt von der Eingabe ab. 42:54.090 --> 42:57.390 Wenn die Eingabe Plus ist, wird die Zeile 14 ausgeführt. 42:57.390 --> 43:00.010 Wenn die Eingabe eben nicht Plus war, wird die Zeile 14 übersprungen. 43:01.050 --> 43:02.310 Also hier haben Sie eine Verzweigung. 43:05.910 --> 43:09.670 Also wir sind jetzt schon relativ weit auf dem Weg zu unserem 43:09.670 --> 43:10.390 Taschenrechner. 43:11.910 --> 43:14.990 Wir können ein- und ausgeben, unter anderem auch Zeichenketten. 43:16.090 --> 43:22.310 Wir können Vergleiche realisieren und wir können jetzt auch schon 43:22.310 --> 43:22.790 verzweigen. 43:22.850 --> 43:26.570 Das heißt, wir können auf die Werte von den Bedingungen reagieren. 43:37.770 --> 43:41.070 Jetzt kommen wir nochmal zurück zu unserem Flussdiagramm. 43:41.130 --> 43:43.850 Das ist ja dann manchmal ein bisschen einprägsamer als nur so ein paar 43:43.850 --> 43:47.170 Programmzeilen von so einem relativ einfachen Beispielprogramm. 43:48.150 --> 43:51.050 So können Sie sich die Sache, denke ich mal, gut merken. 43:51.610 --> 43:53.070 Also das einfache If ist so. 43:53.610 --> 43:56.270 Hier ist dieser kurze Programmausschnitt in so einer allgemeinen 43:56.270 --> 43:56.830 Schreibweise. 43:56.990 --> 43:58.810 Das heißt, If steht da immer, das ist das Schlüsselwort. 43:59.330 --> 44:01.290 Und dann kommt irgendeine Bedingung. 44:01.990 --> 44:03.630 Kommen wir noch dazu, wie man die genau formuliert. 44:03.650 --> 44:06.010 Die kann auch sehr komplex sein, die kann auch zusammengesetzt sein. 44:06.490 --> 44:08.530 Aber hier ist jetzt einfach nur ein einfacher Vergleich gewesen. 44:10.630 --> 44:13.630 Dann kommt eine Anweisung und dann kommen weitere Anweisungen. 44:13.770 --> 44:14.230 Liebe ich viele. 44:15.930 --> 44:17.790 Die Bedingung wird zuerst ausgewertet. 44:17.890 --> 44:19.650 Das ist das erste, was getan wird an dieser Zeile. 44:20.370 --> 44:24.530 Je nach Ergebnis wird eben, wenn es true ist oder wahr, die Anweisung 44:24.530 --> 44:25.250 1 ausgeführt. 44:25.250 --> 44:27.290 Ansonsten bei falsch wird die übersprungen. 44:28.070 --> 44:29.970 Und diese Anweisung 2 wird dann immer ausgeführt. 44:30.130 --> 44:32.590 Das heißt, bis hier wird dann eventuell gesprungen. 44:34.010 --> 44:36.090 Und das gleiche ist hier schematisch dargestellt. 44:37.130 --> 44:41.490 Sie kommen also hier rein auf diesen Verzweigungsblock. 44:41.830 --> 44:42.810 Hier steht die Bedingung drin. 44:43.110 --> 44:45.530 Wenn die zu wahr evaluiert, Anweisung 1. 44:45.630 --> 44:47.690 Wenn nicht, gehen wir an der Anweisung 1 vorbei. 44:48.270 --> 44:50.530 Die beiden Verzweigungen treffen sich irgendwo wieder. 44:51.110 --> 44:53.050 Und wir gelangen bei der Anweisung 2 immer an. 44:57.750 --> 45:01.390 Jetzt können Sie sich vorstellen, dass solche Bedingungen beliebig 45:01.390 --> 45:03.250 komplex verschachtelt werden können. 45:03.810 --> 45:06.710 Und wir müssen das auch machen, denn hier haben wir ja nicht nur die 45:06.710 --> 45:09.010 Frage zu klären, ist das eine Addition oder nicht, sondern wir haben 45:09.010 --> 45:11.730 die Frage zu klären, ist das eine Addition oder eine Multiplikation 45:11.730 --> 45:15.390 oder eine Division oder eine Subtraktion oder vielleicht ganz was 45:15.390 --> 45:16.790 anderes, was wir gar nicht können. 45:17.570 --> 45:19.430 Also wir haben schon mal mindestens fünf Fälle zu unterscheiden. 45:19.910 --> 45:21.790 Während wir hier jetzt erstmal nur einen Fall unterscheiden. 45:21.850 --> 45:22.370 Ja oder Nein. 45:22.370 --> 45:25.830 Das heißt wir müssen jetzt, in den typischen Situationen haben wir 45:25.830 --> 45:29.530 nicht nur ein Entweder-oder, sondern wir haben Entweder-oder-oder-oder 45:29.530 --> 45:29.850 -oder. 45:33.050 --> 45:34.650 Also wir gehen jetzt Schritt für Schritt. 45:35.750 --> 45:39.070 Der nächste Schritt wäre jetzt If-Else. 45:40.830 --> 45:43.710 Das wäre jetzt in der Tat ein Entweder-oder, wo auf beiden Seiten 45:43.710 --> 45:45.650 Anweisungen, sozusagen Alternativen stehen. 45:46.250 --> 45:48.250 Entweder die eine Anweisung oder die andere. 45:49.930 --> 45:52.950 Also steht da ein If mit der Bedingung und der Anweisung genau wie 45:52.950 --> 45:58.250 vorher und wenn dann das Schlüsselwort Else folgt, sonst, das ist ein 45:58.250 --> 46:00.310 neues Schlüsselwort, ein weiteres was wir kennen, wir haben jetzt If 46:00.310 --> 46:01.190 kennengelernt und Else. 46:02.310 --> 46:05.210 Danach steht eine zweite Anweisung oder eine andere und dann kommt 46:05.210 --> 46:06.630 eine dritte, die immer erreicht wird. 46:07.270 --> 46:09.230 Also es wird entweder die Eins ausgeführt oder die Zwei. 46:09.510 --> 46:10.090 Nicht beide. 46:12.890 --> 46:14.690 Und per Flussdiagramm eben hier. 46:18.250 --> 46:23.230 Jetzt hätten wir sozusagen die Möglichkeit, zwei Alternative 46:23.230 --> 46:26.250 Anweisungen auszuführen, je nach der Bedingung, wahr oder falsch. 46:27.710 --> 46:28.930 Wir brauchen aber mehr. 46:31.230 --> 46:35.810 Und dazu benutzen wir typischerweise das Konstrukt Else-If. 46:38.150 --> 46:41.670 Also, wie bisher, If, Bedingung 1, Anweisung 1. 46:42.210 --> 46:45.470 Und dann machen wir aber nicht direkt eine zweite Alternative, sondern 46:45.470 --> 46:46.250 dann fragen wir nochmal. 46:46.830 --> 46:49.310 Also, ist jetzt unser Operator gleich Plus? 46:50.370 --> 46:51.470 Dann machen wir etwas. 46:51.970 --> 46:53.450 Wenn nicht, dann fragen wir weiter. 46:53.910 --> 46:55.390 Ist es gleich Minus? 46:55.670 --> 46:56.530 Dann machen wir etwas anderes. 46:56.890 --> 46:57.650 Und so weiter und so fort. 46:57.710 --> 47:00.410 So können wir beliebig viele Alternativen auswählen. 47:01.990 --> 47:04.090 Also, das Flussdiagramm wird dann schon ein bisschen komplexer. 47:04.150 --> 47:05.670 Wir haben also unsere erste Bedingung hier. 47:06.630 --> 47:07.750 Die ist dann wahr oder falsch. 47:07.850 --> 47:10.630 Wenn die wahr ist, haben wir unsere erste Anweisung und kommen dann 47:10.630 --> 47:11.350 irgendwo wieder zusammen. 47:11.610 --> 47:14.210 Wenn die falsch ist, hätten wir unsere zweite Bedingung. 47:14.210 --> 47:16.190 Die steht hier, in dem Else-If. 47:16.910 --> 47:19.150 Wenn die wahr ist, wird die zweite Anweisung ausgeführt. 47:19.590 --> 47:22.050 Wenn nicht, kommt man am Schluss wieder zusammen und dann bei der 47:22.050 --> 47:24.630 Anweisung 3 gelangen alle Programmzweige an. 47:25.450 --> 47:27.050 Und Sie können das beliebig oft schachteln. 47:27.150 --> 47:28.970 Hier können also beliebig viele Else-Ifs folgen. 47:29.650 --> 47:32.250 Auf ein If können beliebig viele Else-Ifs folgen. 47:35.910 --> 47:39.410 Und schließlich, um die ganze Sache abzuschließen, die letzte 47:39.410 --> 47:39.930 Variante. 47:40.190 --> 47:42.170 Also, wie gesagt, hier können beliebig viele Else-Ifs stehen, 47:42.350 --> 47:43.310 meinetwegen 5 oder 6. 47:43.310 --> 47:45.630 Und ganz am Schluss kann auch noch ein Else stehen. 47:46.110 --> 47:48.210 Else fängt dann alle anderen Fälle auf. 47:48.710 --> 47:52.590 Wenn vorher keiner dieser Fälle eingetroffen ist, gelangt man bei dem 47:52.590 --> 47:53.070 Else an. 47:53.190 --> 47:54.590 Und Else ist sozusagen alle anderen Fälle. 47:55.110 --> 47:56.390 In unserem Fall ist das sinnvoll. 47:56.930 --> 47:59.270 Wir haben, ist dieses Zeichen ein Plus? 47:59.830 --> 48:00.890 Wenn ja, dann mach etwas. 48:01.290 --> 48:02.390 Nimm mich für die Addition aus. 48:03.010 --> 48:05.150 Wenn nicht, ist dieses Zeichen ein Minus? 48:05.330 --> 48:05.990 Und so weiter und so fort. 48:06.070 --> 48:08.170 Und ganz am Schluss fragen wir ansonsten. 48:08.790 --> 48:11.230 Zum Beispiel geben wir dann aus, dieses Zeichen kenne ich nicht. 48:12.290 --> 48:14.850 Das heißt, der Benutzer hat weder ein Plus, noch ein Minus, noch ein 48:14.850 --> 48:16.050 Mal, noch ein Geteilt eingegeben. 48:16.650 --> 48:18.770 Und dann teilen wir dem Benutzer dann schon mit, hey, dieses Zeichen, 48:18.990 --> 48:20.470 dieses Operator kenne ich nicht. 48:21.230 --> 48:22.430 Gib noch was Neues ein oder so. 48:23.930 --> 48:25.270 Dieses Else ist optional. 48:25.510 --> 48:27.250 Das heißt, wir müssen das nicht immer am Schluss mit dem Else 48:27.250 --> 48:27.750 auffangen. 48:28.550 --> 48:29.230 Kann man aber. 48:29.870 --> 48:31.970 Es kommt darauf an, wie der Algorithmus ist. 48:32.110 --> 48:37.610 Und hier bei unserem Taschenrechner wäre dann eine gute Option, um 48:37.610 --> 48:39.670 falsche Eingaben aufzufangen. 48:42.490 --> 48:42.930 Okay. 48:45.770 --> 48:48.270 So, machen wir vielleicht erst das Quiz. 48:49.610 --> 48:52.050 Hier ist ein bisschen längeres Programm als bisher. 48:52.790 --> 48:54.530 Wir haben jetzt auch schon einiges Neues dazugelernt. 48:55.570 --> 48:58.030 Hier können Sie auch gerne mehr Zeit nehmen, um es sich durchzulesen. 48:58.510 --> 49:02.450 Und die Frage ist, ist dieses Programm korrekt, nicht korrekt oder 49:02.450 --> 49:04.730 kann ich im Moment noch nicht beurteilen? 49:06.030 --> 49:07.190 Lesen Sie es selber mal durch. 49:09.550 --> 49:10.710 Nehmen Sie ruhig Zeit. 49:15.650 --> 49:17.510 Ich glaube, wir können jetzt auf Ergebnis schalten. 49:20.210 --> 49:23.570 Okay, also es ist keine klare Aussage. 49:23.790 --> 49:24.950 Es ist alles gut. 49:26.090 --> 49:28.290 Eine leichte Mehrheit für das Programm ist korrekt. 49:30.290 --> 49:32.090 Dann 28% sagen nicht korrekt. 49:32.230 --> 49:33.490 Und viele wussten jetzt auch nicht genau. 49:33.590 --> 49:34.590 Das ist vollkommen in Ordnung. 49:36.090 --> 49:39.990 Ich gehe jetzt mal auf das Signal zurück. 49:41.390 --> 49:43.750 Also in der Tat ist das nicht ganz korrekt. 49:44.770 --> 49:46.850 Und zwar, den Fehler kann man ganz leicht machen. 49:48.750 --> 49:50.090 Wieso ist das Programm nicht korrekt? 49:50.870 --> 49:52.650 Ops, ich habe nicht umgeschaltet, Entschuldigung. 49:53.890 --> 49:57.090 Da muss man immer zweimal drücken, erstaunlicherweise. 49:58.310 --> 50:01.190 Okay, also das Programm ist nicht ganz korrekt. 50:01.850 --> 50:02.710 Also was passiert? 50:03.150 --> 50:05.390 Wenn Sie das einzippen, würde der Compiler das merken. 50:05.590 --> 50:06.710 Das ist schon mal eine gute Nachricht. 50:06.850 --> 50:10.450 Denn Fehler, die der Compiler merkt, sind immerhin nicht ganz so 50:10.450 --> 50:10.610 schlimm. 50:10.710 --> 50:13.670 Man ist dann zwar eventuell verwirrt, wie ich gerade eben auch. 50:15.070 --> 50:18.070 Aber Sie laufen nicht in das Problem rein, dass Sie ein Programm 50:18.070 --> 50:20.350 vielleicht für korrekt halten und jahrelang benutzen. 50:20.450 --> 50:22.890 Und haben hinterher gemerkt, da sind viele fiese Programmierfehler 50:22.890 --> 50:23.070 drin. 50:23.530 --> 50:24.870 Also der Compiler merkt folgendes. 50:25.450 --> 50:26.390 Hier kommt dieses If. 50:26.830 --> 50:28.030 Da wird eine Bedingung abgefragt. 50:28.150 --> 50:29.010 Das ist noch alles okay. 50:29.590 --> 50:33.730 Dann steht hier eine Anweisung, die wird dann entweder übersprungen 50:33.730 --> 50:34.150 oder nicht. 50:34.250 --> 50:34.990 Das ist die Zeile 9. 50:35.570 --> 50:37.390 Und dann kommt noch eine Anweisung auf die Zeile 10. 50:38.150 --> 50:40.270 Und das sieht so aus, als wäre das auch noch Teil von diesem If. 50:40.530 --> 50:41.790 Also dass es auch noch übersprungen wird. 50:41.850 --> 50:42.610 Und dann kommt ein Else. 50:43.930 --> 50:48.310 Das ist aber nicht korrekt, denn der Compiler wird sagen, hier steht 50:48.310 --> 50:49.810 ein Else ohne ein vorheriges If. 50:50.190 --> 50:52.190 Weil das If ist beendet nach einer Anweisung. 50:53.650 --> 50:56.830 Nach dem If folgt nur eine Anweisung, die übersprungen wird oder 50:56.830 --> 50:57.050 nicht. 50:57.050 --> 51:00.470 Das heißt, für den Compiler ist diese Zeile 10 kein Teil von dem If 51:00.470 --> 51:00.890 -Block mehr. 51:00.970 --> 51:04.110 Das heißt, der ist hier mit der Zeile 8 und 9 beendet. 51:05.850 --> 51:08.250 Dass die Zeile 10 eingerückt ist, heißt nichts. 51:09.350 --> 51:10.970 Das Eindrücken ist eine persönliche Vorliebe. 51:11.090 --> 51:13.690 Das kann man machen oder muss man aber nicht machen. 51:14.290 --> 51:16.570 Das heißt, der Compiler wird an der Zeile 11 meckern und sagen, hier 51:16.570 --> 51:18.430 steht ein Else und da ist kein vorheriges If. 51:19.170 --> 51:21.970 Also ein Else muss auf ein If folgen und da darf dazwischen nur eine 51:21.970 --> 51:22.650 Anweisung sein. 51:25.270 --> 51:26.570 Okay, steht hier nochmal. 51:26.830 --> 51:29.110 Ups, falsche Richtung. 51:30.110 --> 51:35.310 Also, wenn man dieses Programm so haben möchte, dass in der Tat diese 51:35.310 --> 51:39.090 zwei Zeilen übersprungen werden sollen, als Resultat dieser Bedingung 51:39.090 --> 51:41.710 oder eben ausgeführt werden sollen, muss man die gruppieren. 51:42.410 --> 51:44.330 Gruppieren haben wir jetzt noch nicht kennengelernt, das kommt jetzt 51:44.330 --> 51:44.610 gleich. 51:45.130 --> 51:48.330 Gruppieren heißt einschließen in geschweifte Klammern. 51:49.030 --> 51:54.770 Also immer dann, wenn der Compiler eine Anweisung erwartet, man möchte 51:54.770 --> 51:58.330 da aber mehrere Anweisungen reinschreiben, hintereinander, dann 51:58.330 --> 51:59.110 gruppiert man das. 51:59.790 --> 52:01.830 Und Sie werden kennenlernen, gruppieren benutzt man ganz oft. 52:02.410 --> 52:04.650 Das ist auch manchmal, selbst wenn es nicht strikt notwendig ist, das 52:04.650 --> 52:05.350 schadet auch nichts. 52:05.750 --> 52:08.730 Das heißt, man fügt Programmteile in solche geschweiften Klammern ein, 52:09.550 --> 52:12.190 einmal auf, einmal zu und alles was dazwischen ist, ist für den 52:12.190 --> 52:14.870 Compiler dann sozusagen nominell eine einzelne Anweisung. 52:15.330 --> 52:18.610 Das heißt, wenn man hier hinter eine geschweifte Klammer aufgemacht 52:18.610 --> 52:21.730 hätte und hier hinter dann wieder zu, wäre alles in Ordnung gewesen. 52:22.790 --> 52:24.310 Genauso hier nach dem else und hier. 52:25.170 --> 52:28.010 Die Tatsache, dass man das eingerückt hat, hat überhaupt nichts zu 52:28.010 --> 52:28.310 bedeuten. 52:28.390 --> 52:30.090 Der Compiler, der interessiert das Einrücken nicht. 52:30.310 --> 52:34.290 C++ ist eine formatfreie Sprache, das Einrücken ist nur für die 52:34.290 --> 52:35.030 Lesbarkeit für Sie. 52:36.530 --> 52:38.250 Hier hat das Einrücken aber getäuscht. 52:38.990 --> 52:42.070 Das war also ein bisschen eine gemeine Frage, das passiert aber oft in 52:42.070 --> 52:42.530 der Praxis. 52:42.530 --> 52:45.890 Sie haben irgendwas falsch eingerückt in Anführungsstrichen, weil Sie 52:45.890 --> 52:48.710 vielleicht irgendwie erwartet haben, dass das so ist. 52:48.790 --> 52:50.850 Es ist aber andersrum und dem Compiler ist das Einrücken egal. 52:51.530 --> 52:52.870 Wenn Sie das gruppieren, ist das in Ordnung. 52:54.130 --> 52:57.910 Also Sie können längere Programmteile, wie zum Beispiel hier, in 52:57.910 --> 53:01.990 diesem Fall nur zwei Zeilen, mit so einer geschweiften Klammer auf und 53:01.990 --> 53:04.050 zu zusammenfügen und dann ist das in Ordnung. 53:04.130 --> 53:08.210 Zum Beispiel hier wollen wir schauen, ob eine Gleitkommazahl größer 0 53:08.210 --> 53:08.490 ist. 53:08.970 --> 53:11.490 Nur dann rechnen wir den Logarithmus und die Wurzel aus. 53:11.490 --> 53:14.070 Weil wir wissen, das geht sonst nicht, das ist sonst eine komplexe 53:14.070 --> 53:14.650 Zahl usw. 53:15.650 --> 53:18.070 Das heißt, wir haben hier eine Bedingung, aber wir haben zwei 53:18.070 --> 53:21.330 Anweisungen, die als Resultat auf diese Bedingung dann übersprungen 53:21.330 --> 53:21.970 werden sollen oder nicht. 53:22.810 --> 53:25.870 Und gruppieren die jetzt, fügen die also zusammen mit der geschweiften 53:25.870 --> 53:26.190 Klammer. 53:27.590 --> 53:33.430 Ich glaube das Beste ist, man gewöhnt sich an, mein persönlicher Tipp, 53:33.990 --> 53:36.690 diese IF-Blöcke immer mit der Klammer zu umfassen. 53:36.990 --> 53:38.190 Auch wenn das nur eine Zeile ist. 53:38.190 --> 53:41.070 Wenn Sie die mit der Klammer umfassen, dann haben Sie sich direkt 53:41.070 --> 53:43.250 angewöhnt, dass es gruppiert, dann haben Sie dieses Problem gar nicht. 53:44.410 --> 53:48.330 Also einfach angewöhnen, das IF, immer direkt Klammer auf, dann eine 53:48.330 --> 53:49.730 oder mehrere Zeilen und dann Klammer zu. 53:50.590 --> 53:52.490 Und das Einrücken ist für Ihre eigene Hilfe. 53:52.930 --> 53:53.670 So, jetzt war dann eine Frage. 54:02.640 --> 54:03.500 Hier brauchen Sie es. 54:03.600 --> 54:04.080 Hier, meinen Sie? 54:09.620 --> 54:11.820 Sie brauchen es hier deswegen nicht, weil wir hier keine 54:11.820 --> 54:14.120 mathematischen Operationen haben, die jetzt nicht... 54:14.860 --> 54:17.180 Wir machen hier praktisch nichts, wir haben nur plus plus als 54:17.180 --> 54:20.220 Operation und das ist in der Tat Teil von der C++-Sprache. 54:20.680 --> 54:24.420 Also dieses C-Math brauchen Sie dann, wenn Sie Sinus, Kosinus, Wurzel, 54:24.720 --> 54:25.120 Potenz... 54:28.320 --> 54:30.640 Und eben leider, genau, in der Tat auch die Potenz. 54:30.760 --> 54:32.840 Also wie gesagt, in vielen anderen Sprachen können Sie die Potenz 54:32.840 --> 54:35.060 einfach mit dem Symbol ausdrücken, bei C++ brauchen Sie es schon, wenn 54:35.060 --> 54:36.680 Sie irgendwas zum Quadrat nehmen. 54:37.580 --> 54:39.780 Aber hier brauchen Sie es nicht, hier würden Sie es brauchen. 54:45.720 --> 54:49.560 So, also wir sind eigentlich jetzt soweit, dass wir in unserem 54:49.560 --> 54:52.380 Taschenrechner -Programm unterscheiden können. 55:00.120 --> 55:05.740 Wir hatten also jetzt hier in unserer letzten Version ein einfaches IF 55:05.740 --> 55:10.060 ohne weitere Alternativen und wir könnten jetzt beliebig hier zum 55:10.060 --> 55:16.360 Beispiel noch eine Multiplikation hinzufügen. 55:33.960 --> 55:38.340 Die sind jetzt in diesem Fall nicht stricken notwendig, aber wie 55:38.340 --> 55:39.140 gesagt, schaden nicht. 55:39.620 --> 55:40.660 Und ich finde, das ist eine gute Angewohnheit. 55:41.900 --> 55:46.700 Jetzt würde man hier Multin schreiben, zum Beispiel, und so weiter. 55:46.920 --> 55:48.720 Und jetzt könnte man zum Beispiel noch ein Else hinterschreiben. 56:00.850 --> 56:04.090 Also wir würden jetzt so vorgehen, dass wir verschiedene Auswahlen 56:04.090 --> 56:07.270 haben, also verschiedene Alternativen für alle unsere Symbole, die wir 56:07.270 --> 56:07.730 definieren. 56:07.870 --> 56:09.710 Also nehmen wir an, wir stellen zur Verfügung eine Addition, eine 56:09.710 --> 56:13.590 Multiplikation, dann hätten wir entweder Addition, würde ich hier kurz 56:13.590 --> 56:18.570 ausgeben, oder Multiplikation, oder eben alle anderen, wir kennen 56:18.570 --> 56:19.470 diesen Operator nicht. 56:34.390 --> 56:35.930 So, Klammern haben wir kennengelernt. 56:36.530 --> 56:39.190 Beim Gruppieren noch ganz kurz die Sache, aber das merkt der Compiler 56:39.190 --> 56:41.950 auch, nach dem Gruppieren brauchen Sie jetzt keinen Semikolon. 56:43.610 --> 56:45.470 Das sind einfach nur die Klammern, da ist dann nicht nochmal ein 56:45.470 --> 56:46.150 Semikolon dahinter. 56:51.630 --> 56:54.290 Können Sie jetzt hier ein bisschen eine endgültigere Version auch 56:54.290 --> 56:55.050 gerne ausprobieren. 56:57.310 --> 57:01.630 Die Frage, die jetzt noch aussteht, ist, was für Arten von Bedingungen 57:01.630 --> 57:04.650 gibt es eigentlich, und sie sind ja nicht immer so einfach, dass ich 57:04.650 --> 57:05.870 nur zwei Daten vergleiche. 57:06.710 --> 57:08.870 Und da kann man vielleicht unterscheiden, die Bedingungen, die 57:08.870 --> 57:13.150 numerische Art sind, oder arithmetische Art, und die, die logische Art 57:13.150 --> 57:13.370 sind. 57:14.590 --> 57:17.830 Also es gibt Bedingungen, die direkt mit logischen Operationen und 57:17.830 --> 57:22.810 logischen Ausdrücken umgehen, und andere, die mit numerischen Daten 57:22.810 --> 57:23.070 umgehen. 57:23.770 --> 57:28.310 Und die typischen numerischen Daten sind eben Vergleiche, größer, 57:28.390 --> 57:29.530 kleiner, gleich und so weiter. 57:30.230 --> 57:33.910 Und die Frage, die wir hier auf der Folie sehen, ist, wie ist denn das 57:33.910 --> 57:38.430 eigentlich, wenn ich jetzt zum Beispiel so eine Bedingung formuliere. 57:38.430 --> 57:40.730 Also wir hatten sowas kennengelernt, x gleich gleich y. 57:41.010 --> 57:44.990 Und nochmal, gleich gleich bedeutet Gleichheitsoperate, man fragt ab, 57:45.070 --> 57:46.630 sind die beiden gleichwertig. 57:47.090 --> 57:49.650 Dann gibt es eben ein eindeutiges Ja oder Nein, oder wahr oder falsch. 57:50.210 --> 57:52.450 Man kann aber auch solche Bedingungen formulieren, sogenannte 57:52.450 --> 57:53.310 implizite Bedingungen. 57:53.410 --> 57:55.230 Da kann einfach nur eine Variable stehen. 57:56.250 --> 57:57.370 Das sieht jetzt ein bisschen komisch aus. 57:57.690 --> 57:59.850 If x, dann was? 58:00.170 --> 58:01.330 Was wird denn eigentlich abgefragt? 58:02.150 --> 58:04.970 Und in der Tat ist es so, wenn man da ganz genau hinschaut, da wird 58:04.970 --> 58:08.650 nur abgefragt, ob diese Bedingung als wahr oder falsch ausgewertet 58:08.650 --> 58:08.790 wird. 58:08.930 --> 58:13.330 Und zwar falsch heißt dann, wenn x genau den Wert 0 hat. 58:14.310 --> 58:17.110 Das ist jetzt nicht unbedingt etwas, was empfehlenswert ist. 58:17.530 --> 58:19.330 Man kann in der Tat auch eine Bedingung so formulieren, dass man 58:19.330 --> 58:22.050 einfach nur schaut, was ist der Wert dieser Variable oder dieses 58:22.050 --> 58:22.650 Ausdruckes. 58:23.190 --> 58:27.010 Und nur dann, wenn der genauen exakt 0 ist, ist die Variable falsch. 58:27.270 --> 58:31.390 Und in allen anderen Fällen ist die Antwort, die Bedingung richtig. 58:31.390 --> 58:35.470 Das heißt, selbst bei 10 hoch minus 16, eine ganz, ganz kleine Zahl, 58:35.730 --> 58:36.930 wird er dann als richtig gewertet. 58:37.430 --> 58:40.270 Und das hängt dann wiederum von der Präzision ab, mit der intern Ihre 58:40.270 --> 58:40.970 Maschine arbeitet. 58:41.090 --> 58:44.510 Von daher sind solche Abfragen bei Zahlen, die jetzt nicht ganz Zahlen 58:44.510 --> 58:45.510 sind, sehr, sehr problematisch. 58:46.310 --> 58:48.990 Weil es ist die Frage, ob Ihr Rechner jetzt gerade 10 hoch minus 16 58:48.990 --> 58:50.630 als 0 ansieht oder als nicht 0. 58:51.570 --> 58:53.090 Das kann man nicht so leicht beantworten. 58:53.910 --> 58:56.750 Für unser 1 ist 10 hoch minus 16 0, aber eben nicht für jede Maschine. 58:57.270 --> 58:59.610 Von daher sind solche Bedingungen relativ gefährlich, so zu 58:59.610 --> 58:59.970 formulieren. 58:59.970 --> 59:01.270 Sind aber legal in C++. 59:01.650 --> 59:02.590 Also man darf das machen. 59:03.030 --> 59:04.130 Und der Compiler wird nicht meckern. 59:04.550 --> 59:05.830 Zum Beispiel hier sehen Sie das Beispiel. 59:06.630 --> 59:08.850 Hier wird eine Gleitkommazahl definiert, die hat jetzt einen relativ 59:08.850 --> 59:09.590 kleinen Wert. 59:11.190 --> 59:14.430 Vielleicht für den einen oder anderen 3 mal 10 hoch minus 5 ungefähr. 59:15.010 --> 59:18.790 Wenn ich da schreibe if f und danach irgendwas ausgebe, können Sie 59:18.790 --> 59:19.550 gerne ausprobieren. 59:19.810 --> 59:21.970 Typischerweise wird hier herauskommen, ja, die Bedingung ist erfüllt, 59:22.450 --> 59:26.150 weil eben der Compiler dieses 3 mal 10 hoch minus 5 nicht gleich 0 59:26.150 --> 59:26.530 ansieht. 59:26.990 --> 59:28.710 Das ist noch eine Zahl, die noch messbar ist. 59:29.490 --> 59:31.070 Kommt aber auch auf die Präzision an. 59:31.450 --> 59:32.910 Sie können auch gerne mal ausprobieren bei sich. 59:33.510 --> 59:37.270 Und diese Potenz, das ist ja die wissenschaftliche Darstellung. 59:38.350 --> 59:45.150 Ich hoffe, das ist jedem klar, dass dieses 3.1e-5 bedeutet 3,1 mal 10 59:45.150 --> 59:45.770 hoch minus 5. 59:46.570 --> 59:48.470 Ihr wissenschaftlicher Taschenrechner arbeitet ja auch so. 59:48.730 --> 59:51.150 Wenn Sie auf Ihrem Taschenrechner eintippen, dann geben Sie oft mal 59:51.150 --> 59:51.910 10er -Potenzen ein. 59:51.970 --> 59:55.370 Sie würden ja jetzt nicht 0,0003 eintippen, sondern Sie tippen das ja 59:55.370 --> 59:55.710 so ein. 59:56.270 --> 59:57.630 Also in C++ ist das genauso. 59:57.630 --> 01:00:00.390 In der sogenannten wissenschaftlichen Darstellung, dass e bedeutet 01:00:00.390 --> 01:00:01.290 eine 10er-Potenz. 01:00:01.730 --> 01:00:02.750 Und danach steht der Exponent. 01:00:03.710 --> 01:00:06.110 Das ist also nicht e hoch minus 5, sondern 10 hoch minus 5. 01:00:08.230 --> 01:00:10.250 Sie können jetzt gerne ausprobieren bei diesen Programmen. 01:00:10.330 --> 01:00:13.170 Sie können sich hier durchklicken und diese Zahl immer runterdrehen. 01:00:13.270 --> 01:00:15.130 Also auf minus 6, minus 7, minus 10. 01:00:15.630 --> 01:00:18.490 Und dann schauen, ab wann eben diese Bedingung nicht mehr erfüllt ist. 01:00:19.450 --> 01:00:22.470 Das ist sozusagen die Grenze, bei der der Compiler denkt, aha, die 01:00:22.470 --> 01:00:23.590 Zahl ist so klein, die ist gleich 0. 01:00:26.190 --> 01:00:28.190 Okay, also Sie hätten solche impliziten Bedingungen. 01:00:28.810 --> 01:00:30.310 Ich würde Ihnen aber empfehlen, die zu vermeiden. 01:00:30.930 --> 01:00:33.290 Sie sehen die manchmal, aus meiner Sicht sind sie nicht 01:00:33.290 --> 01:00:33.890 empfehlenswert. 01:00:35.190 --> 01:00:37.890 Also die typischen Bedingungen sind solche, nämlich 01:00:37.890 --> 01:00:40.690 Vergleichsoperationen zwischen numerischen Daten. 01:00:41.170 --> 01:00:42.390 Sie vergleichen Werte. 01:00:43.150 --> 01:00:44.070 Ist x größer y? 01:00:44.450 --> 01:00:45.510 Ist x kleiner y? 01:00:45.870 --> 01:00:47.330 Ist x größer gleich y? 01:00:47.570 --> 01:00:48.870 Ist x kleiner gleich y? 01:00:49.430 --> 01:00:52.010 Gleich hatten wir schon, ungleich gibt es auch. 01:00:52.530 --> 01:00:54.010 Also die Negation davon. 01:00:55.850 --> 01:00:59.970 Ungleich hat auch zwei Zeichen, dieser Operator, nämlich das 01:00:59.970 --> 01:01:01.650 Ausrufezeichen und das Gleiche Zeichen. 01:01:02.170 --> 01:01:05.310 Das sind auch Dinge, die sind auch nicht in jeder Sprache gleich. 01:01:06.070 --> 01:01:08.410 In manchen Sprachen wird zum Beispiel die Tilde benutzt. 01:01:08.830 --> 01:01:11.430 Aber die Negation in C++ ist das Ausrufezeichen. 01:01:14.110 --> 01:01:18.830 So, jetzt nochmal komme ich nochmal zurück zu dem, was ich eben gesagt 01:01:18.830 --> 01:01:19.130 habe. 01:01:19.130 --> 01:01:23.450 Es besteht eine große Gefahr, und der ein oder andere von Ihnen wird 01:01:23.450 --> 01:01:27.190 das sicher mal hier spüren bei der Übung, dass Sie das doppelte 01:01:27.190 --> 01:01:29.350 Gleicherzeichen mit dem einfachen Gleicherzeichen verwechseln. 01:01:30.190 --> 01:01:32.370 Nochmal, das einfache Gleicherzeichen ist die Zuweisung. 01:01:33.590 --> 01:01:38.210 Und es ist jetzt vielleicht leider so, dass in C++ so eine Bedingung 01:01:38.210 --> 01:01:39.910 legal ist. 01:01:40.590 --> 01:01:42.830 Der Compiler merkt das nicht und der meckert da nicht. 01:01:43.190 --> 01:01:47.450 Sie können also schreiben, if x gleich y, mit einem Gleich. 01:01:48.230 --> 01:01:49.410 Was machen Sie da eigentlich? 01:01:50.070 --> 01:01:51.430 Sie machen da nicht etwas ganz, ganz Komisches. 01:01:52.010 --> 01:01:55.090 Sie sagen dem Compiler, werte erstmal diese Klammer aus. 01:01:55.370 --> 01:01:56.970 In der Klammer steht x gleich y. 01:01:57.550 --> 01:01:58.210 Was heißt das? 01:01:58.570 --> 01:02:01.610 Weise der Variable x den Wert von der Variable y zu. 01:02:01.950 --> 01:02:03.810 Das heißt, in der Klammer wird eine Zuweisung ausgeführt. 01:02:05.010 --> 01:02:07.770 Und das Resultat von der Zuweisung ist gleich dem Wert der rechten 01:02:07.770 --> 01:02:08.110 Seite. 01:02:08.230 --> 01:02:09.690 Das heißt, das Resultat ist gleich y. 01:02:10.470 --> 01:02:12.770 Wenn y nicht 0 ist, ist also die Antwort wahr. 01:02:13.950 --> 01:02:17.270 Also wenn Sie diese Bedingung schreiben, if Klammer auf x gleich y, 01:02:17.450 --> 01:02:21.070 haben Sie erstmal den Wert von x geändert, nämlich gleich dem Wert von 01:02:21.070 --> 01:02:21.650 y gesetzt. 01:02:22.310 --> 01:02:25.070 Und sobald der Wert von y nicht 0 war, ist die Bedingung immer wahr. 01:02:25.730 --> 01:02:29.250 Sie haben also überhaupt nicht überprüft, ob x gleich y ist, sondern 01:02:29.250 --> 01:02:30.770 Sie haben die eigentlich gleich gesetzt. 01:02:31.610 --> 01:02:32.730 Das ist also komplett was anderes. 01:02:33.570 --> 01:02:35.630 Es wird angeboten, ob Sie das schreiben oder das. 01:02:35.930 --> 01:02:36.890 Da sind Welten dazwischen. 01:02:36.970 --> 01:02:38.210 Der Compiler merkt den Unterschied nicht. 01:02:38.570 --> 01:02:39.710 Der meint, Sie wissen, was Sie tun. 01:02:40.450 --> 01:02:42.630 Deshalb Vorsicht bei dem doppelten Gleichheitszeichen. 01:02:42.890 --> 01:02:43.930 Nicht das Einfache benutzen. 01:02:46.750 --> 01:02:48.090 Okay, und nochmal die andere Warnung. 01:02:48.850 --> 01:02:52.790 Vorsicht, wenn Sie Gleichheit prüfen zwischen einer Gleitkommazahl und 01:02:52.790 --> 01:02:53.790 einer festen Grenze. 01:02:54.250 --> 01:02:59.230 Weil die Gleitkommazahl ist vielleicht 1,000000 und irgendwo bei der 01:02:59.230 --> 01:02:59.850 10., 12. 01:03:00.010 --> 01:03:00.970 Stelle ist nochmal eine 1. 01:03:01.430 --> 01:03:04.290 Dann ist die Frage, wollen Sie eigentlich, dass die gleich sind oder 01:03:04.290 --> 01:03:05.090 dass die nicht gleich sind? 01:03:05.090 --> 01:03:09.030 Wie scharf ist Ihre Grenze, beziehungsweise wie hoch ist die interne 01:03:09.030 --> 01:03:10.230 Präzision von Ihrem Rechner? 01:03:10.910 --> 01:03:15.390 Also wenn Sie Gleitkommazahlen mit Werten vergleichen, und zwar eine 01:03:15.390 --> 01:03:16.810 scharfe Grenze, dann müssen Sie aufpassen. 01:03:20.670 --> 01:03:24.350 Jetzt gibt es andere Operationen oder andere Bedingungen, die Sie 01:03:24.350 --> 01:03:25.050 formulieren können. 01:03:25.410 --> 01:03:26.930 Da sind dann logische Operationen drin. 01:03:27.410 --> 01:03:29.130 Bisher hatten wir Vergleiche typischerweise. 01:03:29.470 --> 01:03:31.190 Gleichheit, kleiner Gleich, größer Gleich. 01:03:31.850 --> 01:03:35.470 Und jetzt können Sie auch direkt logische Ausdrücke benutzen. 01:03:36.530 --> 01:03:39.270 Auf diese Weise können Sie insbesondere verschiedene Bedingungen 01:03:39.270 --> 01:03:39.850 verknüpfen. 01:03:43.650 --> 01:03:44.730 Hier unten ist ein Beispiel. 01:03:44.870 --> 01:03:48.170 Sie wollen vielleicht feststellen, ob das Alter einer Person in einem 01:03:48.170 --> 01:03:49.010 gewissen Bereich liegt. 01:03:49.450 --> 01:03:53.050 Ob es größer als die untere Schranke ist und gleichzeitig kleiner als 01:03:53.050 --> 01:03:53.790 die obere Schranke. 01:03:54.330 --> 01:03:56.290 Nämlich wenn das der Fall ist, liegt es in einem Intervall. 01:03:56.930 --> 01:03:58.950 Es könnte ja ganz drunter liegen oder ganz drüber, aber Sie wollen, 01:03:59.050 --> 01:03:59.890 dass es in einem Intervall liegt. 01:03:59.890 --> 01:04:01.890 Eigentlich müssen Sie da zwei Bedingungen prüfen. 01:04:02.710 --> 01:04:06.590 Ist das Alter größer als die untere Schranke und gleichzeitig kleiner 01:04:06.590 --> 01:04:07.150 als die obere? 01:04:07.730 --> 01:04:10.930 Das heißt, das sind zwei separate Bedingungen und die sind auch noch 01:04:10.930 --> 01:04:12.250 durch das logische Und verknüpft. 01:04:12.830 --> 01:04:14.730 Weil Sie wollen, dass beide gleichzeitig wahr sind. 01:04:16.450 --> 01:04:21.890 Dazu gibt es eben in C++ diese Ausdrücke, diese logischen Operatoren. 01:04:22.870 --> 01:04:27.290 Nämlich das logische Und ist ein doppeltes kaufmännisches Und. 01:04:29.970 --> 01:04:43.590 Und dieser doppelte vertikale Strich ist das logische Oder. 01:04:45.550 --> 01:04:48.930 Und dann gibt es noch die logische Negation, das ist das 01:04:48.930 --> 01:04:50.010 Ausrufezeichen. 01:04:50.010 --> 01:04:55.750 Dazu können wir das vielleicht nochmal kurz hier auf diese simulierte 01:04:55.750 --> 01:04:56.390 Tafel gehen. 01:05:07.770 --> 01:05:09.590 Mal die logischen Operatoren anschauen. 01:05:10.390 --> 01:05:11.650 Ich weiß nicht, ob das jedem so klar ist. 01:05:12.210 --> 01:05:17.550 Also nehmen wir an, wir haben zwei Variablen oder 01:05:21.900 --> 01:05:23.260 Ausdrücke, X und Y. 01:05:24.160 --> 01:05:26.180 Die sind jeweils für sich wahr oder falsch. 01:05:28.040 --> 01:05:29.760 Und da gibt es alle möglichen Kombinationen. 01:05:29.760 --> 01:05:30.800 Also ich schreibe jetzt mal ein True. 01:05:35.360 --> 01:05:36.640 Können beide wahr sein. 01:05:42.090 --> 01:05:45.250 Wir haben verschiedene Zustände sozusagen. 01:05:49.530 --> 01:05:52.090 Können nämlich beide wahr sein oder beide falsch oder eben der eine 01:05:52.090 --> 01:05:52.850 wahr, der andere falsch. 01:05:54.250 --> 01:06:03.310 Wir wollen jetzt solche logischen Operatoren auswerten, nämlich der 01:06:04.680 --> 01:06:07.280 erste, den wir auswerten wollen und schauen, was es ergibt, ob das 01:06:07.280 --> 01:06:08.200 eben wahr oder falsch ist. 01:06:20.970 --> 01:06:24.090 Also wir hätten jetzt zwei Variablen, X und Y. 01:06:24.750 --> 01:06:27.250 Die haben Zustände entweder wahr oder falsch, das sind also bool'sche 01:06:27.250 --> 01:06:27.770 Variablen. 01:06:29.090 --> 01:06:31.110 Und wir haben dann also alle Kombinationen vorliegen. 01:06:32.550 --> 01:06:36.670 Und wollen jetzt erstmal diese erste Operation ausführen, nämlich X 01:06:36.670 --> 01:06:37.230 und Y. 01:06:39.770 --> 01:06:44.650 Sie sollen mir sagen, ob dieser Ausdruck X und Y wahr oder falsch ist. 01:06:45.550 --> 01:06:46.990 Also in der Zeile 1 schauen wir mal. 01:06:48.350 --> 01:06:52.090 Da haben wir X ist true, also wahr, Y ist true, also auch wahr. 01:06:53.110 --> 01:06:55.450 Und was ist dann die Antwort von X und Y? 01:07:01.340 --> 01:07:03.440 Ich glaube, dafür brauchen wir nicht diese Abstimmungsgeräte. 01:07:04.000 --> 01:07:05.880 Es darf auch jemand einfach so sagen, wahr, okay. 01:07:06.520 --> 01:07:10.020 Also es wird abgefragt, ob eben dieser kombinierte Ausdruck wahr ist. 01:07:10.100 --> 01:07:13.840 Mit anderen Worten, wird an dieser Stelle gefragt, in dieser Zeile 01:07:13.840 --> 01:07:15.780 wird gefragt, ob beide wahr sind. 01:07:16.100 --> 01:07:16.700 Logisches und. 01:07:16.860 --> 01:07:18.400 Beide sollen wahr sein, nur dann ist es wahr. 01:07:19.120 --> 01:07:22.400 Das heißt, das ist hier wahr. 01:07:23.600 --> 01:07:27.120 Und in der zweiten Zeile, da haben wir true, false. 01:07:28.580 --> 01:07:29.800 Wie ist dann die Gesamtantwort? 01:07:36.800 --> 01:07:37.640 Ich höre nichts. 01:07:39.100 --> 01:07:43.520 Falsch, weil sobald eine von beiden falsch wird, sind eben nicht mehr 01:07:43.520 --> 01:07:46.080 beide wahr und somit ist der Gesamtausdruck dann auch falsch. 01:07:46.580 --> 01:07:48.860 Das gilt natürlich auch hier, weil dann ist auch einer falsch und wenn 01:07:48.860 --> 01:07:49.800 beide falsch sind, sowieso. 01:07:51.340 --> 01:07:54.720 Also X und Y ist nur in einem Fall wahr. 01:07:55.540 --> 01:07:57.940 So, jetzt kommen wir zu X oder Y. 01:07:59.100 --> 01:08:04.360 Heißt, schau bitte nach, ob entweder X oder Y wahr ist. 01:08:06.000 --> 01:08:10.040 Und nur in diesem Fall bist du wahr. 01:08:10.720 --> 01:08:12.640 Also, fangen wir an. 01:08:12.720 --> 01:08:13.320 Beide sind wahr. 01:08:14.700 --> 01:08:15.320 Was kommt dann raus? 01:08:17.640 --> 01:08:18.120 Wahr. 01:08:21.360 --> 01:08:23.240 Nur der erste ist wahr, der zweite nicht. 01:08:25.240 --> 01:08:25.720 Wahr. 01:08:26.800 --> 01:08:27.740 Und hier auch. 01:08:28.440 --> 01:08:29.320 Und in der letzten Zeile? 01:08:31.000 --> 01:08:31.400 False. 01:08:32.800 --> 01:08:34.380 Sie sehen also, das macht einen Unterschied. 01:08:35.580 --> 01:08:36.800 Und dann hätten wir noch die Negation. 01:08:37.620 --> 01:08:41.920 Die Negation ist eben, man dreht den Wahrheitsgehalt sozusagen um. 01:08:43.180 --> 01:08:44.580 Wir haben jetzt das hier nur für X hingeschrieben. 01:08:44.740 --> 01:08:48.020 Das heißt, uns interessieren eigentlich nur die Zeile 1 und 3. 01:08:48.680 --> 01:08:49.900 Was kommt in der Zeile 1 raus? 01:08:50.560 --> 01:08:51.780 X ist wahr. 01:08:52.160 --> 01:08:54.020 Was ist dann nicht X? 01:08:56.620 --> 01:08:56.980 Falsch. 01:08:57.020 --> 01:08:58.580 Ja, also wir drehen das einfach um. 01:08:59.200 --> 01:08:59.800 Hier mal falsch. 01:08:59.800 --> 01:09:01.300 In der Zeile 2 dann natürlich auch. 01:09:02.000 --> 01:09:03.040 Zeile 3 wäre das Umgekehrte. 01:09:03.320 --> 01:09:03.520 True. 01:09:07.000 --> 01:09:07.400 Okay. 01:09:08.020 --> 01:09:08.900 So, und jetzt sehen wir hier nochmal... 01:09:20.720 --> 01:09:21.120 Ja. 01:09:22.500 --> 01:09:23.960 Das Umgekehrte von falsches war. 01:09:29.800 --> 01:09:30.700 Soll ich nochmal zurückgehen? 01:09:32.820 --> 01:09:33.420 Hat's ihr ledig? 01:09:33.480 --> 01:09:33.680 Gut. 01:09:34.640 --> 01:09:34.860 Okay. 01:09:35.880 --> 01:09:38.340 Also, Sie sehen also jetzt, dass wir mit dieser... 01:09:39.760 --> 01:09:43.460 mit dieser zusammengesetzten Bedingung uns das Leben ein bisschen 01:09:43.460 --> 01:09:44.140 leichter machen können. 01:09:44.220 --> 01:09:46.840 Wir können dann in einen einzigen If-Block oder in eine einzige 01:09:46.840 --> 01:09:50.080 Bedingung für ein einziges If eine kombinierte Bedingung 01:09:50.080 --> 01:09:52.680 reinschreiben, die eigentlich aus zwei Abfragen besteht, die noch mit 01:09:52.680 --> 01:09:53.840 dem Logischen unverknüpft sind. 01:09:54.640 --> 01:09:57.020 Das ist manchmal viel lesbarer, als wenn Sie jetzt drei oder vier 01:09:57.020 --> 01:09:58.440 verschachtelte Ifs benutzen. 01:09:59.080 --> 01:10:01.540 Also hier steht If und dann steht eine äußere Klammer. 01:10:01.540 --> 01:10:04.500 Dann werden jetzt hier erstmal diese Klammern ausgewertet. 01:10:04.620 --> 01:10:08.480 Ist das Alter kleiner zwölf, kommt ein Wert raus, true oder false. 01:10:08.780 --> 01:10:11.400 Hier wird ausgewertet, ist das Alter größer zwei, kommt ein Wert raus, 01:10:11.480 --> 01:10:12.040 true oder false. 01:10:12.200 --> 01:10:14.480 Und diese beiden Werte werden mit dem Logischen unverknüpft. 01:10:14.820 --> 01:10:17.280 Es wird also geschaut, ob diese beiden wahr sind. 01:10:17.380 --> 01:10:20.340 Und nur wenn beide wahr sind, ist insgesamt der Gesamtausdruck auch 01:10:20.340 --> 01:10:20.540 wahr. 01:10:22.060 --> 01:10:24.240 Also hier überprüfen Sie, ob eben dieses Alter in einem gewissen 01:10:24.240 --> 01:10:25.560 Intervall liegt. 01:10:25.940 --> 01:10:28.900 Und dann wird irgendwie hier diese Ausgabe getätigt. 01:10:37.530 --> 01:10:40.970 Okay, wir sind eigentlich schon fast durch. 01:10:41.410 --> 01:10:42.350 Kommen wir gleich noch zum Quiz. 01:10:42.530 --> 01:10:46.470 Vielleicht kurz vor dem Quiz noch ein Hinweis. 01:10:47.750 --> 01:10:50.830 Sie merken schon, es ist wichtig, bei solchen zusammengesetzten 01:10:50.830 --> 01:10:54.090 Ausdrücken, die Priorität der Operatoren im Kopf zu behalten. 01:10:56.290 --> 01:10:59.590 Und die logischen Operatoren haben eine relativ geringere Priorität. 01:11:00.450 --> 01:11:05.510 Das heißt in der Tat, die Klammern helfen uns zwar, aber in der Tat 01:11:05.510 --> 01:11:10.710 werden diese Vergleiche erstmal ausgeführt und danach dieses und mit 01:11:10.710 --> 01:11:11.470 dem unverknüpft. 01:11:12.050 --> 01:11:14.170 Die genauen Regeln sind aber relativ kompliziert. 01:11:15.110 --> 01:11:19.750 Und Sie können sich das Leben erleichtern, indem Sie Klammern setzen. 01:11:20.470 --> 01:11:21.690 Klammern sind immer klar. 01:11:21.890 --> 01:11:25.590 Klammern haben die höchste Priorität, genau wie in der Mathematik. 01:11:25.650 --> 01:11:27.150 Durch Klammern setzen können Sie das beeinflussen. 01:11:27.150 --> 01:11:29.750 Selbst wenn die nicht notwendig sind, können Sie den Ausdruck leichter 01:11:29.750 --> 01:11:30.410 verständlich machen. 01:11:31.030 --> 01:11:33.150 Tun Sie sich einen Gefallen damit und auch denjenigen, die Ihre 01:11:33.150 --> 01:11:33.810 Programme lesen. 01:11:34.790 --> 01:11:38.190 Also eigentlich braucht man typischerweise nicht alle Regeln zu 01:11:38.190 --> 01:11:40.330 können, wenn man sich an die einfachen Regeln hält. 01:11:40.450 --> 01:11:44.610 Natürlich wissen Sie, dass die Punktrechnung vor der Strichrechnung 01:11:44.610 --> 01:11:48.030 geht, wie man so sagt, obwohl hier die Division ist auch ein Strich. 01:11:49.110 --> 01:11:50.430 Aber das kennen Sie aus der Mathematik. 01:11:51.050 --> 01:11:53.590 Und für die allen anderen Operatoren würde ich Klammern setzen. 01:12:02.230 --> 01:12:04.650 So, jetzt haben wir nochmal ein kleines Quiz. 01:12:09.370 --> 01:12:10.450 Also wir haben hier ein Programm. 01:12:11.150 --> 01:12:14.490 Wir bleiben immer so ungefähr bei den 10-15 Zeilen maximal, sonst wird 01:12:14.490 --> 01:12:14.950 das zu lang. 01:12:16.410 --> 01:12:17.890 Hier wird ein Wert vorgegeben. 01:12:18.030 --> 01:12:21.870 Hier wird eine Verzweigung ausgeführt, und zwar eine verschachtelte 01:12:21.870 --> 01:12:22.590 Verzweigung sogar. 01:12:23.630 --> 01:12:24.750 Das haben wir jetzt noch nicht gesehen. 01:12:24.870 --> 01:12:28.790 Wir haben IF, ELSE und wir haben dann nochmal in dem zweiten ELSE 01:12:28.790 --> 01:12:30.010 -Block auch nochmal IF, ELSE. 01:12:31.870 --> 01:12:34.970 Und wir haben natürlich da Bedingungen drin und Ausgaben. 01:12:36.310 --> 01:12:39.650 So, und die Frage ist jetzt, wenn das ganze Programm durchläuft oder 01:12:39.650 --> 01:12:43.570 dieser Programmteil durchläuft, welche Bildschirmausgabe wird erzeugt? 01:12:44.330 --> 01:12:45.770 Was sehen Sie auf dem Bildschirm danach? 01:12:54.410 --> 01:12:56.250 Also wie gesagt, das ist nur ein Programmausschnitt. 01:12:56.370 --> 01:12:59.050 Da müsste oben noch unsere Main-Funktion starten. 01:12:59.110 --> 01:13:00.870 Wir müssten noch die Iostream-Bibliothek laden. 01:13:00.950 --> 01:13:02.170 Das ist jetzt hier mal außerhalb. 01:13:03.830 --> 01:13:05.530 Wir brauchen noch 10-20 Stimmen. 01:13:05.530 --> 01:13:07.030 Jede Stimme zählt. 01:13:08.930 --> 01:13:12.010 Alles klar, Sie haben das alle, die meisten richtig gesehen. 01:13:12.110 --> 01:13:14.430 In der Tat ist jetzt hier keine Überraschung gewesen im Programm. 01:13:15.050 --> 01:13:18.010 Das Programm gibt das aus, was erwartet ist, nämlich positiv. 01:13:18.130 --> 01:13:18.850 Der Wert war positiv. 01:13:19.390 --> 01:13:22.690 Es war eine verschachtelte Verzweigung und es wird eben positiv 01:13:22.690 --> 01:13:23.270 ausgegeben. 01:13:23.490 --> 01:13:24.210 Alles in Ordnung. 01:13:24.970 --> 01:13:26.230 Ich bin mit meinem Stoff durch. 01:13:26.390 --> 01:13:28.370 Denken Sie daran, diese Woche starten die Übungen. 01:13:29.090 --> 01:13:31.310 Sie haben im Netz schon das Übungsblatt vorliegen. 01:13:32.110 --> 01:13:35.070 Herr Kidanemayem hat sich sehr viel Mühe damit gegeben, damit Sie ein 01:13:35.070 --> 01:13:36.970 schönes ballistisches Problem zu lösen haben. 01:13:37.570 --> 01:13:38.670 Dann wünsche ich Ihnen viel Erfolg. 01:13:38.810 --> 01:13:40.870 Wir sehen uns in zwei Wochen wieder hier in der Vorlesung.