fangen wir mit etwas einfachen zu Erays an. Wenn ich einen Eray gegeben habe von ganzen Zahlen namens A, das könnte zum Beispiel dann so aussehen, fürchterlich viele Klammern muss man sich erst mal daran gewöhnen,

das würde heißen, lege mir einen Eray an von ganzen Zahlen, es soll A heißen, die eckigen Klammern sagen, das wird ein Eray werden, vom Typ her. Und hier gebe ich tatsächlich an, welches Eray es werden soll, also mit fünf ganzen Zahlen, den die dahinterstehen, in Schreibklammern.

Und natürlich am Ende wieder wie üblichen Semikodern. Man könnte hier auch noch reinschreiben, es sind fünf Zahlen, aber das sieht der Compiler von selbst, dass es fünf Zahlen sind. Netterweise muss man das nicht reinschreiben. Auch eine Fehlermöglichkeit weniger, wenn wir da vier reinschreiben und geben fünf an, ist schon wieder ein bisschen komisch.

So, was ich möchte ist, dass wir einmal als Fingerübung das aufsummieren. Wir geben so ein Eray, was ist die Summe von den ganzen Zahlen, die da in dem Eray stehen?

Ich lese das mal an. Man könnte die Summe auf die ganz harte Art bestimmen, nämlich so, dass man sagt, wir nehmen den Nulten und dann addieren wir den Ersten und addieren wir den Zweiten und den

Dritten und den Vierten, so was. Zwei, drei, vier. Das wäre auch eine Art, die Summe zu berechnen, das wäre offensichtlich nicht allzu geschickt. Wenn hier oben einer mehr drin steht, müsste ich hier ausführlich anfangen, um zu programmieren, das wäre schon nervig.

Und wenn ich eine Million Sachen addieren will, eine Million Sachen hier hintereinander schreiben, das wäre schon mal praktisch ein Ding der Unmöglichkeit. Man wird es nicht so schreiben, sondern wird es mit einer Vorschleife schreiben.

Soweit waren wir uns eilig. Das noch mal als Tipp. Ich würde erst mal dieses Muster hinschreiben, wie die Vorschleife im Prinzip aussieht. Das geht dann nächstes Semester mit Visual Studio auch ein bisschen netter. Man tippt einfach vor, drückt zweimal Tabulator und es steht dieses Grundgerüst da. Das hat auch einen guten Grund. Man weiß dann, was man ausfüllen muss. Man hat eine Schablone zum Ausfüllen.

Ich will eine Vorschleife, in die runden Klammern kommt, wie das Ding voranschreitet, was es mit den Indizes macht und in die Schweifklammern kommt, was es denn tatsächlich als Schleife an Arbeit verrichten soll. Ja, hier haben sich die meisten noch erinnert. Das fängt an mit Initialisierung und dann kommt ein Vergleich vor und dann kommt das Voranschreiten.

Wie schon gesagt, in 99 Prozent der Fälle steht da vor int i gleich null. Muss man sich überlegen, was der Vergleich ist.

Und hinten steht in 99 Prozent der Fälle i plus plus. Ich möchte hier diese Einträge durchlaufen. Der erste ist die Nummer 0, der zweite ist die Nummer 1, Nummer 2, Nummer 3, Nummer 4. Dann werde ich hier sinnvollerweise i kleiner 5 reinschreiben.

Jetzt haben sie eine Vorschleife, bei der diese Variable i mit 0 startet. Sie wird 1, sie wird 2, sie wird 3, sie wird 4. Und wenn er versucht, die auf 5 zu setzen, stellt er fest, 5 ist nicht kleiner als 5 und hört auf. Also dieses i ist innerhalb von den Schweifklammern 0, 1, 2, 3, 4. Was wir brauchen 0, 1, 2, 3, 4.

Andere Programmiersprachen fangen bei den Erays nicht mit 0 an, aber die ganze C-Familie fängt mit 0 an, insbesondere MATLAB. Eine wichtige Ausnahme fängt nicht mit 0 an, sondern mit 1 an. Aber die C-Programmiersprachen fangen alle mit 0 an, insofern hier mit 0 angefangen.

Und jetzt kommt der Körper von dieser Vorschleife. Ich möchte aufsummieren. Ich brauche also eine Variable, in der ich die Summe abspeichern kann. Und das muss man sich überlegen, wo kann ich diese Variable einführen?

Das haben wir uns jetzt also überlegt. Das kann so nicht funktionieren. Sie können diese Variable nicht innerhalb der Vorschleife einführen. Was sie innerhalb der Schweifklammern oder überhaupt in C, egal wo, innerhalb von solchen Schweifklammern einführen, ist außerhalb der Schweifklammern verborgen.

