Interessante Programmieranleitung für Designer--Program Process Control-Loop Statement: 8 Schritte

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:22

Programmprozesssteuerung – Schleifenanweisung

Von diesem Kapitel an werden Sie mit einem wichtigen und mächtigen Wissenspunkt-Loop-Statement in Berührung kommen.

Bevor Sie dieses Kapitel lesen, können Sie, wenn Sie 10.000 Kreise im Programm zeichnen möchten, nur mit einer schrecklichen Methode vorgehen. Das heißt, 10.000 Zeilen Ellipsencode zu schreiben. Diejenigen faulen Code-Designer, die die Effizienz mit allen Mitteln verbessern wollen, würden dies definitiv nicht zulassen. Es wird also eine Schleifenanweisung erstellt. Mit dieser Aussage können Sie die Kraft der Computerautomatisierung intuitiv spüren.

Schritt 1: Für Schleife

Es gibt viele Schleifenanweisungen, von denen die am weitesten verbreitete For Loop ist. Wir alle wissen, dass die Funktion Draw ständig im Umlauf ist. Beginnen Sie mit dem ersten Satz am Anfang, es wird von oben nach unten bis zum letzten Satz implementiert. Nachdem es eine Operation beendet hat, beginnt es wieder mit dem ersten Satz. For-Anweisung ist der Funktion draw ein wenig ähnlich. Code innerhalb der for-Anweisung kann wiederholt ausgeführt werden.

Hier ist seine Grammatikstruktur:

For(Ausdruck 1; Ausdruck 2; Ausdruck 3){

Schleifenkörper

}

Offensichtlich haben wir erwartet, dass Sätze innerhalb des Schleifenkörpers wiederholt implementiert werden. Ausdruck 1 wird verwendet, um die Schleifenvariable zu initialisieren und den ersten Wert zuzuweisen. Ausdruck 2 ist für Schleifenbedingung. Ausdruck 3 aktualisiert den Wert der Schleifenvariablen.

Was ist Schleifenvariable? Es entspricht eigentlich einer lokalen Variablen. Werfen wir einen Blick auf ein vollständiges Schreiben.

for(int i = 0; i < 10; i ++) {

Schleifenkörper

}

Um die Schleifenfunktion zu realisieren, benötigt die for-Anweisung hauptsächlich eine lokale Variable, die am Ende der Schleife verwendet wird. Die lokale Variable im obigen Beispiel ist i. Ausdruck 1 hat die Initialisierung der lokalen Variablen abgeschlossen. Später, jedes Mal, wenn die Schleife einmal ausgeführt wird, muss diese Variable aktualisiert werden. Von den obigen Beispielen wird i++ in Ausdruck 3 verwendet, um eine Aktualisierungsfunktion zu realisieren. Dadurch wird die Variable bei jeder Aktualisierung um 1 erhöht. Letztendlich kann der Code innerhalb des Schleifenkörpers nicht endlos durchlaufen, sonst können die letztgenannten Anweisungen nicht ausgeführt werden. Wir brauchen also eine Endbedingung. Express 2 ist genau dafür. Hier beurteilt das Programm, ob i kleiner als 10 ist. Wenn dies der Fall ist, fahren Sie mit der Operation fort. Wenn nicht, dann spring aus der Schleife.

Daher ist die Operationsfolge der for-Anweisung genau so.

Ausdruck 1 (Initialisierung der lokalen Variablen)

Ausdruck 2 (Zufrieden, dann weiterarbeiten)

Schlaufenkörper (Erster Umlauf)

Ausdruck 3 (Aktualisierung)

Ausdruck 2 (Zufrieden, dann weiterarbeiten)

Schleifenkörper (zweiter Umlauf)

Ausdruck 3 (Aktualisierung)

Ausdruck 2 (Zufrieden, dann weiterarbeiten)

Schlingenkörper (Dritter Kreislauf) …

Ausdruck 3 (Aktualisierung)

