Ich kann jetzt alleine Schleifen programmieren…

aber keine Schleifen binden. Mittlerweile haben schon so viele gute und hilfsbereite Freunde völlig entsetzt darauf reagiert. Und dann haben sie mir gezeigt, wie man „natürlich“ Schleifen bindet. Allerdings zeigten sie mir alle eine andere Schleifen-Technik. Und ich habe alle schon wieder vergessen. Ich bin also weiterhin abhängig von lieben Menschen, die mir unterwegs die Schuhe zubinden, damit ich nicht in meiner Fahrradkette hängenbleibe. Ich bin seit Jahren kein Single gewesen. Das hat aber nichts miteinander zu tun.

In Kapitel 5 geht es jedenfalls um Schleifen. Schleifen! Selbst in meinem Lieblingschat ##fionalerntprogrammieren (ja, nur echt und untergeordnet mit zwei Rauten!) wurde positiv darauf reagiert, ohne dass ein einziges Mal das Wort „Dum“ fiel. Schleifen scheinen The Big Shit zu sein im Programmierbusiness. Eigentlich sind ja auch Schleifen die Steilvorlage für das, was Computer uns bieten können: Unheimlich blöde Aufgaben übernehmen, das aber rasend schnell. Mit einer Schleife kann ich einen Teil des Programms immer wieder ausführen lassen. Menschen könnten das zwar auch, aber langsamer und wir werden depressiv bei solchen Dingen. Und da Maschinen zum Glück über keine Rechte verfügen, kann ich sie dazu verpflichten, immer wieder neu zu berechnen, wo sich gerade mein Mauszeiger befindet. Nicht auszudenken, wie scheiße das für einen Menschen wäre.

(Was rede ich hier eigentlich für einen Quatsch? Es ist 2:55, zurück zum Thema.)

Ich lernte drei verschiedene Schleifentypen kennen: Die For-, die Do- und die While-Schleife. For arbeitet mit einer Zählvariablen, die hochzählt, wie oft der Programmteil wiederholt werden soll. Bei der While-Schleife gibt es dagegen eine Bedingung, die entscheidet, wie oft der Teil durchlaufen wird. Bei der Do-Schleife befindet sich diese Bedingung am Ende des zu wiederholenden Programmteils.

Ein Beispiel für eine for-Schleife bietet das folgende GANZ ALLEINE geschriebene Programm:

#include <stdio.h>
main ()
{
        int x, n, gesamt=0;
        printf("\n\tADD THE ODDS\n");
        printf("\nDieses Programm rechnet alle ungeraden Zahlen bis n zusammen\n");
        printf("\nBitte Wert für n eingeben: \n");
        scanf("%i", &n);
        for (x=0; x<=n; x=x+1)
        {
                if ((x%2))
                gesamt = gesamt + x;
                else 
                        continue;
        }
        printf("\nDie Summe der ungeraden Zahlen bis n beträgt %i\n", gesamt);
}

Das Programm berechnet die Summe aller ungeraden Zahlen bis zur Zahl n, die ich selber bestimmen kann. Per scanf wird n eingelesen, bspw.. eine 5. Nein, ich bin faul, lieber eine 3.
Dann kommt die for-Anweisung.

for (x=0; x<=n; x=x+1)

In der Klammer steht als erstes eine Zuweisung. x soll zu Beginn auf Null gesetzt sein. Danach folgt die Bedingung. Wenn x kleiner/gleich n ist, wird die Schleife durchlaufen. Als letztes wird bestimmt, dass x nach jedem Schleifendurchlauf mit 1 addiert wird. Das muss nicht 1 sein, manchmal ergibt es auch Sinn, um 2 zu erhöhen. Dann folgt die geschweifte Klammer, nach welcher der Programmteil steht, der jetzt wiederholt wird.

Die if-Konstruktion

 if ((x%2))

prüft, ob als Divisionsrest 1 oder 0 vorliegt (x%2). Wenn x durch 2 teilbar ist, handelt es sich um eine gerade Zahl und es steht eine 0 in der Klammer. 0 ist logisch ein „Falsch“. Also ist die Bedingung logisch nicht erfüllt und zur Variablen „gesamt“ wird die keine Zahl hinzugezählt. Stattdessen wird zur if else gesprungen und durch „continue“ springt das Programm zurück zum Anfang der Schleife. Eins ist der zweite Wert der für x eingesetzt wird, weil x um Eins erhöhrt wurde, wie es im dritten Teil der For-Bedingung bestimmt wurde. Bei x=1 würde in der Klammer eine 1stehen, eine logisch „wahre“ Aussage. Die darunter stehende Anweisung wird also ausgeführt, und es wird x (also 1) zur Variablen „gesamt“ hinzuaddiert.
Machen wir mit x=2 weiter. x wurde wieder um eins erhöht. Wenn x nun gleich 2 ist, steht in der Klammer wieder eine Null, es wird also nichts zur Variablen „gesamt“ hinzugefügt. Ist x=3, ist die Aussage (x%3) wiederum wahr und 3 wird zu gesamt hinzugerechnet.
Jetzt wird x wieder um eins erhöht und ist bei 4. Das widerspricht allerdings der Bedingung, dass x<=3 sein soll. Also wird die Schleife nicht nochmal ausgeführt und es wird hinter der geschweiften, schließenden Klammer weitergemacht.
Jetzt erfolgt ein noch eine Print-Anweisung, welche den Wert von „gesamt“ ausgibt und das Programm ist beendet.

Die While-Schleife kann mit einem ganz einfachen Programm erklärt werden:

#include <stdio.h>
main ()
{
        int zahl;
        printf("Dieses Programm berechnet das Quadrat von n\n");
        printf("\nBitte Zahl eingeben ('0' fuer Lassdas!): ");
        scanf("%i", &zahl);
        while(zahl != 0)        
        {
                printf("%3i hoch 2 = %4i\n", zahl, zahl*zahl);
                printf("\nBitte Zahl eingeben ('0' fuer Ende): ");
                scanf("%i", &zahl);
        }
}

Das Programm berechnet das Quadrat von n, bzw. vom Wert, der „zahl“ zugeordnet wurde. Für „zahl“ kann immer wieder ein neuer Wert eingesetzt werden, bis eine Null eingegeben wird. Dann wird die Schleife nicht mehr ausgeführt. Denn die Bedingung, die nach while in der Klammer steht, lautet: Solange „zahl“ ungleich Null ist, wird der Teil in den geschweiften Klammern wiederholt.Wenn nicht, dann nicht!

So weit, so gut wie möglich erklärt. Aber ich glaube, ich werde die Schleifen noch ein paar Mal nachprogrammieren und selber anwenden müssen, um sie wirklich verstanden zu haben und geschickt einsetzen zu können.

In der Hoffnung, dass der Post nicht allzu verwirrend war wünsche ich eine gute Nacht und bitte um Nachsicht. Es ist das Ergebnis von viel Kaffee, einem Bier, einem Bernd, der in meinem Zimmer lauert (er will mir seinen Namen nicht verraten) und zwei Tütensuppen, für die ich mich sehr schäme.

With Endlosschleifen-Love:

FLP

%d Bloggern gefällt das: