Es gab ja so ein paar Grundbegriffe, int, um zu sagen, lege mir mal eine Variable an, in die eine ganze Zahl reingeht. Es gab while, die Schleife, so lange wie. Es gab if, zum verzweigen.

Mehr gab es bisher noch nicht. Ich wollte mit Ihnen heute mit diesen drei Grundbausteinen Folgendes bauen. Ein Programm, das versucht, die Wurzel 2 zu nähern. Und zwar suche ich eine ganze Zahl, ich nenne sie mal P, so dass diese ganze Zahl durch 100 ungefähr gleich Wurzel 2 ist.

Also das ist gesucht, eine ganze Zahl. Wir wissen natürlich schon, 141 wäre nicht schlecht, 141 hundertstel.

Wenn da jetzt nicht Wurzel 2 stünde, wenn da jetzt Wurzel 93 stünde, wüssten wir es nicht. Wie kann ich da fallen, welche ganze Zahl denn ungefähr rein muss, damit ich eine Näherung für die Wurzel 2 kriege? Erst mal haben wir nur ganze Zahlen, keine Gleitkommazahlen.

Jetzt habe ich hier dieser Trick mit durch 100 ungefähr Wurzel 2. Das muss man passend umformen und sich dann überlegen, wie man denn auf die Suche gehen kann. Das ist nicht völlig abwegig, man wird es in der Praxis nicht ganz so machen, aber es ist nicht völlig abwegig, solche Sachen zu veranstalten.

Die ganzen kleineren Microcontroller haben im Zweifelsfall keine Gleitkommerauperationen eingebaut. Die können nicht wirklich von selbst die Wurzel ziehen aus irgendeiner Zahl. Man muss sich dann irgendwie drum rum lügen. C kann sich auch drum rum lügen, aber dann hat man gleich monsterlange Programme, die jetzt besonders bei diesem kleinen Microcontroller

den Speicher voll machen. Also, das sieht erst mal ein bisschen unsinnig aus. Wurzel 2 sollte die Maschine eigentlich können. Im Prinzip ja, aber wenn die Maschine richtig klein ist, dann eben doch nicht. Wie geht man da dran? Ich suche eine ganze Zahl, sodass ein Hundertstel der ganzen Zahl ungefähr Wurzel 2 ist. Die möchte ich suchen mit einem Programm.

Die Frage war, wie ist das mit dem Speichern? Verlier ich das irgendwann, das Programmchen? Folgendes. Ich würde an einer Stelle, die ich wieder finde, einen Ordner anlegen für unser jeweiliges Projekt.

Und dann alles, was hier die Embedded Workbench veranstaltet, wenn ich sage Project, Create No Project, in diesen Ordner reinspeichern. Erste Sicherheitsmaßnahme, dann weiß man, wo es landet. Regelmäßig hier Save All klicken

oder einfach, wenn sich die Gelegenheit bietet, es laufen lassen. Um es laufen zu lassen, wird es auch gespeichert. Der Compiler arbeitet von der Flesseplatte, also es wird auf jeden Fall gespeichert, wenn Sie sagen, lass einmal laufen. Wenn Sie eine halbe Stunde arbeiten und weder hier den klicken, alles speichern, noch es laufen lassen, das ist gefährlich. Dann haben Sie nach dem Absturz nichts mehr auf der Platte.

Dieses Verzeichnis, was wir da angelegt haben, wird dann mit all möglichen Sachen gefüllt. Das hier ist offensichtlich ein Embedded Workbench Project. Das Projekt, das sagt, welche Dateien alle dabei waren. Zum Beispiel hier diese main.c-Datei mit unserem Programmtext.

Es gibt hier noch ein Workspace, der mehrere Projekte zusammenfassen kann, kompliziertere Geschichte ignorieren. Es gibt das, was übersetzt ist, was dann nachher tatsächlich auf dem Microcontroller gespielt würde. Als Programm.

Tausend Sachen können Sie alle erst mal ignorieren. Wichtig ist nur, dass Sie im Hinterkopf haben, es ist nicht nur eine Datei. Es sind ganz viele Dateien, die als Bündel zusammengehören. Die spannendste Datei ist hier dann die sowieso.c-Datei. Da steht das drin, was wir selbst geschrieben haben. Später schreiben wir auch mehrere.c-Dateien und noch andere.h-Dateien und sowas.