Ausdruck 2 (Nicht erfüllt, dann aus der Schleife springen)

Diesen Ausführungsablauf können Sie mehrmals im Kopf simulieren. Aber es ist unmöglich, den Code wirklich zu verstehen, ohne ihn einmal mit der Hand zu tippen. Wenn wir ein seltsames Konzept herausfinden möchten, können wir den Wert in der Konsole über die println-Anweisung ausgeben.

Codebeispiel (5-1): void setup(){

for(int i = 0; i < 10; i++) {

println ("Ausführen");

}

}

Sie können die Anzahl der ausgeführten Ausgaben in der Konsole zählen. Hier sind es genau 10. Dies sagt Ihnen, wie oft der Code im Schleifenkörper ausgeführt wurde. Wir können jedoch immer noch nicht erkennen, welche Änderungen in der Schleife tatsächlich passiert sind. Wir können also versuchen, das Zeichen "lauf in die Variable "i" zu ändern und sehen, was passiert.

Codebeispiel (5-2): void setup(){

for(int i = 0; i < 10; i++) {

println (i);

}

}

Jetzt können wir sehen, dass der Wert i im Schleifenkörper kontinuierlich ansteigt. Später können wir diesen Wert verwenden, um den aktuellen Prozess der Schleife zu verstehen.

Im Codebeispiel (5-2) wird der Wert von i von 0 auf 9 geändert. Im Vergleich zu den tatsächlichen Schleifenzeiten scheint es immer 1 weniger zu haben. Wenn Sie sich nicht daran gewöhnt haben, kann der Ausdruck in Klammern der for-Anweisung wie folgt geschrieben werden:

for(int i = 1; i <＝ 10; i++)

Somit entspricht i zu Recht den Schleifenzeiten. Die Bedeutung von "<＝" ist kleiner und gleich. Wenn also i gleich 10 ist, erfüllt es immer noch die Bedingung. Daher funktioniert es noch einmal im Vergleich zum Schreiben in i < 10. Obwohl es bei 1 beginnt, sind die Schleifenzeiten immer noch 10. Wenn nichts Besonderes erforderlich ist, möchte ich natürlich vorschlagen, dass Sie die Schreibmethode im übernehmen Beispiel am Anfang. Später werden wir Ihnen den Vektor oder das Array vorstellen, die beide ihr Element durch ihren Index erhalten. Und die standardmäßigen Indizes beginnen alle bei 0. Den Anfangswert auf 0 zu setzen, ist die vergleichsweise gängige Praxis.

Wenn wir im obigen Beispiel schreiben, dass i größer als 0 ist, stürzt das Programm ab. Da die Variable konstant ansteigt, wird sie diese Bedingung niemals erfüllen. Dies ist so, als ob es nie gestoppt werden kann, so dass das Programm in eine Endlosschleife läuft.

Lokale Variablen in der for-Anweisung können nicht nur plastische Typen deklarieren, sondern auch Variablen in Gleitkommatypen. Es kann beispielsweise geschrieben werden als (float i = 0; i <10; i + = 0.02).

Schritt 2: Verwenden Sie for Loop, um mathematische Probleme zu lösen

Erinnern Sie sich noch an eine Kindheitsgeschichte des Mathematikers Gauß? Zu diesem Zeitpunkt war Guass 10 Jahre alt. Sein Lehrer wollte in der Klasse eine Aufgabe zuweisen und die Frage war

1＋2＋3＋4……＋97＋98＋99+100＝？

Wenn Sie mit den Händen rechnen, brauchen Sie viel Zeit. Aber Guass scheint die Methode der Summation der arithmetischen Folge bereits herausgefunden zu haben. Kurz nachdem die Frage gestellt war, sprach er die Antwort mit Leichtigkeit aus, was seinen Lehrer sehr überrascht hatte.

Jetzt erinnern wir uns vielleicht nicht mehr daran, wie die arithmetische Folge summiert wurde, aber wir können die Antwort auf primitive und gewaltsame Weise erhalten. Und das ist für Schleife. Da das Zählen von Computern nur ein kleines Stück Kuchen ist, müssen wir die Frage in einer für Computer erkennbaren Sprache beschreiben, dann können wir unsere Antwort leicht bekommen.

Codebeispiel (5-3):

Void-Setup () {

int-Antwort = 0;

for(int i = 1; i <= 100; i++) {

Antwort += ich;

}

println(Antwort);

}

Ich glaube, das Ergebnis, das Sie erhalten, ist das gleiche wie die Antwort, die Guass berichtet hat: Es ist 5050!

Tipps: Der Name lokaler Variablen in der for-Schleife kann nach Belieben geändert werden, vorausgesetzt, er hält sich an die Regeln für die Benennung von Variablen. Sie können es als (int k = 1;k <= 100;k++) schreiben. Wenn keine besonderen Bedingungen aufgetreten sind, wird standardmäßig i als Name der Variablen verwendet.

Schritt 3: Für Loop-Zeichnung

Nach einer Reihe scheinbar langweiliger Bettwäsche können wir endlich zu einem interessanteren Abschnitt kommen. Das ist für die Schleife zu verwenden, um Bilder zu zeichnen. Wir können diese mühsame mathematische Berechnung jetzt beiseite legen. Wir Designer sind sensibler für Grafiken.

Verwenden Sie For Loop, um ein Kreisarray zu zeichnen

Wenn wir eine for-Schleife verwenden möchten, um eine Gruppe von wiederholten Elementen darzustellen, müssen wir vorher die Zahlenrelation dieser Elemente sicherstellen, dann können wir die for-Schleife verwenden, um dies bequem zu realisieren, anstatt massive Wiederholungsarbeit zu leisten. Angenommen, wir möchten eine Kreisreihe zeichnen, die in horizontaler Richtung gleichmäßig verteilt ist. Seine virtuelle Koordinate bleibt unverändert, während seine horizontale Koordinate geändert wird. Und von links nach rechts nimmt die horizontale Koordinate ständig zu und der zunehmende Abstand ist gleich. Zu diesem Zeitpunkt können wir i in der for-Schleife verwenden, um die horizontale Koordinate jedes Kreises zu erhalten.

Codebeispiel(5-4): void setup(){

Größe (700, 700);

Hintergrund (83, 51, 194);

keinStroke();

}

Leere zeichnen (){

for(int i = 0; i < 7; i ++) {

Ellipse (50,0 + i * 100,0, Höhe/2,0, 80,0, 80,0);

}

}

50 steht für die Startposition des ersten Kreises links. 100 in i * 100 steht für die zunehmende Entfernung.

Schritt 4: Verwenden Sie for Loop, um einen zufälligen runden Punkt zu zeichnen

Die obige Grafikposition ist vorhersehbar. Dadurch wird viel Interesse minimiert. Wir können die Funktion random verwenden, auf die wir im vorherigen Kapitel Bezug genommen haben, und versuchen, sie in die Zeichenfunktion zu schreiben.

Codebeispiel (5-5):

Void-Setup () {

Größe (700, 700);

Hintergrund(0);

keinStroke();

}

Leere zeichnen (){

Hintergrund(0);

for(int i = 0; i < 10; i ++) {

float randomWidth = random(60,0);

Ellipse (zufällig (Breite), zufällig (Höhe), zufällige Breite, zufällige Breite);

}

}

Hier ist der Grund, warum die Position des Kreises kontinuierlich blinkt, darin, dass jedes Mal, wenn die Zufallsfunktion einmal ausgeführt wird, das Ergebnis zufällig ist. Da die Funktion Zeichnen standardmäßig 60 Bilder pro Sekunde ausführt, ändern alle 10 in einer Sekunde gezeichneten Kreise ihre Position 60 Mal. Durch diesen schnellen Blitz scheint das Bild mehr als nur 10 Kreise zu haben. Wenn Sie einen einfachen Wert im Programm ändern, erhalten Sie einen ganz anderen Effekt. Wir können die Schleifenzeiten ändern, indem wir die Terminalbedingung überarbeiten. Die Klemmenbedingung im Bild unten ist i < 100

1. Hier ist der Effekt, wenn die Endbedingung i < 1000 ist:
2. RandomSeed
3. Wenn ich nicht möchte, dass die Position des Kreises sowie sein Blitz zufällig generiert werden, was kann ich tun? Eine Methode besteht darin, für jeden Kreis unabhängige Variablen zu erstellen und zu speichern und diese Variablen im Setup zu initialisieren. Weisen Sie diesen Variablen einen zufälligen Wert zu. Wenn wir die Zeichenfunktion innerhalb von draw verwenden, haben wir also den in Variablen gespeicherten Wert aufgerufen. Es wird sich zu keiner Zeit ändern. Um 10 Kreise zu zeichnen, können wir einfach diese Methode verwenden. Aber was ist, wenn wir 1000 Kreise oder 10.000 Kreise zeichnen wollen? Es wird ziemlich mühsam, wenn wir diese traditionelle Methode verwenden, um diese Variablen zu erstellen und sie zu benennen. Wir müssen keine neue Methode zum Erstellen von Variablen lernen. Hier ist eine flexible Methode, die uns helfen kann, dieses Ziel zu erreichen. Das heißt, randomSeed zu verwenden. Werfen wir nun einen Blick auf die Wirkung nach der Verwendung. Codebeispiel (5-6):[cceN_cpp theme="dawn"] void setup(){ size(700, 700); background(0);keinStroke();}

4. Leere zeichnen (){

   Hintergrund(0);

   zufälliger Samen(1);

   for(int i = 0; i < 10; i ++) {

   float randomWidth = random(20.0, 60.0);

   Ellipse (zufällig (Breite), zufällig (Höhe), zufällige Breite, zufällige Breite);

   }

   } [/cceN_cpp]

   Im Vergleich zum vorherigen Code hat es keine Änderungen, außer dass der Radiusbereich des Kreises von 10 auf über 30 mit einem Satz von nur SeedRandom geändert wird. Nach dem Hinzufügen dieses Satzes scheint die Grafik statisch zu werden.

   Aufrufformat:

   RandomSeed(a);

   Bei diesem Format ist die Einstellung von a der Seed. Sie müssen einen Integer eingeben (schreiben Sie einen Gleitkommawert in P5, es wird nicht schief gehen, aber behandeln Sie ihn als Integer). Die Funktion von randomSeed besteht darin, den Startwert für den Zufallswert zu setzen. Dann wird es je nach Seed verschiedene zufällige Arrays generieren. Danach rufen wir die Funktion random auf, damit das Ergebnis der Rückgabe eindeutig ist. Hier ist das Definite nicht für das Ergebnis ein definitiver Wert, sondern für das generierte Array. Das heißt, das Ergebnis der Rückgabe ist relativ zu den Aufrufzeiten eindeutig.

   Code-Beispiel (5-7):[cceN_cpp theme="dawn"] void setup(){

   zufälliger Samen(0);

   for(int i = 0; i < 5; i ++) {

   println(zufällig(10));

   }

   } [/cceN_cpp]

   Jetzt fahren wir mit println fort, um ein Experiment durchzuführen. Nach der Verwendung von randomSeed wird jedes Mal, wenn Sie das Programm schließen und das Programm neu starten, zu einer Zeichenfolge mit dem gleichen Ergebnis zurückgekehrt. Der Wert wird nacheinander der Sequenz entsprechen. Wenn Sie es löschen, wird es jedes Mal auf einen anderen Wert zurückgesetzt. Warum hat es diese Einstellung? Es liegt daran, dass der Zufallswert selbst im Programm pseudozufällig ist. Das Ergebnis scheint zufällig zu sein, aber tatsächlich wird es durch eine feste und wiederholbare Berechnungsmethode generiert. Es ist äquivalent einen primitiven Wert für randomSeed zu bestimmen, dann wird das folgende Ergebnis entsprechend diesem Seed berechnet. Wenn wir jedoch keinen Seed festlegen, verwendet das Programm standardmäßig die aktuelle Zeit des Systems, um Seed zu generieren. Daher ist das Ergebnis jeder Operation anders. Das folgende Beispiel kann Ihnen helfen, randomSeed besser zu verstehen.

   Beispielcode (5-8):[cceN_cpp theme="dawn"] void setup(){

   Größe (700, 700);

   Hintergrund(0);

   keinStroke();

   }

   Leere zeichnen (){

   zufälliger Samen(1);

   for(int i = 0; i < 10; i ++) {

   float randomWidth01 = random(10, 60);

   Ellipse (zufällig (Breite), zufällig (Höhe), zufällige Breite01, zufällige Breite01);

   println (zufällige Breite01);

   }

   zufälliger Samen(1);

   for(int i = 0; i < 10; i ++) {

   float randomWidth02 = random(10, 60);

   Ellipse (zufällig (Breite), zufällig (Höhe), randomWidth02, randomWidth02);

   println (zufällige Breite02);

   }

   } [/cceN_cpp]

   Versuchen Sie, das zweite randomSeed(1) zu randomSeed(0) zu überarbeiten und vergleichen Sie die Endergebnisse.

   Tipps: In P5 müssen wir die Funktion noLoop nur am Ende des Zeichnens aufrufen, damit wir den gleichen Effekt erzielen. Seine Funktion besteht darin, das Programm zu beenden. Es unterscheidet sich stark von den oben genannten Arbeitsprinzipien in der Natur.

Schritt 5: Verwenden Sie für Loop, um eine Linie zu zeichnen

Nachdem wir die Verwendung von randomSeed gemeistert haben, können wir versuchen, die Zeichenfunktion zu ändern. Ändern Sie beispielsweise die Kreiszeichnung in eine Strichzeichnung. Nur wenn wir einige sich ändernde Vorschriften bis zum Ende der Linie entwerfen, können wir viele Linien ineinander verschlingen, um ein einzigartiges Muster zu erstellen.

Codebeispiel(5-9):

[cceN_cpp theme="dawn"] void setup(){

Größe (700, 700);

Hintergrund(0);

}

Leere zeichnen (){

zufälliger Samen(0);

for(int i = 0; i < 2000; i ++) {

Gleitkomma x1 = Breite/2,0;

Gleitkomma x2 = zufällig (50.0, 650.0);

Schlaganfall (255, 20);

Linie (x1, 50, x2, 650);

}

} [/cceN_cpp]

Erstellen Sie einen einfachen Pinsel

Zurück zur for-Schleife. Die obigen Beispiele sind nicht interaktiv. Wenn wir das Ergebnis interessanter gestalten wollen, dürfen wir nicht vergessen, mouseX und mouseY in unserem Code zu kombinieren.

Codebeispiel (5-10):

[cceN_cpp theme="dawn"] void setup(){

Größe (700, 700);

Hintergrund(255);

keinStroke();

}

Leere zeichnen (){

for(int i = 0; i < 1000; i ++) {

füllen (0, 30);

Float x = MausX + zufällig (-50, 50);

float y = MausY + zufällig (-50, 50);

Ellipse (x, y, 2, 2);

}

} [/cceN_cpp]

Ein Pinsel mit "Streupunkten" wird erstellt. Da jeder intensive Mini-Rundpunkt auf der Position der Maus basiert, kann er begrenzte Richtungen aus den vier Richtungen links, rechts, oben und unten bewegen. Die endgültige Formverteilung des Pinsels ähnelt also einem Quadrat.

Codebeispiel (5-11):

[cceN_cpp theme="dawn"] void setup(){

Größe (700, 700);

Hintergrund(255);

keinStroke();

}