Sie könnten nach der Vorschleife nicht mehr die Summe abfragen. Das wäre ja ein bisschen blödsinnig. Und obendrein würden Sie hier, wenn hier eine Initialisierung ist, jedes Mal diese Initialisierung ausführen, bei jedem Durchlauf der Vorschleife. Es gibt diverse Gründe, weshalb diese Variable nicht innerhalb der Vorschleife eingeführt werden kann. Sie kann nicht danach eingeführt werden,

weil ich sie dann ja nicht in der Vorschleife verwenden kann. C will die Variablen erst eingeführt haben und dann will er sie verwendet haben. Das kann nicht gehen. Das habe ich jetzt gerade an einer Stelle gesehen. Vorsicht, Sie können hier nichts zwischen die runde Klammer

und die Schweifklammer schreiben. Da geht nichts dazwischen. Hier dazwischen geht nichts. Nach der runden Klammer zu hier muss die Schweifklammer kommen. Da kann nichts anderes dazwischen. Das heißt, die einzige Chance ist, vor das vorzuschreiben.

So müsste das aussehen. Ich führe eine Variable ein, in der nachher die Summe stehen soll. Und dann kommt die Vorschleife. Und diese Variable lebt natürlich länger als die Vorschleife. Sie ist außerhalb eingeführt. Irgendwas wird in der Vorschleife passieren. Schön. Und danach soll dann die Summe drin stehen.

Eine Sache, die ich zwischendurch gesehen habe, A von I Das kann nicht auf der linken Seite stehen. Wenn das auf der linken Seite steht, heißt das ja, Sie schreiben etwas rein. C funktioniert ja, wie die ganzen Nachfolgesprachen, von rechts nach links. Wenn da sowas steht, bla bla bla bla bla.

Rechnen Sie irgendwas aus und schreiben das in A rein. Das will ich ja gerade nicht. Ich möchte das, was in A steht, rausholen. Damit weiß ich schon, das muss auf der rechten Seite stehen. So muss das irgendwie vorkommen. A von I auf der rechten Seite. Und was soll passieren? Es soll zur Summe addiert werden.

Die Langfassung wäre Summe ist gleich Summe plus A von I. Das wäre die Langfassung. In jedem Schleifendurchlauf den alten Wert von Summe nehmen. Wir starten mit Null.

Den so und so vielten Eintrag des Arrays drauf addieren und das als neuen Wert für Summe nehmen. Oder Kurzfassung, was ich jetzt bei den meisten gesehen hatte, plus gleich in C. Und seine Nachfolgesprachen. Summe plus gleich A von I. Das wäre das übliche. Gucken wir vielleicht nochmal an, was hier im Einzelnen passiert.

So, einmal hier in Einzelschritten durch. Das Array angelegt hier. Was drin steht. An der Stelle Null steht die 3 drin. An der Stelle 1 steht die 42 drin. Wenn man ein bisschen weiter aufmacht, sieht man

auch, wo die im Speicher stehen. Sowas gucken wir uns später an, wenn es um Zeiger geht. Jetzt kennt er die variable Summe. An der Null steht zu Beginn. Wir fangen die Schleife an. Er hat I auf Null gesetzt. Er prüft, ob I kleiner 5 ist. Vor dem ersten

Schleifendurchlauf prüft er schon, ob I kleiner 5 ist. Ja, ist der Fall. Und jetzt holt er A von Null raus, addiert es auf Summe drauf. Und damit wird die Summe 3. Den ersten hier, den Nulten, den mit der Nummer Null, so, rausgeholt und auf die Summe addiert. I um 1 erhöhen.

Prüfen, ob es kleiner ist als 5, immer noch. Und jetzt ist I gleich 1. Er wird die 42 holen und auf die Summe addieren. 45. Nach dem Schleifendurchlauf um 1 erhöhen. Prüfen, ob es immer noch kleiner ist als 5.

Den Nächsten holen. I ist 2. Also jetzt die 13 holen, drauf addieren. 58 und so weiter im Schnelldurchlauf. So, jetzt ist I im letzten Schritt auf 5 erhöht worden. Dieser Vergleich wird fehlschlagen.

Und damit ist die Schleife beendet und die Summe ist 70. So sieht das in kleinen Schritten aus. Zu der Frage hier die 5, die ist ja noch ein bisschen blöd, weil die ist ja fest einprogrammiert. Was ist, wenn ich hier jetzt ein Array anderer Größe habe, da muss ich hier ja dann auch die Zahl ändern.

Da ist C total ungeschickt, was das angeht. Die neueren Sprachen, einschließlich C++, sind da besser. Da haben Sie Arrays, bei C++ auch, wenn Sie die richtige Sorte Array nehmen, da haben Sie Arrays, die Sie nach der Größe fragen können.