Die Dateien, die wir selbst geschrieben haben, das sind die wichtigen. Aber es gibt noch nebenbei alle möglichen Hilfstateien, die sagen, wie es denn zusammenspielt, was eingestellt worden ist in der hier in der Entwicklungsumgebung.

Das Ding muss sich ja irgendwo, das zum Beispiel merken, wenn ich hier sage, Maustick rechts, auf das Projekt, Options. Irgendwo muss es sich ja zum Beispiel merken, dass ich nicht diesen Chip haben will, sondern, dass ich den G-22-31 haben will. Irgendwo muss es sich merken,

dass ich, das ist auch noch eine wichtige Einstellung beim Arbeiten hier, dass ich die Optimierung ausgestellt habe und all sowas. Das landet alles in diesen Extra-Dateien drin. Das hier ist diese main.c-Datei. Da steht nun wirklich das drin, was hier an Buchstaben steht, nackter Text.

Der Rest muss auch noch irgendwo landen. Wenn Sie den Rest nicht dabei haben, müssen Sie ihn wieder rekonstruieren. Das nervt total. Also, um immer dieses ganze Bündel mitzunehmen. Machen Sie eine SIP-Datei daraus. Oh, das wollte ich auch noch mal zeigen. Das ist nicht immer bekannt. Maustick rechts. Senden an. SIP-komprimierte Ordner. Dann haben Sie eine einzige Datei, die Sie auch in eine

E-Mail packen können oder auf Dropbox oder was in einem Rutsch packen können. Senden an ist der Trick. Da kommt man nicht drauf. Das ist ein bisschen unsäglich, warum das Senden an muss sein soll hier. Also, klicken auf den Ordner, Senden an, SIP-komprimierten Ordner. Dann haben Sie eine

Datei, die Sie dann ja mit Doppelklick wieder auseinandernehmen können. Zurück zur Aufgabe. Da möchte ich jetzt, dass Sie dieses dazwischenschreiben. Ein Programmchen, das eine ganze Zahl bestimmt. Wir wissen schon, es ist 141 oder irgendwas in der Größenordnung. Eine ganze Zahl bestimmt, so dass die ganze Zahl durch 100 ungefähr Wurzel 2 ist. Wie gehe ich auf die Suche mit?

int, while und if Das soll dann hier irgendwo dazwischen. Diese Zeile hier werde ich vielleicht einmal mal ganz dreist weg machen. Das ist eine Spezialität für diesen speziellen Microcontroller.

Lässt sich da nicht so sehr dran gewöhnen an die Zeile. Übliches C sähe so aus. Das wäre alles, was man einen üblichen C hat. Und Ihr Job ist jetzt, die Zeilen hier zu ergänzen. Wurzel 2 können Sie ja noch gar nicht ausrechnen am Rechner.

Was ich viel mehr suche, ist folgendes. Ich quadriere. Ich suche eine Zahl P, sodass dieses Quadrat ungefähr 2 ist. Dann habe ich nur noch ganze Zahlen. Und die Welt ist in Ordnung. Ich kann jetzt nicht direkt irgendwie Wurzel 2 am Rechner verlangen. Aber ich kann das hier versuchen. Ich suche solange, bis ich eine Zahl habe, die

so ist, dass die Zahl durch 100 ins Quadrat ziemlich dicht bei Wurzel 2 ist. Oder dichter als alles andere, was ich sonst so finde an Wurzel 2 ist. Also erst mal diese gerundet Gleichung so ein bisschen vereinfachen.

P quadrat durch 10.000 ist ungefähr 2. Ich schreibe das mal hier jetzt als Äquivalent, was mathematisch ein bisschen zweifelhaft ist. Egal. P quadrat durch 10.000 ist ungefähr 2. Also ist P quadrat ungefähr 20.000. So. Ich suche also eine ganze Zahl, deren Quadrat ungefähr 20.000 ist.

Denn jetzt ist gar nicht mehr von Brüchen die Rede. Es ist schon gar nicht mehr von Wurzeln die Rede. Das können wir am ehrlich machen. Also ein Vorschlag. Wir suchen die letzte ganze Zahl. Wir fangen vorne an. 1, 2, 3, 4, 5 und so weiter. Wir suchen die letzte ganze Zahl, deren Quadrat unter