Leere zeichnen (){

for(int i = 0; i < 1000; i ++) {

Float-Verhältnis = MausX/(Float)Breite;

Float x = MausX + zufällig (-50, 50);

float y = MausY + zufällig (-50, 50);

füllen (0, Verhältnis * 255, 255 * (1 - Verhältnis), 30);

Ellipse (x, y, 2, 2);

}

}

[/cceN_cpp]

Wenn wir den Wert von mouseX verwenden, um die Füllfarbe zu beeinflussen, erhalten wir einen viel magischeren Farbverlauf.

Schritt 6: Für Schleife verschachtelt

For-Schleife kann verschachtelt werden. Sie können wieder eine for-Schleife in die for-Schleife schreiben. Wenn Sie eine zweidimensionale Punktmatrix zeichnen müssen, können Sie diese Methode wählen.

Codebeispiel(5-12):

[cceN_cpp theme="dawn"] void setup(){

Größe (700, 700, P2D);

Hintergrund(202, 240, 107);

}

Leere zeichnen (){

füllen(0);

for(int i = 0; i < 5; i ++) {

for(int j = 0;j < 5;j++){

Schwimmer x = 150 + i * 100;

Schwimmer y = 150 + j * 100;

Ellipse (x, y, 60, 60);

println(i + ":" + j);

}

}

}

[/cceN_cpp]

Um die verschachtelte Schleife zum ersten Mal zu verwenden, müssen Sie ihre logischen Beziehungen herausfinden. Die Codeimplementierung im Programm erfolgt immer von oben nach unten. Daher ist die erste implementierte definitiv die äußerste Schleife. Jedes Mal, wenn die äußere Schleife einmal ausgeführt wird, wird die interne Schleife kontinuierlich arbeiten, bis sie die Bedingung nicht mehr erfüllen kann. Danach wird die zweite äußere Schleifenoperation gestartet. Nachdem die zweite Operation gestartet wurde, wird die interne Schleife so lange ausgeführt, bis sie die Bedingung nicht erfüllen kann. Eine solche Wiederholung macht es solange, bis nicht alle Bedingungen erfüllt werden können und es aus der Schleife springt.

Im obigen Code hat der Schleifenkörper in der äußeren Schleife insgesamt 5 Mal gearbeitet, während der Schleifenkörper in der internen Schleife 25 Mal betrieben wurde. Innerhalb von 25 Mal können wir gemäß der Differenz von i, j-Werten die horizontale und vertikale Koordinate des Kreises separat sicherstellen. Ich habe einen Abschnitt von print eingebettet, Sie können die Datenausgabe beobachten und über ihre Veränderung nachdenken. Mit nur zwei verschachtelten Schleifen können wir alle Kombinationen von i-, j-Daten erfahren.

Tipps

For-Schleife in der zweiten Ebene verdichten normalerweise mit Tab am Anfang. Dies kann die Codestruktur klarer machen. Sie müssen lokale Variablen in den beiden Schichten der for-Schleife mit unterschiedlichen Namen benennen. Darunter werden "i", "j", "k" am häufigsten verwendet.

Flexibler Einsatz "i", "j"

Die beiden Variablennamen "i", "j" repräsentieren lokale Variablen der beiden Schichten der for-Schleife. Das folgende Beispiel wird Ihr Verständnis für "i""j" vertiefen. Entsprechend dem unterschiedlichen Wert von "i", "j" können wir Parameter eingeben, um die Elemente zu gruppieren.

Codebeispiel (5-13):[cceN_cpp theme="dawn"] void setup() {

Größe (700, 700);

Hintergrund(0);

keinStroke();

}