Dann können Sie sagen, hier gib mir mal die Größe von Array A. Da schreiben Sie nicht die Zahl 6 rein, sondern gib mir mal die Größe von Array A. In C ist das etwas antik. Sie müssen sich irgendwie gemerkt haben, was die Größe war. Entweder haben Sie das Array direkt angelegt, dann wissen Sie, wie viel es waren. Sie haben das Array von jemand anderem gekriegt.

Dann muss der Ihnen sagen, wie groß es war. Es gibt auch noch einen Heck, bei dem man C fragen kann, wie groß ist dieses Array insgesamt und teilt es durch die Größe eines einzelnen Elements. Aber das ist nicht gerade so prickelnd, will ich jetzt an dieser Stelle auch nicht vorführen. Lange Rede, kurzer Sinn. Man muss tatsächlich dafür sorgen, dass man weiß, wie viele Elemente man hat.

Das sollte am besten dann eine Variable sein, in der man sich das, oder eine Konstante sein, in der man sich das gemerkt hat. Genau das Problem, auf das werden wir jetzt auch stoßen, ich möchte nämlich, dass Sie jetzt eine Funktion schreiben, die sowas kann.

Eine Funktion, der ich ein Array übergebe und die Funktion liefert die Summe der Einträge des Arrays zurück. Überlegen Sie sich, wie das funktionieren kann. Also das hier jetzt auslagern in eine Funktion und stellen Sie sich vor, Sie haben ganz viele Messwerte an verschiedenen Stellen. Sie müssen ständig zum Beispiel Mittelwerte bilden, Summe bilden durch die Anzahl.

Dann wäre es ja vielleicht hilfreich eine Funktion zu haben, der Sie ein Array geben und die Funktion liefert die Summe der Zahlen des Arrays zurück. Wie müsste so eine Funktion aussehen? Oder stoßen Sie genau auf diesen Ärger hier, dass man wissen muss, wie viele denn in dem Array drinnen stecken.

So, eine Funktion zum Summieren. Vielleicht sollte ich das wieder so machen, dass ich die erst mal aufrufe. In Summe ist gleich Summiere, was will ich haben?

Ich möchte, der das Array übergeben, da müssen Sie jetzt nicht eckige Klammern schreiben, sondern nur a, a ist der Name des Arrays. Die eckigen Klammern hier sagen, was über den Typ ist a, die Variabelnamen ist a, steht für ein Array, eckige Klammern, von ganzen Zahlen.

In moderneren Sprachen landen die eckigen Klammern dann auch gerne hinter dem Int, das ist sinnvoller. Der Typ von a ist ein Array von ganzen Zahlen, aber in C sieht es eben so aus, dann ist es so zerrissen. a ist der Name und der Typ ist ein Array von ganzen Zahlen.

Das ist leider auseinander genommen, was für ein Typ das ist. Also hier übergebe ich definitiv a, der Name des Arrays ist das a, aber es reicht eben leider nicht, in C zumindest nicht, nur dieses Array zu übergeben, Sie müssen auch noch sagen, wie viele Einträge drinnen stehen, das ist ein bisschen antik.

Also diese Funktion hier kriegt zwei Sachen übergeben. Ich schreibe sie mal davor, das haben einige schon gemerkt, wenn Sie die Funktion dahinter schreiben, dachte der Compiler erkennt sie an dieser Stelle nicht, das gucken wir uns gleich noch mal im Detail an. Ich schreibe sie erst mal davor, summiere und er kriegt ein Array, nennen wir es hier mal x,

und er kriegt, wie viele Einträge drinnen sind, Anzahl, Number, Count, N, das zeige ich jetzt einfach mal. Und in Schleifklammern schreibe ich, wie viele drin sind, das haben wir mal links, etwas hübscher, so weiß man was gemeint ist.

So sähe die Funktion von außen aus, sie kriegt ein Array ganzer Zahlen, das jetzt innerhalb dieser Funktion x heißt, und sie kriegt die Länge mitgeteilt, wie viele ganze Zahlen drinnen sind.

Und in der Funktion findet das statt, was wir hier eben hatten, das kann ich da einfach rausschneiden, Copy und Paste. Hier muss natürlich jetzt da Länge stehen, und ich gebe die Summe zurück.

Das wäre meine Funktion, also das was wir eben hatten, einfach rausgeschnitten und verselbständigt. Die Funktion kriegt ein Array, das jetzt in der Funktion x heißt, was in der Funktion x heißt, nicht mehr a, das muss jetzt x heißen,

sie kriegt die Anzahl der Elemente, wir fangen an mit Summe 0, laufen so weit durch, wie die Anzahl der Elemente sagt, lesen x aus und geben die Summe zurück. Das sollte das soweit sein.

Ich habe das Array a jetzt hier. Nun gehe ich in meinen Funktionsaufruf rein, hier mit dem Step Into, und bin hier oben im Funktionsaufruf drinnen.