20.000 ist. Wir werden keine ganze Zahl finden, der Quadrat exakt gleich 20.000 ist. Sonst wäre Wurzel 2 ja keine so krumme Zahl. Wir suchen die letzte in Anführungszeichen, deren Quadrat gerade noch unter 20.000 ist, als eine Idee.

Ok, ein paar Sachen sehe ich gerade. Fangen Sie mit der Schleife an. Außen drum steht die Schleife und innen drin wird dann in der Schleife was passieren. Ich würde von außen nach innen arbeiten. Erste Tipp. Zweite Tipp. Das Quadrieren.

Es gibt Programmiersprachen, in denen Sie schreiben können. So was schreiben können wie und dann steht da ich den Circle Flex finde, a Quadrat. So was für das Quadrat. Es gibt Programmiersprachen, in denen Sie das schreiben können. Metlab zum Beispiel. Es gibt Programmiersprachen, in denen man die Potenz so schreiben kann. Das ist zum Beispiel Python.

Und dann gibt es C. Und den C schreiben Sie das Quadrat. Sorry. Also ich würde außen anfangen mit der

Schleife. Sozusagen von von der hohen Ebene zur tiefen Ebene gehen, von der Vorstellung zum konkreten Programm gehen und von außen nach innen. Vom großen zum kleinen. Das ist viel leichter als andersrum. Wenn Sie mit dem Kinkerlitzchen anfangen, verlieren Sie einfach aus dem Auge, was Sie eigentlich mal machen wollen.

Das sehen wir im Laufe des Semesters noch ein bisschen ausführlicher. Warum das geschickter ist, Top-down zu programmieren. Von der Vorstellung zum Detail. Dann wie man es dann hier jetzt mit den ganzen Emikolons und Schleifklammern baut. Die entscheidende Geschichte wird sein, ich prüfe ob das Quadrat, ups, ob das Quadrat immer noch kleiner gleich

20.000 ist. Das wird die entscheidende Bedingung sein. Ist das Quadrat irgendeiner Zahl, die ich durchprobiere, immer noch kleiner gleich 20.000. Und wenn ja, nehme ich die nächste Zahl.

Das heißt ich brauche aber erst mal dieses i überhaupt. C ist da strikt. Ich kann jetzt nicht von einer Variable namens i reden, ohne dass ich sie eingeführt habe. Andere Sprachen sind da großzügiger. Ich muss erst mal einführen. Ich fange halt sinnvollerweise mal an mit 100 anfangen, weil ich sehe 100 ins Quadrat wird zu wenig sein.

Ich nehme mal 1. Das ist nicht gerade effizient, aber ganz sicher auf der sicheren Seite. Ich probiere 1. Ist 1 Quadrat kleiner gleich 20.000? Ja hoffentlich. Und dann soll ich 2 probieren und dann 3 und so weiter und so weiter bis ich zum Schluss eine Zahl habe, deren Quadrat

nicht mehr kleiner gleich 20.000 ist. Die lange Schreibweise wäre diese hier. Einfach 1 weiter zählen. Ich fange mit der Zahl 1 an, prüfe ob deren Quadrat kleiner gleich 20.000 ist. Wenn ja, nehme ich die nächste.

Und so weiter und so weiter. Ich überlege gerade, ich habe jetzt bei vielen von Ihnen das kleiner gleich gesehen. Doch ergibt gleich im Zusammenhang Sinn. I gleich I plus 1. Nehme den Wert, der in der Variablen I steht, addiere 1 drauf, also dann von der 1 auf die 2 und schreibe das wieder in I rein, von rechts nach links.

Das kostet Gewöhnung zu entgegnermaßen. Rechts ist der Wert, den ich ausrechne. Links ist die Variablen, die ich reinspeichere. Links kann nicht stehen I mal I oder sowas. Es gibt dann später Möglichkeiten, auf der linken Seite auch was zu rechnen, aber das ist auf eine ganz komplizierte Art.

Wenn Sie links rechnen, ist höchstwahrscheinlich was schiefgegangen. Links steht typischerweise der Name einer Variablen und nichts anderes. Das Ding hier schreibt man im Allgemeinen nicht so, sondern kürzer. In C zumindest, in anderen Sprachen nicht. Ich kann schreiben I plus gleich 1.

Das heißt, schau an, was in I steht, plus gleich, addiere 1 drauf, auf das, was in I steht. Es geht auch I plus plus. Dies Jahr könnten Sie auch mit plus gleich 10 machen, wenn Sie in Zehner-Schritten arbeiten wollen.

Wir fangen mit 1 an, da kommt plus gleich 10, da sind wir bei 11 und beim nächsten Mal wieder plus gleich 10, da sind wir bei 21. Das wiederheißen in Zehner-Schritten. Dieses plus gleich 1 lässt sich noch kürzer schreiben. I plus plus, daher kommt dann nachher auch der Name C plus plus. Von C 1 weitergehen, deshalb C plus plus. I plus plus, gucke an, was in I steht

und erhöhe das, was in I steht, um 1. Es gibt auch noch plus plus I, aber das will ich jetzt nicht erzählen, was da der Unterschied ist. Insbesondere in den Nachfolgesprachen einfach immer I plus plus schreiben. I um 1 erhöhen, das wird das übliche sein.

So, haben wir gerade geguckt. Der Ärger ist, jetzt haben wir um 1 zu weit gezählt. 141 wird ja gerade noch gehen. 141 mal 141 wird hier gerade noch gehen. Ich erhöhe von der 141, kriege die 142. 142 wird zu groß sein und ich ende dann die Schleife. Und in I steht 142, obwohl ich eigentlich 141 haben wollte.

Und dann wäre ich das Dümste zu sagen. Ja, dann ziehen wir eben wieder 1 ab. Nehme das, was in I steht und verringere den Wert von I. Genau, damit beschäftigen wir uns nämlich gleich noch. Ich finde die Zahl da drunter.

Erstmal hier. Aber das kann sein, dass das nicht die beste Zahl ist. Wenn hier die Wurzel 2 ist, könnte ja sein, dass die 141 hier liegt

und die, ach, ich erzähl was, dass die 1,41 hier liegt und dass die 1,42 da liegt. Dann wäre ich bei der 1,41 mit der 1,41 besser bedient als mit der 1,42. Aber ohne, dass ich jetzt den Taschenrechner rausrücke,

könnte ja auch sein, dass die so liegen, dass die 1,41 weiter weg liegt als die 1,42. Und dann würde ich ja doch gerne die 1,42, die 142 rauskriegen. Bisher nehmen wir die letzte Zahl, die es macht, also immer die 1,41. Das Schöne wäre dann gleich, noch mal das so zu bauen, dass er immer die Zahlen nimmt, die am dichtesten dran liegt von den beiden.

Das kommt gleich noch. Das ist ein bisschen schwieriger. Hier können wir erst mal noch ein bisschen weiter gucken. Sie sehen, ich habe hier ganz viele Leerzeichen reingesetzt. Leerzeichen sind an den meisten Stellen für C egal.

Sie können natürlich nicht mitten in so ein Schlüsselwort ein Leerzeichen reinsetzen. Ich hoffe, das ist klar. Sie können dieses Leerzeichen nicht weglassen. Aber viele Leerzeichen sind egal, da das Leerzeichen um die, das Leerzeichen vor dem Gleich, das Leerzeichen nach dem Gleich, das ist ihm egal. Hier können wir noch Leerzeichen reinschreiben, damit es hübscher aussieht. Sie können vor dem Plus-Plus ein Leerzeichen machen.

Sie können die Zeileneinteilung so gestalten, wie Sie wollen. Wenn Sie es absolut unleserlich machen wollen, können Sie es auch so hinschreiben. Das stört C nicht. Andere Sprachen stört das, zum Beispiel Pyson macht da einen Ärger.

Bei C ist der Zeilenfall egal. Man wird es typischerweise so hinschreiben mit hübschen Eindrückungen. Das kriegen Sie auch automatisch hier bei, wenn Sie die Eindrückungen hier verbaut haben, können Sie sagen, edit, ich hoffe, ich finde das jetzt gerade hier, order indent.

Muss man es erst auswählen. Gucken wir mal, edit. Ok, erst auswählen und dann edit order indent, dann macht das ihn wieder hübsch. Also man versucht es schon in dieser Form hier zu kriegen, dass innerhalb der Schweifklammern eingerückt wird. Sie sehen da innerhalb der Schweifklammern wird auch eingerückt. Dann hört man so

Hierarchiestufen und kann erkennen, was jetzt außen steht und was jetzt innen steht. Ich hatte die Optimierung schon ausgeschaltet, denke ich. Genau, die Optimierung war schon aus. Compiler, optimizations, none. Das heißt, ich sollte wirklich in der Lage sein, hier jetzt den Einzelschritten durchzugehen

und zu gucken, was passiert. Das ist ja der spannendste Teil, ob es denn auch funktioniert. Locals möchte ich haben.

Ich fange an mit i gleich 1. Offensichtlich hat er hier schon probiert, ob das Quadrat von 1 kleiner gleich 20.000 ist. Unglaublich, es ist kleiner gleich 20.000. Jetzt sollten wir i erhöhen. Also da, wo der grüne Fall steht, das ist bei allen Systemen so, da wo der grüne Fall steht, die Zeile markiert ist, das ist die Zeile, die als Nächste kommt. Die ist doch nicht ausgeführt. Die kommt jetzt als Nächste.

So. 2. Sie sehen hier mit der Schweifklammer, das ist für dieses System keine echte Programmzeile. Andere Systeme bleiben dabei der Schweifklammer erstmal noch mal stehen. Für den ist die Schweifklammer hier nichts. Er sagt sofort hier, nächster Schleifendurchgang. Das ist das nächste, was passiert. Ist 2 Quadrate kleiner gleich 20.000

und so weiter und so weiter. Im wahren Leben läuft das natürlich 100.000 Mal, Millionen Mal, aus den richtigen Maschinen dann auch Milliarden Mal schneller, als ich das hier vorführe. Wir können ihn einfach weiter laufen lassen. Nur wenn wir ihn einfach weiter laufen lassen, erfahren wir von nichts. Ich habe ihn noch nicht

verraten, wie sie irgendwas ausgeben können oder so. Deshalb setze ich hier auf die letzte Zeile einen Breakpunkt. Also Cursor in die Zeile und hier dann den roten Knopf da. Anderswo kann man auch hier direkt in die Zeile, neben die Programmzeile klicken. Hier ist das so, dass man da auf den roten Knopf klicken muss und zu sagen muss, ein Abbruchpunkt, ein Breakpunkt.

Und jetzt kann ich einfach sagen, lass mal laufen, solange bis irgendwas passiert. Insbesondere bis du einen Abbruchpunkt findest. So sieht das aus. Rund 141. Also jetzt bin ich nicht in Einzelschritten weitergegangen, sondern habe der Maschine gesagt, lauf mal los.

Es geht dann eben in Sekundenbruchteilen weiter. Er landet hier und wir haben 141 da. Tatsächlich in dieser Variable ein I drin stehen, wie erhofft. Dieses Return Null ist noch eine ganz andere Geschichte. Er hat das Return Null ja noch gar nicht ausgeführt. Wir gucken uns das Ergebnis, bis er ja einfach dreist im Speicher an. Ich gucke dem Prozessor auf die Finger,

was er jetzt in diese Variable I reingeschrieben hat. Das ist ja noch nicht wirklich eine Ausgabe. So ein Dialogbox, oder er verschickt eine Mail oder druckt es aus oder was. Das ist ja nicht im ernsten Sinne eine Ausgabe. Ich habe nur geguckt, was in dieser Variable I drin steht. Dieses Return Null ist noch eine ganz andere Geschichte, die noch nicht ausgeführt worden ist.

Mit Return Null sagt mein Programm nur, dass es fehlerfrei abgelaufen ist. Später. Ich habe einmal die exakte Wurzel 2 und dann liegt irgendwo 141 hundertstel und irgendwo liegt 142 hundertstel.

Ich weiß nicht genau, wer von den Dichter an Wurzel 2 liegt. Eine Möglichkeit wäre, ich quadriere den. Ich quadriere den und gucke dann, welches Quadrat Dichter an 2 ist. Das ist mathematisch nicht so 100%ig klar, dass man dann auch hier bei der Wurzel den dichtesten Abstand hat, aber das ist schon halbwegs plausibel.

Das wäre der Gedanke. Das Ergebnis quadrieren und dann gucken, welche der beiden Möglichkeiten dichter an der Wurzel 2 liegt. Oder dann in unserem Programm, welche der beiden Möglichkeiten dichter an der 20.000 ist. Nachdem man hier durch ist mit der Schleife, bauen Sie das mal.

Irgendwas muss ich vergleichen und mein Gedanke wäre jetzt, bauen Sie Zwischenvariablen, in denen diese Abstände steht. Wir können nicht mit Wurzel 2 vergleichen, aber wir können mit 20.000 vergleichen. Also, wenn Sie diese Quadrate bilden, vergleichen wir 20.000 und das eine ist, was in i steht, quadriert und das andere ist i plus 1 quadriert. Bestimmen Sie diese beiden Abstände