Leere zeichnen () {

Hintergrund(0);

füllen (250, 233, 77);

für (int i = 0; i < 7; i ++) {

für (int j = 0; j < 7; j++) {

pushMatrix();

übersetzen (50 + i * 100, 50 + j * 100);

// Einstellung 1

// Schwimmwinkel = sin (millis () / 1000,0) * PI/2;

// Einstellung 2

// Schwimmerverhältnis = i/7,0;

// Schwimmwinkel = sin (millis () / 1000.0 + Verhältnis * (PI/2)) * PI/2;

// Einstellung 3

Schwimmerverhältnis = (i * 7 + j)/49,0;

Schwimmwinkel = sin(millis() / 1000.0 + Verhältnis * (PI/2)) * PI/2;

drehen (Winkel);

rectMode (MITTE);

// Bild zeichnen 1

gleich (0, 0, 80, 80);

// Bild zeichnen 2

// Rect (0, 0, 100, 20);

// Bild zeichnen 3

//Rechteck (0, 0, Verhältnis * 50);

popMatrix();

}

}

} [/cceN_cpp]

Code-Erklärung

rectMode(CENTER) kann die Zeichenmethode des Quadrats ändern. Die ursprünglichen beiden Parameter von rect werden verwendet, um die Koordinate der linken oberen Ecke des Quadrats zu definieren. Nachdem wir diesen Befehl gestartet haben, werden diese beiden Parameter verwendet, um die Koordinaten für den quadratischen Mittelpunkt festzulegen. Da wir hier die Musterrotation durch Rotieren betreiben, müssen wir diese Methode verwenden, um den Mittelpunkt auf den ursprünglichen Punkt der Koordinate zu ziehen.

millis() erfasst die Zeit vom Programmstart bis zur Gegenwart. Die Einheit ist ms. Dieser Wert beeinflusst die Änderungsgeschwindigkeit des Sinus-Ausgangswerts. Wenn wir Millis direkt schreiben, ist die Änderungsskala zu groß. Daher müssen wir es durch 1000.0 dividieren.

In diesem Codeabschnitt verwenden wir das Kommentarsymbol "//", um verschiedene Einstellungen auszublenden. Sie können Effekte nach Start oder Ende verschieben. Wenn wir beispielsweise Sätze hinter "Einstellung 3" beginnen, müssen wir das Kommentarsymbol verwenden, um Codeblöcke hinter "Einstellung 1" und "Einstellung 2" zu schließen. Beispiele für diese ähnliche Programmstruktur mit verschiedenen lokalen Variablen können wir in diesem Format schreiben. So müssen wir nicht mehrere Engineering-Dokumente separat speichern. Wir können diese Fertigkeit oft während des Übens und der Erstellung verwenden und einige zufriedenstellende Parametereinstellungen beibehalten.

Darunter wird der Einfluss des i-, j-Wertes auf das Programm hauptsächlich durch das Verschieben von "Einstellung 1 (Einstellung 2) (Einstellung 3)" dargestellt. Sie können die Ausgabeergebnisse unten vergleichen.

Bild 1 zeichnen: Einstellung 1

Bild 1 zeichnen: Einstellung 2

Bild 1 zeichnen: Einstellung 3

Bild zeichnen 2: Einstellung 1

Bild zeichnen 2: Einstellung 2

Bild zeichnen 2: Einstellung 3

In Einstellung 1 haben wir i und j nicht verwendet, um den Drehwinkel jedes Elements zu beeinflussen. So können wir sehen, dass die Bewegung jedes Elements gleich ist. In Einstellung 2 haben wir den i-Wert und in Einstellung 3 sowohl i als auch j verwendet. Schließlich haben sie die Parametereingabe der Funktion sin through ratio beeinflusst. Dies hat die periodische Winkeländerung geändert. Da die tatsächliche Wirkung von Einstellung 2 und Einstellung 3 in den animierten Grafiken nicht so offensichtlich ist, können wir dies anhand des folgenden Screenshots beobachten.

Bild 2 zeichnen (Links: Einstellung 2; Rechts: Einstellung 3)

Bild 3 zeichnen (Links: Einstellung 2; Rechts: Einstellung 3)