x ist jetzt das, was in der anderen Funktion Main a war. Wir sehen hier schon, da kommt er extrem durcheinander, er zeigt hier nur noch den ersten Eintrag an.

Selbst das Entwicklungssystem weiß anscheinend nicht mehr, wie groß das Array ist. Egal, wir trotzdem funktionieren. x steht jetzt für das, was vorher a war. Er übergibt dieses a, und in meiner Funktion hier heißt es jetzt dann eben x, weil ich da geschrieben habe, es kommt x an.

Und jetzt gehe ich hier durch die Schleife durch, wie üblich. Was da passiert, eine große Überraschung. So, letzter Return Summe, Summe ist 170, ich habe jetzt am Schluss noch 100 drauf gradiert eben. 170 ist die Summe, jetzt geht er mit der Summe wieder zurück dahin, und da ist die Summe 170.

Was hat eigentlich diese Variable namens Summe hier oben bei Sumire mit dieser Variable namens Summe zu tun? Hier oben in meiner Funktion Sumire habe ich eine Variable Summe, und hier unten in meiner Funktion Main habe ich eine Variable Summe.

Was haben die miteinander zu tun? Korrekt, die haben nichts miteinander zu tun. Das ist am Anfang etwas verwirrend. Hier habe ich eine Variable innerhalb von den Schleifklammern namens Summe,

die ist innerhalb von diesen Schleifklammern verborgen, niemand außerhalb erfährt was davon. Hier oben habe ich eine Variable namens Summe, die ist in diesen Schleifklammern verborgen, niemand erfährt was davon. Die beiden sehen sich nicht, die haben zufällig denselben Namen, lassen sie sich dadurch nicht irritieren.

Wir können hier auch Summe 42 benennen, und jetzt wird dasselbe passieren im Programm. Das sind zwei komplett verschiedene Variablen. Summe 42 ist jetzt 170. Also davon nicht irritieren lassen, dass Variablen an verschiedenen Stellen denselben Namen haben können.

Wenn sie innerhalb von Schleifklammern verborgen sind, macht das überhaupt nichts. Schwieriger wird es, wenn sie hier eine globale Variable namens Summe haben, dann müsste man ein bisschen nachdenken. Weil die wäre natürlich in den Schleifklammern hier sichtbar, und diese innere Variable würde diese äußere verdecken.

Das wäre eine fiese Geschichte, das sollte man nicht tun. Aber hier, da oben Summe, da unten Summe, kein Problem. Stellen Sie sich vor, ich hätte noch eine andere Vorschleife, vielleicht möchte ich mehrere Sachen aufsummieren. Stellen Sie sich vor, ich hätte zwei Vorschleifen hintereinander. Dieses i in der einen Vorschleife und dieses i in der anderen Vorschleife, die würden sich nicht sehen.

Das sind zwei verschiedene Paar Schuhe. Diese Summe hier, das wäre natürlich diese Variable, die vor den beiden Vorschleifen definiert worden ist. Schön die Schleifklammern beachten. Fußnote, in JavaScript ist das anders. Das ist die einzige C-Nahvorgesprache, von der ich weiß, dass es anders ist.

JavaScript nimmt das sehr locker, was diese Schleifklammern angeht. Funktionen wirken in JavaScript so, dass sie die Variable unsichtbar machen. Aber diese for und while und so weiter Schleifklammern wirken da nicht so. Das ist da ein bisschen heikel.

Ende der Fußnote. Die Rolle von Returnsumme, wenn Sie das nicht schreiben würden, wird hoffentlich der Compiler so ein bisschen meckern. Missing return statement at end of non-void function. Das ist ein fehlendes Return. Am Ende der non-void.

Non-void, wenn Sie void davor schreiben, heißt das, Sie geben nichts zurück. Non-void, eine Funktion, die nicht nichts zurückgibt. Ich habe eine Funktion, die nicht nichts zurückgibt, weil ich int davor geschrieben habe. Ich sage, sie gibt eine ganze Zahl zurück, habe keinen Return. Was offensichtlich blödsinnig ist, diese Funktion muss eine ganze Zahl zurückgeben.

Wie auch immer. Das ist das erste Problem, wenn Sie keinen Return haben. Es ist syntaktisch falsch. Sie sagen, ich gebe eine ganze Zahl zurück, geben aber gar nichts zurück. Deshalb muss das da hin. Wir müssen natürlich auch irgendwie tatsächlich unsere Arbeit verrichten.

Summiere soll ja die Summe bestimmen. Wie erfährt die Funktion, die Summiere aufruft, wie erfährt die Funktion main das Ergebnis? Was hier in den Schweifklammern eingeführt wird, zum Beispiel hier diese variable Summe, ist ja unsichtbar außerhalb.

Die einfachste Art, das Ergebnis mitzuteilen, ist zu sagen, Summe, das was ich als Summe rausgekriegt habe, den Zahlenwert, den ich übergebe bitte als Ergebnis. Und der kommt dann hier zurück und wird hier gespeichert. Sie könnten return 42 hinschreiben. Diese Funktion würde, egal was passiert,

immer 42 zurückgeben als Wert. Stellen Sie sich vor, Sie hätten einen Sinus, aus dem nicht 1 durch 4 zu 2 oder minus 1 was rauskommt, sondern ständig 42 rauskommt, egal bei welchem Winkel. 42, da hätten Sie jetzt eine Funktion, egal was reingeht, die rechnet irgendwas, hat aber in jedem Fall das Ergebnis 42.

Was Sie gerade gesagt haben, return i, das ist eine spannende Geschichte. Return i. Correct, i wird nicht gehen, weil i in der Vorschleife verborgen ist. Wenn ich hier sage, project make, gibt das hier, identifier i ist undefined.

An dieser Stelle kennt der i nicht. i ist in der Vorschleife bekannt, aber nicht außerhalb. Also return i würde nicht gehen. Return Summe, so sieht es dann wieder richtig aus. Project make. Zur Initialisierung von x und Length.

Dieser Aufruf hier, Summiere a und 6, dieser Aufruf sorgt dafür, dass dieses x mit dem a initialisiert wird und dass diese Länge mit 6 initialisiert wird. Ich muss jetzt nirgends wo hinschreiben, int Length ist gleich 6 oder sowas.

Das ist automatisch bei der Funktionsaufruf dabei. Wenn Sie sagen, das hier sind die Werte, die in meiner Funktion ankommen sollen, dann werden die automatisch initialisiert. Das ist gerade der Sinn hier von dem a und dem 6. Dieses x wird das a und das Length wird die 6.

So wird die Funktion aufgerufen. Zu Beginn der Funktion werden diese beiden hier mit Werten gefüllt. Vollautomatisch. Ich weiß ja hier, wenn ich die Funktion schreibe, weiß ich ja gar nicht, mit welchen Werten die gefüllt wird. Das hängt ja jeweils vom Aufruf ab. Das passiert dann zur Laufzeit vollautomatisch. Zur Zuordnung von diesen beiden.

C ist sehr großzügig, wenn man verschiedene Typen hier miteinander mischt. Ich probiere mal Folgendes. Was ist, wenn ich für den ersten eine Zahl angebe und für den zweiten das Array angebe? Was der Compiler davon hält. Okay, das stellt er immerhin fest, dass das nicht zusammenpasst. Er kann nicht für das Array die 6 nehmen und für die Zahl das a nehmen.

Da ist er dann doch strikt an der Stelle. Aber ansonsten ist C sehr großzügig. Zu großzügig. Was wird passieren, wenn ich hier summiere a 600 aufrufe?

Ja, irgendwelche anderen Zahlen. Das ist wirklich fies. Mit 600, bei der Ausführung sieht das Programmchen dann hier das Array a und es ist 600 lang. Schön. Und dann nudelt er hier durch. a von 400, a von 401, a von 500, a von 599.

Ein korrektes Betriebssystem will dann irgendwann auf die Nase fallen und sagen, hallo, hier ist was faul. Der einfache Chip hier schluckt das wahrscheinlich. Wenn wir gerade laufen lassen, mal gucken, was da passiert. Ich weiß nicht genau, was passiert. Das hängt so jeweils davon ab. Sie sehen, das wird ohne Probleme übersetzt.

Das stört gar keinen bei der Übersetzung, dass das gar nicht gehen kann. Das merkt sie nicht. Das würden auch die meisten modernen Sprachen nicht merken bei der Übersetzung. Aber die würden es dann beim Ausführen merken. Und ich mal gerade gucken, was er hier sagt. Okay, wir summieren 600 Zahlen und kriegen 4542 raus.

Völliger Blödsinn. Da ist c sehr großzügig. Wenn Sie sagen, da stehen 600 Zahlen in diesem Array, dann tut c so, als ob 600 Zahlen in diesem Array sind. Also man kann sehr locker ziemlich einen Blödsinn veranstalten. Er liest einfach weiter im Speicher. Dieses Array fängt irgendwo im Speicher an.

An dieser Stelle fängt das Array im Speicher an und er liest einfach weiter im Speicher. Ohne Sinn und Verstand. Wie gesagt, ein ordentliches Betriebssystem stellt dann fest, dass dieser Speicher nicht dem Programm gehört. Wenn zu weit gelesen wird zumindest. Und gibt dem Programm etwas auf die Finger, bricht das ab.

Zugriffsverletzung, kennen Sie vielleicht. Auf so einem simplen Ding hier findet das nicht statt. Er liest einfach weiter und kriegt Blödsinn raus. Das ist alles ein bisschen antik, aber relativ einfach. Ohne alle Tests geht das eben schön einfach.