und stellen Sie dann fest, welcher der kleinere ist. Und beim kleineren Abstand liegt die bessere Zahl. Okay, also ich baue eine Variable, in der ich diesen Abstand speichere, eine Variable, in der ich den Abstand speichere.

Am besten nach der Schleife. Also, man kann Variablen zwischendurch anlegen. Das ging in C nicht immer. In allen Nachfolgesprachen geht es seit jeher, wenn ich mich recht erinnere, in C ging es am Anfang nicht.

Inzwischen geht das. Sie können jetzt nach dieser Schleife sagen, okay, bauen wir mal wieder eine neue Variable. A soll dieser, wenn ich jetzt A, soll dieser Unterabstand sein, 20.000 minus i Quadrat.

Unterabstand, 20.000 minus i Quadrat. Und B soll der Oberabstand sein. Ich habe ja eben eins zu weit gezählt, deshalb würde ich ganz dreist sagen, das machen wir doch einfach vorher dann. In B ist gleich i mal i.

Da fällt mir gerade was auf, was man effizienter machen könnte. Egal. Minus 20.000, das wäre der Oberabstand. Vorher habe ich eins zu weit gezählt. Ich nehme die Zahl, mit der ich zu weit gezählt habe, berechne da den Abstand. Eins runter zählen, berechne da den Abstand.

Ich werde das jetzt nicht optimieren, aber Frage, sehen Sie, warum das jetzt nicht gerade so effizient ist, was ich da veranstalte. Wie hätte ich das besser machen können? Gibt es irgendwas, was ich recyceln kann? Genau, das ist blödsinnig, dass ich das i Quadrat noch mal ausrechne. Ich habe es ja vorher schon ausgerechnet.

Na ja, mit einem Könnchen Salz eigentlich ja nicht. Ich habe es vom Wert vorher ausgerechnet. Wenn man das ja richtig veranstaltet, würde man sich dieses i Quadrat tatsächlich merken können und das i Quadrat hier aus der Schleife für den hier benutzen können und dann nur noch den nächsten ausrechnen, zum Beispiel. Egal, so wird es überschaubarer. Wir haben die Schleife, wie wir sie kennen. Wir zählen eins zu weit.

Abstand, das Quadrat von dem eins zu weit gezählten, minus 20.000, eins runter gehen und Abstand umgekehrt, 20.000 minus eins weniger. Sollte mal ich mal tatsächlich Leerzeichen machen.

So, das wären die beiden Abstände. Das wären diese beiden Abstände. Und jetzt gucke ich, was der größere Abstand war oder besser, gucke ich, was der kleinere Abstand war und dann weiß ich, das ist geschickter. Bei dem kleineren Abstand steht die bessere Zahl.

Ich weiß, dass beide Differenzen, die ich berechne, positiv sind, weil die eine Zahl garantiert kleiner ist oder gleich ist und die andere Zahl garantiert größer ist. Insofern kein Ärger mit Vorzeichen. Ich rechne eigentlich nicht wirklich Abstände aus. Hier stehen keine Beträge, es sind nicht wirklich Abstände, es sind Differenzen. Jetzt gucke ich einfach, welcher besser ist.

Wenn A besser ist als B, tue Folgendes, ein Schweifklammern. An der Stelle nochmal zu den Schreibweisen. Das ist ja schwierig. Nach diesen

Statements, Befehlen sozusagen, stehen Semikolons in C. Nach dem While und der runden Klammer hier steht kein Semikolon. Und nach dem If und der runden Klammer da steht kein Semikolon. Und nach dem, nach der Schweifklammer von dem If steht kein Semikolon. Also so ein richtiger Befehl hat ein Semikolon am Ende.

Nicht nur ein richtiger Befehl, sondern auch eine Deklaration. Wenn Sie nur das schreiben, eine Variable, nicht initialisieren, steht auch ein Semikolon dahinter. Diese Konstruktion hier mit runde Klammer, runde Klammer, Schweifklammer, Schweifklammer, da steht kein Semikolon. Runde Klammer, runde Klammer, Schweifklammer, Schweifklammer, kein Semikolon, runde Klammer, runde Klammer,

