Alex schrieb:
> echt!!
> wird so funktioniert?
Sag du's mir!
Du bist Computer und arbeitest das Programm ab.
1 | Var1 Var
|
2 | +---+---+---+ +---+---+---+
|
3 | | 2 | 4 | 6 | | | | |
|
4 | +---+---+---+ +---+---+---+
|
5 | | | | |
|
6 | Var2 +---+---+---+
|
7 | +---+---+---+ | | | |
|
8 | | 1 | 3 | 5 | +---+---+---+
|
9 | +---+---+---+
|
10 |
|
11 | i j
|
12 | +---+ +---+
|
13 | | | | |
|
14 | +---+ +---+
|
jetzt gehst du dein Programm durch und machst mit den Kästchen (die
deine Variablen symbolisieren) genau das und nur das, was dir der
Programmtext vorschreibt.
for( i = 0; i < 3; i++ )
was passiert hier?
(i wird auf 0 gesetzt und dann wird das erste mal die Bedingung geprüft.
Also setz i auf 0
1 | Var1 Var
|
2 | +---+---+---+ +---+---+---+
|
3 | | 2 | 4 | 6 | | | | |
|
4 | +---+---+---+ +---+---+---+
|
5 | | | | |
|
6 | Var2 +---+---+---+
|
7 | +---+---+---+ | | | |
|
8 | | 1 | 3 | 5 | +---+---+---+
|
9 | +---+---+---+
|
10 |
|
11 | i j
|
12 | +---+ +---+
|
13 | | 0 | | |
|
14 | +---+ +---+
|
dann wird die Bedingung geprüft. i < 3.
Schau auf deinem Zettel mit den Variablen nach. Welchen Wert hat i? Im
Kästchen i steht 0 drinnen. 0 ist kleiner als 3 also wird die Schleife
betreten.
Was geschieht innerhalb der Schleife
for( j = 0; j < 3; j++ )
Wieder j wird auf 0 gesetzt und die Bedingung geprüft
j wird auf 0 gesetzt
1 | Var1 Var
|
2 | +---+---+---+ +---+---+---+
|
3 | | 2 | 4 | 6 | | | | |
|
4 | +---+---+---+ +---+---+---+
|
5 | | | | |
|
6 | Var2 +---+---+---+
|
7 | +---+---+---+ | | | |
|
8 | | 1 | 3 | 5 | +---+---+---+
|
9 | +---+---+---+
|
10 |
|
11 | i j
|
12 | +---+ +---+
|
13 | | 0 | | 0 |
|
14 | +---+ +---+
|
und die Bedingung lautet j < 3?
Schau nach: j ist 0, 0 ist kleiner als 3, also wird die Schleife
betreten
Var[i][j] = Var1[i] * Var2[j]
Was passiert hier?
Rechte Seite der Zuweisung
Var1[i]
Welchen Wert hat i? Schau am Zettel nach -> 0
Was ist daher Var1[0]? Wieder nachsehen: Var1 suchen und vom Array den
Eintrag mit dem Index 0 (der von i kommt) aufsuchen. Also gleich das
erste Kästchen. Was steht drinnen -> 2
Was brauchst du noch auf der rechten Seite?
Var2[j]
Was ist der Wert von j? -> 0
Was ist also Var2[j]. Wieder am Zettel nachsehen. Var2 finden und dort
den Eintrag mit dem Index 0 -> 1
auf der rechten Seite stand Var1[i] * Var2[j]
Die Einzelwerte wurden bestimmt zu 2 * 1
das ausgerechnet ergibt -> 2
damit ist die rechte Seite fertig. Links vom = steht
Var[i][j]
i war 0, j war 0.
Also such die Variable Var auf und identifiziere das Feld am
Schnittpunkt von erster Zeile und erster Spalte. Und dort schreibst du
das Rechenergebnis rein.
1 | Var1 Var
|
2 | +---+---+---+ +---+---+---+
|
3 | | 2 | 4 | 6 | | 2 | | |
|
4 | +---+---+---+ +---+---+---+
|
5 | | | | |
|
6 | Var2 +---+---+---+
|
7 | +---+---+---+ | | | |
|
8 | | 1 | 3 | 5 | +---+---+---+
|
9 | +---+---+---+
|
10 |
|
11 | i j
|
12 | +---+ +---+
|
13 | | 0 | | 0 |
|
14 | +---+ +---+
|
damit ist die innere Schleife erst mal am Ende angelangt, es wird vom
for das Inkrement ausgeführt: j++
also: j aufsuchen, wert holen, der ist 0, den erhöhst du um 1, das
Ergebnis ist also 1, und den schreibst du zurück nach j
1 | Var1 Var
|
2 | +---+---+---+ +---+---+---+
|
3 | | 2 | 4 | 6 | | 2 | | |
|
4 | +---+---+---+ +---+---+---+
|
5 | | | | |
|
6 | Var2 +---+---+---+
|
7 | +---+---+---+ | | | |
|
8 | | 1 | 3 | 5 | +---+---+---+
|
9 | +---+---+---+
|
10 |
|
11 | i j
|
12 | +---+ +---+
|
13 | | 0 | | 1 |
|
14 | +---+ +---+
|
Die for-Schleife geht wieder nach oben und es wird die bedingung geprüft
j < 3
j - ablesen vom Zettel - hat den Wert 1. 1 ist kleiner als 3. Ja, die
Schleife wird erneut ausgeführt.
Var[i][j] = Var1[i] * Var2[j]
rechts vom = steht
Var1[i] * Var2[j]
um das zu berechnen brauchen wir also mal Var1[i]. i war 0, also das
erste Feld von Var1 aufsuchen, da steht 2 drinnen.
j hat den Wert 1, also das zweite Feld in Var2 aufsuchen. Da steht 3
drinnen.
Also wird gerechnet 2 * 3
Und das wird zugewiesen an Var[i][j]
i war 0, j war 1
also suchst du den SChnittpunkt der ersten Zeile mit der 2ten Spalte und
schreibst dort das Rechenergebnis rein
1 | Var1 Var
|
2 | +---+---+---+ +---+---+---+
|
3 | | 2 | 4 | 6 | | 2 | 6 | |
|
4 | +---+---+---+ +---+---+---+
|
5 | | | | |
|
6 | Var2 +---+---+---+
|
7 | +---+---+---+ | | | |
|
8 | | 1 | 3 | 5 | +---+---+---+
|
9 | +---+---+---+
|
10 |
|
11 | i j
|
12 | +---+ +---+
|
13 | | 0 | | 1 |
|
14 | +---+ +---+
|
damit ist die for-Schleife unten angelangt. Das Inkrement wird
ausgeführt, welche ist: j++
also erhöhst du j um 1 und ab gehts an den Anfang der Schleife, wo die
bedingung geprüft wird
etc. etc. etc.
Du machst genau das und nur das, was im Programmtext steht. Auf deinem
Zettel sind die Kästchen mit Variablen. Wenn eine Variable im Programm
gelesen wird, dann liest du den Wert aus dem Kästchen ab, wenn im
Programm an eine Variable zugewiesen wird, dann radierst du den Wert aus
und schreibst den neuen hinein.
Ganz einfach.
Was anderes macht dein Computer auch nicht. Nur schneller.
Thread beobachten
Seitenaufteilung abschalten