Das ist ideal für solche billigen Chips, die nicht allzu viel können und auch nicht allzu viel Strom verbrauchen. Auch nicht allzu viel kosten. Also wenn man den c mit Arrays hantiert, muss man sich immer merken, wie lang die sind. Wir sehen in den nächsten Wochen nochmal Zeichenketten.

Da gibt es einen Trick in c, dass man sich nicht merken muss, wie lang die sind, sondern dass man das in den Zeichenketten verstecken kann, wie lang die sind. Für alle anderen Arrays kommen Sie praktisch nicht drum herum, sich nicht nur das Array zu merken, sondern auch die Länge zu merken. Mit viel Glück ist das Array immer von derselben Größe. Dann können Sie es als Konstante machen.

Wenn Sie Arrays mal so, mal so haben, das geht mit c inzwischen, dass die auch mal verschiedene Größen haben dürfen, dann muss man ein bisschen vorsichtiger sein. Diese Namensverwirrung hier. Es ist erst mal a und plötzlich wird es x.

Vielleicht erst mal noch ein zweites Array. Wenn ich ein zweites Array habe, namens b, sehr kreativerweise, mit irgendwelchen anderen Werten, was weiß ich, eins, zwei, drei, vier, sowas. Dann nehmen wir auch mal sechs Werte.

Hier ist an dieser Stelle klar, es wird a übergeben, es wird nicht b übergeben. Wenn ich b übergeben wollen würde, müsste ich b schreiben und nicht a schreiben. Das legt fest, was übergeben wird. Und was dann hier oben ankommt, dieses x ist ja sozusagen nur ein Platzhalter.

Es kommt ein Array an und in der Funktion heißt das jetzt x. Ich rechne hier mit x. Die Funktion könnte ja sonst was sein, ich könnte die Funktion auch zweimal aufrufen. Ich hoffe, das ist nicht ganz verwirrend dann. Was ist, wenn ich die Funktion zweimal aufrufe? Einmal summiere ich a und einmal summiere ich b.

So berechnet er erst die Summe von a, so berechnet er erst danach die Summe von b. Beim ersten Aufruf steht das x für das a und beim zweiten Aufruf steht das x für das b. Am Anfang der Funktion wird das x mit Leben gefüllt. Hier wird es für das Array a stehen und da wird es für das Array b stehen.

Das muss ich vielleicht dann doch noch mal zeigen. Da müssen wir gerade gucken, wo die Arrays hier im Speicher stehen.

Jetzt soll er erst mal a aufsummieren. Gucken Sie sich an, wo a steht. 9f0 Hexadezimal, irgendeine Hausnummer. Später mehr dazu, eine Hausnummer im Speicher. Damit geht er jetzt rein in die Funktion summiere.

9f0, das ist x. x hat die Rolle von a. Ich starte an der Stelle im Speicher, wo a steht. Ich gehe mal wieder raus aus der Funktion. Dann hier stamp out. Die erste Summe hier ist berechnet worden, 170. Jetzt gehe ich nochmal rein in dieselbe Funktion, aber mit b.

b steht an der Stelle 9e4 im Speicher. Gehe in die Funktion rein. Und Sie sehen, x hat jetzt die Rolle von b, 9e4. Andere Hausnummer. Und ich gehe raus aus der Funktion.

Und es ist 21 rausgekommen. Und plus 6. Also Sie übergeben hier das, was berechnet werden soll. Wenn da a steht, ist a das, was spannend ist. Wenn da b steht, ist b das, wovon es stattfinden soll. Genauso für den zweiten.

Wenn Sie da nicht 6 reinschreiben, sondern 42, wird die 42 übergeben. Und hier kommt genau das an, was ich übergebe. Dieses x hat nicht immer dieselbe Rolle, sondern die Rolle von dem, was übergeben wird. Und diese Länge, Length, wird mit dem Wert gefüllt, der da als Zweiter steht.

Man wird ja normalerweise die Main-Funktion als Erster haben wollen. Dass ich erstmal sehe, was überhaupt abgeht. Und hier diesen Kleinkram mindestens als Ende setzen, wenn nicht sogar in eine andere Datei. Und das jetzt eben auf die naive Weise macht.

Ich möchte nochmal die Fehlermeldung zeigen. Das wäre jetzt die naive Weise. Erstmal Main nach vorne und dann kommt Summiere. Make. Weil die Fehlermeldung auf diesem System hier ist vielleicht nicht so klar. Funktion Summiere declared simplicity. Der Compiler stößt hier auf Summiere.

Er liest von oben durch. Summiere, kennt Summiere nicht. Und dann ist c so hart drauf. Es baut sich eine Funktion. Es denkt sich was, wie die Funktion aussieht. Und das wird fürs wahrscheinlich falsch sein, wie die Funktion aussieht. Es gibt nur eine Warnung.