Im ersten Bild wird das Verhältnis verwendet, um den quadratischen Drehwinkel zu beeinflussen. Beim zweiten Bild wird der Radius des Kreises direkt gesteuert. Wir können sehen, dass es einen i-Wert-Satz verwendet hat:

Schwimmerverhältnis = i/7,0;

Die Änderung des Scheitelelements ist konsistent. Da die horizontale Koordinate zum Steuern des Bildes nur vom Wert von i abhängt, sind Muster mit derselben horizontalen Koordinate gleich. Und der Wert von Verhältnis, Drehwinkel und Kreisradius ist auch gleich.

Gleichzeitig verwenden wir den Satz i, j:

Schwimmerverhältnis = (i * 7 + j)/49,0;

Es kann "Gradient" beschreiben. Hier hat es mit der Methode der Faktormultiplikation den Einfluss von Zeilen und Spalten kombiniert. Jedes Element ist also anders.

Schritt 7: Während Schleife

Es gibt einen Bruder für die for-Schleife. Das ist eine while-Schleife. Was for loop tun kann, während loop es auch kann. Die Verwendungshäufigkeit der while-Schleife in creativeCoding ist jedoch nicht so hoch wie bei der for-Schleife.

Codebeispiel (5-14):[cceN_cpp theme="dawn"] void setup(){

int a = 0;

während(a < 10){

println(a);

a++;

}

} [/cceN_cpp]

Die Grammatikstruktur von while ist leichter zu verstehen als von. Wir können Variablen vor einer while-Anweisung erstellen. Geben Sie dann einen Ausdruck in eckigen Klammern ein. Wenn es erfüllt ist, dann operiere die Sätze innerhalb des Schleifenkörpers. Schließlich fügen wir einen Ausdruck in den Schleifenkörper ein, um die Variablen zu aktualisieren, dann ist die Schleife beendet. Was die zugesicherten Schleifenzeiten angeht, verwenden wir oft for loop. Was den unbestimmten Variablenwert betrifft, empfehlen wir Ihnen die Verwendung von while loop.

Denken:

Versuchen Sie, alle Arten von Grundelementen zu verwenden, um Zeichenelemente in einer for-Schleife zu ersetzen, um verschiedene verschiedene Pinsel zu erstellen.

Kombinieren Sie mit der trigonometrischen Funktion, auf die im letzten Kapitel Bezug genommen wurde, und versuchen Sie, den Pinsel "Streupunkte" in einen runden Pinsel umzuwandeln.

Versuchen Sie, eine zweidimensionale Punktmatrix nur mit einer for-Schleife zu erstellen.

Nächste KapitelvorschauWie bei diesem Kurs finden Sie jedes neue Wissen, das Sie lernen, die Möglichkeit des Spielens wird sofort um ein Vielfaches erhöht. Programm ist eine Pandora-Box. Alles, was Sie sich vorstellen können, kann es für Sie tun. Es gibt also keinen Grund, diese Sprache, die mit Computern kommunizieren kann, nicht zu lernen. In unserem nächsten Kapitel stellen wir Ihnen eine weitere Anweisung zur Prozesssteuerung vor. Es kann den Prozessfluss steuern und kompliziertere und veränderbare Ergebnisse erzeugen. Mit der if-Anweisung können Sie ganz einfach Ihre eigenen Text-Adventure-Spiele erstellen!Dieser Artikel stammt vom Designer Wenzy. Relative Readings:Interessante Programmieranleitung für Designer – Verarbeitung der ersten BerührungInteressante Programmieranleitung für Designer – Erstellen Sie Ihr erstes VerarbeitungsprogrammInteressante Programmieranleitung für Designer –Lassen Sie Ihr Bild laufen (Teil 1) Interessante Programmieranleitung für Designer – Bringen Sie Ihr Bild zum Laufen (Teil 2)

Schritt 8: Quelle

Dieser Artikel ist von:

Bei Fragen wenden Sie sich bitte an: [email protected].