Schweifklammer, Schweifklammer, kein Semikolon. Hätte man auch alles anders erfinden können, so ist es eben geworden, historisch. Zurück zum Thema hier. Wenn die

diese untere Differenz kleiner ist als die obere Differenz, dann möchte ich gerne in der Variablen i die untere Zahl stehen haben. Na toll, steht sie sowieso. i minus minus, es steht ja sowieso die untere Zahl drin. Was muss ich eigentlich deshalb prüfen hier bei dem If?

Korrekt, ich probiere, ob b kleiner a ist, ist der Abstand oben besser als der Abstand unten. Der Abstand oben kleiner als der Abstand unten. Wenn das der Fall ist, dann nehme ich eben nicht den unteren, sondern ich nehme den oberen und sage i plus plus.

So würde ich das bauen. Jetzt mal hier mal wieder einen Breitpunkt. Ich glaube, es kommt weiter zu 141, wir können ja ganz schwer spicken. 0 zu 2.

Okay, 1414, also es sollte weiterhin 141 sein. Trotz dieser Maßnahme. Er ist jetzt am Start des Programms. Mehr zu dieser Zeit ist später. Ich sage, laufe mal weiter bis zu dem Breitpunkt, den ich eben eingebaut habe.

141. Okay, wir können uns noch die Abstände angucken. Der Abstand unten, die Differenz unten, korrekt am Maß, die Differenz unten 119, die Differenz oben 164. Der untere Wert war dichter dran. 20.000, hier mit der Wurzel aus 2, ist natürlich langweilig. Ich möchte das gerne allgemeiner haben.

Mal int. Ach, wie nenne ich das? Z. Sprechende Variablenamen wären auch nicht schlecht. Ich lasse es jetzt mal bei diesen einbuchstabigen. Int z ist gleich 2. Okay, so möchte ich das gerne haben. Ich möchte die Wurzel aus einer ganzen Zahl ziehen.

Als so und so viel Hundertstel. Was schreiben sie dann statt der 20.000? Das hier war ja 2 mal 10.000. Da kam eine komische Rechnung. Ich wollte die Wurzel als Hundertstel haben.

Ich wollte die Wurzel als Hundertstel geschrieben haben und die Hundertstel ins Quadrat habe ich rüber gebracht. 2 mal 10.000. Jetzt dann also die Zahl, aus der ich die Wurzel haben will, mal 10.000.

Ja, sehr schön. Z mal 10.000. Man sollte auch das schreiben, was man sagt. Und hier natürlich auch Z mal 10.000. Und hier steht auch Z mal 10.000. Das ganze ist jetzt obendrein besser verständlich, weil ich weiß, was die Rolle von der 20.000 war.

20.000 ist die Zahl, deren Wurzel ich suche, mal 10.000. Also es ist oft geschickt, Sachen wirklich so dann auszubuchstabieren, damit man weiß, wo sie herkommen. Statt da so magische Zahlen reinzuschreiben, von denen dann nachher keiner mehr weiß, wo sie hergekommen sind.

Jetzt ist das hübsche, dass ich einstellen kann, von welcher Zahl ich die Wurzel ziehen will. Ich bin mal gespannt, ob sie drauf kommen, was jetzt gleich schiefgeht. Wurzel 10, probieren wir das. Der Backpunkt unten ist noch drin, ja, mal durch, so, a ja, die Wurzel 10.

I ist gleich 0, B ist gleich 31.000, noch was. Irgendjemand schon einen Schimmer, was da passiert? Wurzel 10 ist offensichtlicher Blödsinn, ich zeige nochmal Wurzel 3.

173, mal gucken. 173, soweit so gut. Was ist der Ärger mit Wurzel 10?

Genau, das übersteigt die Fähigkeiten des Integers auf dieser Maschine. Das sind dann so die Freuden des Programmiererlebens, man denkt, man hat ein Programm geschrieben, das doch eigentlich funktioniert. Mit 2 geht es, mit 3 geht es, mit 10 geht es nicht mehr. Blöd. Sie können nicht beliebig große Zahlen in diese Ints rein speichern.

Das gibt es dann nächste Woche noch ein bisschen ausführlicher. Die Ints sind auf dieser Maschine 16 Bitzahlen und dann ist bei 32.000 noch was feierabend. Also 3 geht gerade noch, 3 mal 10.000 geht gerade noch, aber 10 mal 10.000, 100.000 geht nicht.