Absurderweise kein Fehler. Aber diese Warnung ist eigentlich vernichtend. Das geht so nicht. Der C-Compiler ist nicht so raffiniert. Wir müssen ihm sagen, wie denn diese Funktion Summiere funktioniert. Eine Deklaration. In der Form. Ich habe einfach nur die erste Zeile kopiert von Summiere. Und dann setze ich einfach ein Semikolon dahinter.

Das wäre die Deklaration. Meine erste Zeile hier. Was kommt zurück? Wie heißt die Funktion? Runde Klammer. Semikolon. Dann weiß der Compiler was los ist. Kann es hier schon mal verwenden. Und hier sage ich dem Compiler, wie es nun wirklich funktioniert.

Dann ist er glücklich. Project Make. So geht das. Wo würde ich typischerweise aber eigentlich so eine Deklaration unterbringen? Professioneller wäre jetzt hier diese Funktion in eine andere C-Datei zu schmeißen.

Diese Implementierung. Wäre dann einfach Begriff. Diese Implementierung von Summiere schmeiße ich in eine andere C-Datei. Diese Deklaration. Schmeiße ich in eine Header-Datei. Und ich inkludiere die Header-Datei. So wie hier eben schon standardmäßig die Header für den Chip mit den ganzen Standardfunktionen.

Und Konstanten für diesen Chip inkludiert sind. Den schmeiße ich in eine Header-Datei. Und inkludiere dann die Header-Datei. Das wäre das übliche. Eine Sache muss ich noch sagen. Weil ich das jetzt gerade eben noch an zwei Stellen gesehen habe. Sie können nicht eine Funktion innerhalb einer anderen bauen.

Das passiert gerne am Anfang. In C geht das nicht. Sie können nicht sagen, oh ich hätte hier jetzt gerne eine Funktion. Blablabla. Innerhalb der anderen. Er kann es einfach nicht. Da kann ich auch nichts führen. So ist das halt. Das funktioniert nicht. Wenn Sie Funktionen so verschachteln wollen.

Funktionen stehen nebeneinander in C. Da gibt es keine Hierarchie an der Stelle. Sie können die nicht ineinander schreiben. Sondern es gibt die eine Funktion namens Main. Die steht für sich. Firearm. Hier gibt es die Funktion Summiere. Die steht für sich.

Die können nur so stehen. All das kann man in anderen Sprachen ein bisschen entspannter sehen. In C ist das sehr strikt. Auch dass die Funktion erst deklariert werden muss. Ist in C strikt. Das ist in anderen Sprachen dann lockerer.

Jetzt versuchen wir das mal zu vorallgemein. Ich hätte gerne eine Funktion. Die das Maximum aus einem Irre findet. Maximum. Wenn nenne ich das mal. Findemax. Findemax ist gut.

Findemaximum. Und da übergebe ich das Irre natürlich wieder mal C. Mäßig die Länge von dem Irre. Schreiben wir so eine Funktion. Der größte vorkommende Wert. Der soll zurückgegeben werden. Also hier die 100. Das ist langweilig. Wenn es der letzte ist, machen wir hier eine 420 drauf.

So. Hier die 420 soll zurückgegeben werden. Und da soll die 6 zurückgegeben werden. Der größte Wert kann natürlich mehrfach vorkommen. Wenn ich hier nochmal 420 reinschreibe. Egal. Hauptsache 420 wird zurückgegeben. Egal wie oft es vorkommt. Vielleicht nochmal gerade den Ansatz, wie man es finden kann.

Ich gucke mir die Nummer 0 an. Was steht in der Nummer 0 und in der Nummer 1? Davon nehme ich den größten. Das ist der Gewinner sozusagen. Dann gucke ich mir die Nummer 2 an. Und den hier. Von den nehme ich den größeren.

Oder wenn sie gleich sind, einen von den beiden. Egal. Und dann nehme ich die Nummer 3 noch dazu. Hier den Gewinner. Und die Nummer 3. Die beiden vergleiche ich. Nehme den größeren. Oder wenn sie gleich sind, einen davon. Und dann die Nummer 4. Das wäre mein Gedanke.

So in dieser Form. Quasi eine Art von Turnier. 0 und 1 spielen gegeneinander. Ich nehme den größeren. Wenn sie gleich sind, einen von den beiden. Dann dieser Gewinner spielt gegen Nummer 2. Dieser Gewinner spielt gegen Nummer 3.

Dieser Gewinner spielt gegen Nummer 4. Das heißt ich laufe tatsächlich einmal durch jeden Eintrag durch. Es sind nicht zwei Schleifen ineinander. Es reicht einige einzige Schleife. Jeder wird ein einziges Mal angeguckt. Und was ich mir merke, ist ein Kandidat fürs Maximum. Vorher haben wir uns gemerkt, was die Summe sein wird.