Es gibt einen anderen Typ an Variate, der das kann, Long. Wenn ich das tue, haut das hin, dann sollte ich das i auch als Long machen, dann müssten wir hier überall auf der sicheren Seite sein. Machen wir alle als Long.

Das ist eine andere Sorte Variable, wo er auf dieser Maschine 32 Bit hat. 32 Bit heißt, das geht bis 2 Milliarden noch was. Dann haben wir eine Chance, bis 2 Milliarden noch was. C ist ein unsägliches Ding. Je nach Rechner, auf dem man arbeitet, hat Long mehr oder weniger Bits, Int mehr oder weniger Bits.

Es gibt nur Mindestanforderungen. Auf dieser Maschine sind es eben 16 Bit für Int und 32 Bit für Long. Ich sollte sagen, auf diesem Microcontroller sind es so viel. Er läuft hier ja gerade auf einem ganz normalen Pentium.

Der Pentium hat normalerweise größere Maßstäbe. Hier in diesem System. Int mit 16 Bit bis 32.000 noch was. Von minus 32.000 noch was bis plus 32.000 noch was. Und Long auf diesem System für den Microcontroller. Von minus 2 Milliarden irgendwas bis plus 2 Milliarden irgendwas.

So, und jetzt müsste das auch funktionieren. Ich drücke mal die Daumen. 3, 1, 6. Sieht schon mal mindestens etwas besser aus als eben.

Invers und die Wurzel. 3, 1, 6. So funktioniert es auch. Was ich jetzt gerne noch in Aktion gesehen hätte, ist, dass er mir mal den oberen nimmt. Wir sehen, das waren ja bisher immer Ergebnisse, wo er den unteren nehmen soll. Das weiß ich auswendig keinen. Ich probiere mal Wurzel 11. Wo er mal den oberen nehmen muss.

In Quadrat 3, 1, 6. So, da müsste er den oberen nehmen. 3, 3, 1, 6 bei der Wurzel 11. Da will ich also 3, 3, 2 haben. Weil der korrekte Wert 3, 3, 1, 6, 6 ist. Müsste er rund zu 3, 3, 2.

3, 3, 2 müssten es korrekt gerundet werden. Probieren wir das. Wurzel 11. Da haben wir eine Idee, ob dieses Programmchen auch das tut, was es tun soll. Das ist natürlich jetzt kein perfekter Test. Man vergewissert sich mehr und mehr, dass das Programm tut, was es tun soll. Wurzel 11.

3, 3, 2. Soweit sieht das gut aus. Bisher läuft es also dann fehlerfrei. Nachdem wir das Int durch Slonk ersetzt haben, lief es dann so weit fehlerfrei. Von dieser Sorte an Variabentypen gibt es nachher noch diverse. Das sehen wir dann im Verlauf.

Es kam ja schon ein Bool vor in den Videos. Sie können sich speichern, ob etwas wahr ist oder falsch ist. Und nichts anderes. Das nennt sich dann Bool. So eine Ja-Nein-Information speichern. Und zum Rechnen erst mal Int und Long. Da kommen aber noch ein paar weitere. Eine Sache, die ich eben noch gesehen hatte.

Die soll ich noch mal sagen. Dieses If braucht ja netterweise kein Else. Else heißt, wenn ich hier oben nicht reingehe in das If, dann gehe ich in das Else rein. Andernfalls. Wenn B kleiner ist als A, mache dieses, was in den Oberundreifklammern steht.

Wenn B nicht kleiner ist als A, sondern gleich ist oder größer ist. Also das Gegenteil hiervon. Dann mache das, was im Else steht. Und was ich eben gesehen habe, da müssen Sie natürlich keine Bedingung dahinter schreiben. Das Else ist automatisch das Gegenteil.

Nicht, dass Sie da jetzt noch mal mit runden Klammern arbeiten. Das sieht sowas von plausibel aus. Auf den ersten Blick, dass ich es auch nicht gesehen habe. Das Else ist einfach das Gegenteil von If. Deshalb kriegt es keine runden Klammern mehr. Und auch kein Semikolon. Nach den Schweifklammern steht kein Semikolon. Es gibt in C und C++ einige Fälle, bei denen nach den Schweifklammern ein Semikolon steht, sehen wir noch.

Erstmal steht nach den Schweifklammern in diesen Fällen kein Semikolon.