Hier merken wir uns einen Kandidaten fürs Maximum. Und zum Schluss, beim allerletzten, nach dem letzten Spiel sozusagen, ist dieser Kandidat fürs Maximum auch das wirkliche Maximum. Also hier müsste was stehen. Ich kopiere das mal ganz dreist. Im Prinzip sowas ähnliches.

Es heißt dann eben finde Maximum. Und hier, das heißt natürlich nicht Summe, sondern Maximum. Am Ende wird es das Maximum sein. Ich gebe das Maximum zurück. Ich könnte das auch A oder Z oder weiterhin Summe nennen, was sehr irritierend wäre.

Ich nenne es sinnvollerweise Maximum. Die Vorschleife durchläuft alle hier über die Null. Da müssen wir nochmal nachdenken. Und hier oben lege ich schon mal sofort eine Deklaration an.

Finde Maximum. Finde Maximum. Gucken wir uns gerade selbst noch mal die Vorschleife an und diesen Maximumskandidaten. Sich das angucken. Wie viel Durchläufe braucht die Vorschleife?

Ich habe fünf Einträge. Ich habe fünf Einträge. Wie viel Durchläufe braucht meine Vorschleife? Das ist der Witz. Das ist jetzt anders als bei der Summe. Sie kommen mit vier Vergleichen aus. Wir haben fünf Teilnehmer, müssen aber nur viermal spielen. Einer weniger.

Das heißt, diese Vorschleife muss gar nicht bei, muss man überlegen, was am geschicktesten ist, statt wird die bei eins einfach. Das könnte am geschicktesten sein. Die Vorschleife wird eins kürzer. Die läuft von eins los, nicht von null los. Ich habe einen Durchgang weniger als diese Länge anzeigt.

Und jetzt müssen wir hier spielen, sozusagen. Was heißt dieses Spiel hier? Was passiert hier? Was muss in die Vorschleife rein? Dieses jeweils ist ein Durchlauf der Vorschleife.

Zwei treten gegeneinander an. Was heißt das im Endeffekt? Genau, dann haben wir es. Wenn Sie sich also dieses Spiel hier angucken, das ist Nummer drei, spielt gegen den größten bisherigen Wert. Ich vergleiche den größten bisherigen Wert mit Nummer drei. Und gucke, wer gewinnt.

Das wird der neu größte bisherige Wert. Der wird dann im nächsten Durchlauf mit vier verglichen. Also steht hier, wir gucken uns an, was ist mit dem neuen Spieler, den wir uns jetzt angucken,

wird der gegen den bisherigen gewinnen. In der Form wird der gewinnen. Wenn ja, dann ist das der neue Beste. Maximum ist gleich x von i.

So wird das sein. Das passiert in jedem Durchgang. Das muss ich hier vielleicht nochmal zeigen. Xi größer Maximum. Hier die drei. Wenn i gleich drei ist, dann ist hier x von drei. Das hier ist das bisherige Maximum.

Ich vergleiche. Und das neue Maximum wird dann sein, wer von den beiden am größten ist. Oder wenn beide gleich sind, einer von den beiden. Egal. Genau das passiert hier in der Schleife. Ich gucke nach, ob der neue gewinnen würde.

Wenn er gewinnen würde, dann ist er das neue Maximum. Das einzige, was mir jetzt noch fehlt, ist hier der Anfangswert für Maximum. Das ist nicht mehr Null. Richtig, der Anfangswert für Maximum ist x von Null. Denn, wenn Sie sich hier das in der Skizze angucken,

hier, der allererste, das ist ja das Maximum, mit dem ich in den ersten rein gehe. Das ist x von Null schlicht und ergreifend. So wird das funktionieren. Gucken wir uns den gerade nochmal an, ob das irgendwas Sinnvolles macht. Die Summen hatten wir alles schon.

Ich gehe in meine Funktion rein. Maximum von Null ersetzt es auf den ersten möglichen Wert. Das war die 3. Vielleicht können wir mal gucken, was war das hier? 3, 420 und so weiter. Bin ich mit meiner Schleife schon am Ende?

Nein. Jetzt gucke ich nach. Der mit der Nummer 1, das war die 420. Der mit der Nummer 1. Ist der größer als der bisherige Maximale? Offensichtlich ja. Also setze ich den maximalen Wert, den ich bisher habe, auf den neuen, die 420.

Und ab da wird keiner mehr gewinnen. Klar. Und wir geben die 420 zurück, wie sich das gehört. Maximum steht auf 420. So geht das. Das wäre, wie ich das Maximum eines Erays bestimmen kann.

Ich gehe alle durch und veranstalte hier sozusagen so ein Turnier. Der bisherige Beste gegen den Nächsten. Und gucke, wer gewinnen wird.