Guide de programmation intéressant pour le concepteur - Contrôle du processus de programme - Déclaration de boucle : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:10

Contrôle du processus du programme - instruction de boucle

À partir de ce chapitre, vous entrerez en contact avec un énoncé de boucle de point de connaissance important et puissant.

Avant de lire ce chapitre, si vous voulez dessiner 10 000 cercles dans le programme, vous ne pouvez le faire qu'avec une méthode terrible. C'est-à-dire écrire 10 000 lignes de code ellipse. Ces concepteurs de code paresseux qui veulent améliorer l'efficacité par tous les moyens, ne permettraient certainement pas que cela se produise. Ainsi, l'instruction de boucle est créée. Avec cette déclaration, vous pouvez intuitivement ressentir la puissance de l'automatisation informatique.

Étape 1: boucle For

Il existe de nombreuses instructions de boucle, parmi lesquelles la plus utilisée est For Loop. Nous savons tous que la fonction tirage est continuellement en circulation. Commencez par la première phrase au début, il s'appliquera de haut en bas jusqu'à la dernière phrase. Après avoir terminé une opération, il recommencera à partir de la première phrase. L'instruction For est un peu similaire à la fonction draw. Le code dans l'instruction for peut être exécuté à plusieurs reprises.

Voici sa structure grammaticale:

Pour(expression 1; expression 2; expression 3){

Corps de boucle

}

De toute évidence, les phrases dans le corps de la boucle sont ce que nous nous attendions à ce qu'elles soient implémentées à plusieurs reprises. L'expression 1 est utilisée pour initialiser et affecter la première valeur à la variable de boucle. L'expression 2 est pour la condition de boucle. L'expression 3 mettra à jour la valeur de la variable de boucle.

Qu'est-ce qu'une variable de boucle ? C'est en fait l'équivalent d'une variable locale. Jetons un coup d'oeil à une écriture complète.

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

Corps de boucle

}

Afin de réaliser la fonction de boucle, l'instruction for repose principalement sur une variable locale, qui sera utilisée à la fin de la boucle. La variable locale dans l'exemple ci-dessus est i. L'expression 1 a terminé l'initialisation de la variable locale. Plus tard, chaque fois que la boucle fonctionne pour une fois, cette variable doit être mise à jour. Parmi l'exemple ci-dessus, i++ dans l'expression 3 est utilisé pour réaliser la fonction de mise à jour. Grâce à elle, la variable augmentera de 1 à chaque mise à jour. En fin de compte, le code dans le corps de la boucle ne peut pas boucler indéfiniment, sinon ces dernières instructions ne peuvent pas être exécutées. Ainsi, nous avons besoin d'une condition terminale. Express 2 est fait pour ça. Ici, le programme jugera si i est inférieur à 10. Si c'est le cas, continuez à fonctionner. Si ce n'est pas le cas, sortez de la boucle.

Par conséquent, la séquence d'opérations de l'instruction for est exactement comme ceci.

Expression 1 (initialisation de la variable locale)

Expression 2 (satisfait, puis continuer à fonctionner)

Corps en boucle (Première circulation)

Expression 3 (Mise à jour)

Expression 2 (satisfait, puis continuer à fonctionner)

Corps de boucle (deuxième circulation)

Expression 3 (Mise à jour)

Expression 2 (satisfait, puis continuer à fonctionner)

Corps en boucle (troisième circulation) …

Expression 3 (Mise à jour)

Expression 2 (pas satisfait, puis sautez hors de la boucle)

Vous pouvez simuler cette séquence d'exécution dans votre tête plusieurs fois. Mais il est impossible de vraiment comprendre le code sans le taper à la main pour une fois. Lorsque nous voulons découvrir un concept étrange, nous pouvons imprimer la valeur dans la console via l'instruction println.

Exemple de code (5-1): void setup(){

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

println ("exécuter");

}

}

Vous pouvez compter le nombre de sorties d'exécution dans la console. Ici, c'est exactement 10. Cela vous indique combien de fois le code dans le corps de la boucle a été exécuté. Cependant, nous ne pouvons toujours pas détecter les changements qui se sont réellement produits dans la boucle. Nous pouvons donc essayer de changer le caractère "run into variable "i", et voir ce qui va se passer.

Exemple de code (5-2): void setup(){

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

println (i);

}

}

Maintenant, nous pouvons voir que la valeur i dans le corps de la boucle augmente continuellement. Plus tard, nous pouvons utiliser cette valeur pour comprendre le processus actuel de la boucle.

Dans l'exemple de code (5-2), la valeur de i passe de 0 à 9. Par rapport aux temps de boucle réels, il semble toujours avoir 1 de moins. Si vous n'y êtes pas habitué, l'expression entre crochets de l'instruction for peut être écrite comme suit:

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

Ainsi, i correspond à juste titre aux temps de boucle. La signification de "<＝" est inférieure et égale à. Ainsi, lorsque i est égal à 10, il répondra toujours à la condition. Par conséquent, il fonctionnera à nouveau par rapport à l'écriture dans i < 10. Bien qu'il commence à partir de 1, les temps de boucle sont toujours de 10. Bien sûr, si rien de spécial n'est nécessaire, je voudrais vous suggérer d'adopter la méthode d'écriture dans le exemple au début. Plus tard, nous vous présenterons le vecteur ou le tableau, qui obtiennent tous deux son élément par son indice. Et les indices par défaut commencent tous à partir de 0. Définir la valeur initiale à 0 est la pratique relativement courante.

Dans l'exemple ci-dessus, si nous écrivons que i est au-delà de 0, le programme plantera. Parce que la variable est constamment croissante, elle ne satisfera jamais cette condition. C'est comme s'il ne pouvait jamais être arrêté pour que le programme s'exécute en boucle sans fin.

Les variables locales dans l'instruction for peuvent non seulement déclarer des types plastiques, mais également déclarer des variables dans des types à virgule flottante. Par exemple, il peut être écrit comme (float i = 0; i <10; i + = 0,02).

Étape 2: Utilisez la boucle for pour résoudre des problèmes mathématiques

Vous souvenez-vous encore d'une histoire du mathématicien Gauss dans son enfance ? A cette époque, Guass avait 10 ans. Son professeur voulait assigner une tâche à la classe et la question était

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

Si vous calculez avec vos mains, cela vous prendra beaucoup de temps. Mais Guass semble avoir déjà compris la méthode de sommation de la séquence arithmétique. Ainsi, juste après que la question soit posée, il prononça la réponse avec aisance, ce qui avait grandement surpris son professeur.

Maintenant, nous ne nous souvenons peut-être pas encore de la somme de la séquence arithmétique, mais nous pouvons obtenir la réponse de manière primitive et violente. Et c'est pour la boucle. Étant donné que ce n'est qu'un petit morceau de gâteau pour que les ordinateurs comptent, nous devons décrire la question dans un langage qui peut être reconnu par l'ordinateur, puis nous pouvons facilement obtenir notre réponse.

Exemple de code (5-3):

void setup(){

réponse int = 0;

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

réponse += je;

}

println(réponse);

}

Je crois que le résultat que vous obtenez est le même que la réponse signalée par Guass: c'est 5050 !

Astuces: Le nom des variables locales dans la boucle for peut être modifié à volonté à condition de respecter les règles de nommage des variables. Vous pouvez l'écrire sous la forme (int k = 1;k <= 100;k++). Si aucune condition particulière ne s'est produite, la valeur par défaut est i comme nom de la variable.

Étape 3: Pour le dessin en boucle

Après une série de literie apparemment ennuyeuse, nous pouvons enfin entrer dans une section plus intéressante. C'est à utiliser pour la boucle pour dessiner des images. Nous pouvons mettre de côté ces calculs mathématiques fastidieux maintenant. Nous, les designers, sommes plus sensibles aux graphismes.

Utiliser la boucle For pour dessiner un tableau circulaire

Lorsque nous voulons utiliser la boucle for pour représenter un groupe d'éléments répétés, nous devons nous assurer au préalable de la relation numérique de ces éléments, puis nous pouvons utiliser la boucle for pour le réaliser facilement au lieu de faire un travail de répétition massif. Supposons que nous voulions dessiner une rangée de cercles également répartis dans la direction horizontale. Sa coordonnée virtuelle est inchangée tandis que sa coordonnée horizontale est modifiée. Et de gauche à droite, la coordonnée horizontale augmente constamment et la distance croissante est la même. À ce stade, nous pouvons utiliser i dans la boucle for pour obtenir la coordonnée horizontale de chaque cercle.

Exemple de code (5-4): void setup(){

taille (700, 700);

arrière-plan (83, 51, 194);

noStroke();

}

tirage nul (){

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

ellipse (50,0 + i * 100,0, hauteur/2,0, 80,0, 80,0);

}

}

50 représente la position de départ du premier cercle à gauche. 100 en i * 100 représente la distance croissante.

Étape 4: Utilisez la boucle for pour dessiner un point rond aléatoire

La position graphique ci-dessus est prévisible. Cela minimisera beaucoup d'intérêt. Nous pouvons utiliser la fonction random dont nous avons parlé dans le chapitre précédent et essayer de l'écrire dans la fonction de dessin.

Exemple de code (5-5):

void setup(){

taille (700, 700);

arrière-plan(0);

noStroke();

}

tirage nul (){

arrière-plan(0);

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

float randomWidth = random (60.0);

ellipse(aléatoire(largeur), aléatoire(hauteur), aléatoireLargeur, aléatoireLargeur);

}

}

Ici, la raison pour laquelle la position du cercle clignote en permanence est que chaque fois que la fonction aléatoire fonctionne pour une fois, le résultat est aléatoire. Parce que la fonction draw est définie par défaut pour exécuter 60 images par seconde, donc tous les 10 cercles dessinés en une seconde changeront de position 60 fois. Ce flash rapide fait que l'image semble avoir plus de 10 cercles. Changer une simple valeur dans le programme vous apportera un effet totalement différent. Nous pouvons modifier les temps de boucle en révisant la condition terminale. La condition terminale dans l'image ci-dessous est i < 100

1. Voici l'effet lorsque la condition terminale est i < 1000:
2. AléatoireSeed
3. Si je ne veux pas que la position du cercle soit générée aléatoirement ainsi que son flash, que puis-je faire ? Une méthode consiste à créer et à stocker des variables indépendantes pour chaque cercle et à initialiser ces variables dans la configuration. Attribuez à ces variables une valeur aléatoire. Ainsi, lors de l'utilisation de la fonction de dessin dans draw, ce que nous avons invoqué est la valeur stockée dans variables. Cela ne changera à aucun moment. Pour dessiner 10 cercles, nous pouvons simplement utiliser cette méthode. Mais que se passe-t-il si nous voulons dessiner 1000 cercles, ou 10 000 cercles ? Ce sera assez gênant si nous utilisons cette méthode traditionnelle pour construire ces variables et les nommer. Nous n'avons pas besoin d'apprendre une nouvelle méthode de construction de variables. Voici une méthode flexible qui peut nous aider à atteindre cet objectif. C'est-à-dire utiliser randomSeed. Voyons maintenant son effet après utilisation. Exemple de code (5-6):[cceN_cpp theme="dawn"] void setup(){ size(700, 700); background(0);noStroke();}

4. tirage nul (){

   arrière-plan(0);

   graine aléatoire(1);

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

   float randomWidth = random(20.0, 60.0);

   ellipse(aléatoire(largeur), aléatoire(hauteur), aléatoireLargeur, aléatoireLargeur);

   }

   } [/cceN_cpp]

   Par rapport au code précédent, il n'a aucun changement, à l'exception de la modification de la plage de rayon du cercle de 10 à au-delà de 30 avec une phrase ofSeedRandom uniquement. Après avoir ajouté cette phrase, le graphique semble devenir statique.

   Format d'appel:

   randomSeed(a);

   Parmi ce format, le paramètre de a est une graine. Vous devez remplir un entier (écrivez une valeur à virgule flottante dans P5, cela ne se trompera pas mais traitez-le comme un entier) dedans. La fonction de randomSeed est de définir la graine pour une valeur aléatoire. Ensuite, il générera différents tableaux aléatoires en fonction de différentes graines. Après cela, nous invoquons la fonction random pour que le résultat du retour soit défini. Ici, le défini n'est pas pour le résultat est une valeur définie mais pour le tableau généré. C'est-à-dire que le résultat du retour est défini par rapport aux temps d'invocation.

   Exemple de code (5-7):[cceN_cpp theme="dawn"] void setup(){

   graine aléatoire(0);

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

   println(aléatoire(10));

   }

   } [/cceN_cpp]

   Maintenant, nous continuons à utiliser println pour faire une expérience. Après avoir utilisé randomSeed, chaque fois que vous fermez le programme et redémarrez le programme, il reviendra à une chaîne de même résultat. La valeur correspondra à la séquence un par un. Si vous le supprimez, il reviendra à chaque fois à une valeur différente. Pourquoi a-t-il ce paramètre ? C'est parce que la valeur aléatoire elle-même dans le programme est pseudo-aléatoire. Le résultat semble aléatoire mais en réalité il est généré par une méthode de calcul fixe et répétable. Cela équivaut à désigner une valeur primitive pour randomSeed, puis le résultat suivant sera calculé en fonction de cette graine. Cependant, si nous ne désignons pas la graine, le programme utilisera par défaut l'heure actuelle du système pour générer la graine. Par conséquent, le résultat de chaque opération est différent. L'exemple ci-dessous peut vous aider à mieux comprendre randomSeed.

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

   taille (700, 700);

   arrière-plan(0);

   noStroke();

   }

   tirage nul (){

   graine aléatoire(1);

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

   float randomWidth01 = random(10, 60);

   ellipse(aléatoire(largeur), aléatoire(hauteur), aléatoireLargeur01, aléatoireLargeur01);

   println(randomWidth01);

   }

   graine aléatoire(1);

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

   float randomWidth02 = random(10, 60);

   ellipse(aléatoire(largeur), aléatoire(hauteur), aléatoireLargeur02, aléatoireLargeur02);

   println(randomWidth02);

   }

   } [/cceN_cpp]

   Essayez de réviser le deuxième randomSeed(1) en randomSeed(0) et comparez les résultats finaux.

   Astuces: Dans P5, nous n'avons qu'à invoquer la fonction noLoop à la fin du dessin pour obtenir le même effet. Sa fonction est de terminer le programme. Il est assez différent des principes de travail ci-dessus dans la nature.

Étape 5: Utilisez la boucle pour tracer une ligne

Après avoir maîtrisé l'utilisation de randomSeed, nous pouvons essayer de changer la fonction de dessin. Par exemple, changez le dessin du cercle en dessin au trait. Ce n'est que si nous concevons des réglementations changeantes jusqu'à la fin de la ligne que nous pouvons utiliser beaucoup de lignes entrelacées pour créer un motif unique.

Exemple de code (5-9):

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

taille (700, 700);

arrière-plan(0);

}

tirage nul (){

graine aléatoire(0);

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

float x1 = largeur/2,0;

flottant x2 = aléatoire (50,0, 650,0);

course (255, 20);

ligne(x1, 50, x2, 650);

}

} [/cceN_cpp]

Créer un pinceau simple

Retour à la boucle for à nouveau. Les exemples ci-dessus ne sont pas interactifs. Si nous voulons rendre le résultat plus intéressant, nous ne pouvons pas oublier de combiner mouseX et mouseY dans notre code.

Exemple de code (5-10):

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

taille (700, 700);

arrière-plan (255);

noStroke();

}

tirage nul (){

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

remplir (0, 30);

float x = mouseX + random(-50, 50);

float y = mouseY + random(-50, 50);

ellipse(x, y, 2, 2);

}

} [/cceN_cpp]

Un pinceau "points de diffusion" est créé. Parce que chaque mini-point rond intensif est basé sur la position de la souris, il peut se déplacer dans des directions limitées à partir des quatre directions gauche, droite, haut et bas. Ainsi, la forme finale de la brosse est semblable à un carré.

Exemple de code (5-11):

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

taille (700, 700);

arrière-plan (255);

noStroke();

}

tirage nul (){

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

rapport flottant = mouseX/(float)width;

float x = mouseX + random(-50, 50);

float y = mouseY + random(-50, 50);

remplissage (0, rapport * 255, 255 * (1 - rapport), 30);

ellipse(x, y, 2, 2);

}

}

[/cceN_cpp]

Si nous utilisons la valeur de mouseX pour affecter la couleur de remplissage, nous obtiendrons un dégradé de couleurs beaucoup plus magique.

Étape 6: pour la boucle imbriquée

La boucle For peut être imbriquée. Vous pouvez réécrire une boucle for dans la boucle for. Lorsque vous devez dessiner une matrice de points à deux dimensions, vous pouvez choisir cette méthode.

Exemple de code (5-12):

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

taille (700, 700, P2D);

arrière-plan (202, 240, 107);

}

tirage nul (){

remplir(0);

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

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

flottant x = 150 + i * 100;

flottant y = 150 + j * 100;

ellipse(x, y, 60, 60);

println(i + ":" + j);

}

}

}

[/cceN_cpp]

Pour utiliser la boucle imbriquée pour la première fois, vous devez comprendre ses relations logiques. L'implémentation du code dans le programme se fait toujours de haut en bas. Par conséquent, la première boucle implémentée est certainement la boucle la plus éloignée. Chaque fois que la boucle externe fonctionne pour une fois, la boucle interne fonctionnera en continu jusqu'à ce qu'elle ne puisse plus satisfaire la condition. Après cela, il commencera la deuxième opération de boucle externe. Après le début de la deuxième opération, la boucle interne passera à l'outil jusqu'à ce qu'elle ne puisse plus satisfaire la condition. Une telle répétition qu'il fait jusqu'à ce que toutes les conditions ne puissent pas être satisfaites et il saute hors de la boucle.

Dans le code ci-dessus, le corps de boucle de la boucle externe a fonctionné 5 fois au total, tandis que le corps de boucle de la boucle interne a fonctionné 25 fois. Dans les 25 fois, selon la différence des valeurs i, j, nous pouvons assurer séparément les coordonnées horizontales et verticales du cercle. J'ai intégré une section d'impression, vous pouvez observer la sortie des données et réfléchir à son changement. Avec seulement deux boucles imbriquées, nous pouvons expérimenter toutes les combinaisons de données i, j.

Des astuces

La boucle For dans la deuxième couche se condense généralement avec Tab au début. Cela peut rendre la structure du code plus claire. Vous devez nommer les variables locales dans les deux couches de la boucle for avec des noms différents. Parmi ceux-ci, "i", "j", "k" est le plus couramment utilisé.

Utilisation flexible "i", "j"

Les deux noms de variables "i", "j" représentent les variables locales des deux couches de la boucle for. L'exemple ci-dessous approfondira votre compréhension de "i" "j". Selon la valeur différente de "i", "j", nous pouvons entrer des paramètres pour regrouper les éléments.

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

taille (700, 700);

arrière-plan(0);

noStroke();

}

tirage nul () {

arrière-plan(0);

remplir (250, 233, 77);

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

pour (int j = 0; j < 7; j++) {

pushMatrix();

traduire (50 + i * 100, 50 + j * 100);

// Réglage 1

//angle flottant = sin(millis() / 1000.0) * PI/2;

// Réglage 2

//rapport flottant = i/7,0;

//angle flottant = sin(millis() / 1000.0 + ratio * (PI/2)) * PI/2;

// Réglage 3

rapport flottant = (i * 7 + j)/49,0;

angle flottant = sin(millis() / 1000.0 + ratio * (PI/2)) * PI/2;

tourner (angle);

rectMode(CENTRE);

// Dessine l'image 1

rect(0, 0, 80, 80);

// Dessine l'image 2

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

// Dessine l'image 3

//rect(0, 0, rapport * 50);

popMatrice();

}

}

} [/cceN_cpp]

Explication du code

rectMode(CENTER) peut changer la méthode de dessin du carré. Les deux premiers paramètres de rect sont utilisés pour définir la coordonnée du coin supérieur gauche de la place. Après avoir lancé cette commande, ces deux paramètres seront utilisés pour définir les coordonnées du point central du carré. Parce qu'ici, nous opérons la rotation du motif par rotation, nous devons donc utiliser cette méthode pour dessiner le point central jusqu'au point d'origine de la coordonnée.

millis () acquiert le temps entre le début du programme et le présent. L'unité est la ms. Cette valeur influencera la vitesse de changement de la valeur de sortie sin. Si nous écrivons les millis directement, l'échelle de changement est trop grande. Ainsi, nous devons le diviser par 1000,0.

Dans cette section de code, nous utilisons le symbole de commentaire "//" pour masquer plusieurs paramètres. Vous pouvez changer les effets en commençant ou en fermant. Par exemple, si nous commençons des phrases derrière "Paramètre 3", nous devons utiliser le symbole de commentaire pour fermer les blocs de code derrière "Paramètre 1" et "Paramètre 2". En ce qui concerne les exemples de cette structure de programme similaire avec différentes variables locales, nous pouvons écrire dans ce format. Ainsi, nous n'avons pas à stocker séparément plusieurs documents d'ingénierie. Nous pouvons utiliser cette compétence souvent pendant la pratique et la création et conserver certains réglages de paramètres satisfaisants.

Parmi ceux-ci, l'influence de la valeur i, j sur le programme est principalement représentée par le décalage du "Réglage 1 (Réglage 2) (Réglage 3)". Vous pouvez comparer les résultats de sortie ci-dessous.

Dessinez l'image 1: Réglage 1

Dessinez l'image 1: Réglage 2

Dessinez l'image 1: Réglage 3

Dessinez l'image 2: Réglage 1

Dessinez l'image 2: Réglage 2

Dessinez l'image 2: Réglage 3

Dans le réglage 1, nous n'avons pas utilisé i et j pour influencer l'angle de rotation de chaque élément. Ainsi, nous pouvons voir que le mouvement de chaque élément est le même. Alors que dans le réglage 2, nous avons utilisé la valeur i et à la fois i et j dans le réglage 3. Enfin, ils ont influencé l'entrée des paramètres de la fonction sin through ratio. Cela a changé le changement périodique d'angle. Étant donné que l'effet réel du réglage 2 et du réglage 3 n'est pas si évident dans les graphiques animés, nous pouvons l'observer à partir de la capture d'écran suivante.

Dessinez l'image 2 (gauche: réglage 2; droite: réglage 3)

Dessinez l'image 3 (gauche: réglage 2; droite: réglage 3)

Dans la première image, le ratio est utilisé pour affecter l'angle de rotation du carré. Alors que la deuxième image, il est ised de contrôler le rayon du cercle directement. Nous pouvons voir qu'il a utilisé i value phrase:

rapport flottant = i/7,0;

Son changement d'élément vertical est consistant. Parce que la coordonnée horizontale pour contrôler l'image ne dépend que de la valeur de i, donc les motifs avec la même coordonnée horizontale seront les mêmes. Et la valeur du rapport, de l'angle de rotation et du rayon du cercle est également la même.

En même temps, on utilise la phrase i, j:

rapport flottant = (i * 7 + j)/49,0;

Il peut décrire "gradient". Ici, avec la méthode de multiplication d'un facteur, il a combiné l'influence des lignes et des colonnes. Donc chaque élément est différent.

Étape 7: Boucle While

Il y a un frère pour la boucle. C'est en boucle. Ce que for loop peut faire, tandis que loop peut le faire aussi. Mais la fréquence d'utilisation de la boucle while dans creativeCoding n'est pas élevée par rapport à la boucle for.

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

un entier = 0;

tandis que(a < 10){

println(a);

a++;

}

} [/cceN_cpp]

La structure grammaticale de while est plus facile à comprendre que for. Nous pouvons créer des variables avant l'instruction while. Ensuite, remplissez une expression entre crochets. Lorsqu'il est satisfait, utilisez les phrases dans le corps de la boucle. Enfin, nous mettons une expression dans le corps de la boucle pour mettre à jour les variables, puis la boucle while est terminée. En ce qui concerne les temps de boucle assurés, nous utilisons souvent la boucle for. En ce qui concerne la valeur de variable indéfinie, nous vous recommandons d'utiliser la boucle while.

Pense:

Essayez d'utiliser toutes sortes d'éléments de base pour remplacer les éléments de dessin dans la boucle for afin de créer différents pinceaux.

Combinez avec la fonction trigonométrique mentionnée dans le dernier chapitre, essayez de réviser le pinceau "points de diffusion" en pinceau de forme ronde.

Essayez de créer une matrice de points à deux dimensions avec une boucle for uniquement.

Aperçu du chapitre suivantComme avec ce cours, vous trouverez toutes les nouvelles connaissances que vous apprenez, la possibilité de jouer sera immédiatement augmentée. Le programme est une boîte pandora. Tout ce que vous pouvez imaginer, il peut le faire pour vous. Il n'y a donc aucune raison pour que nous n'apprenions pas cette langue qui peut communiquer avec les ordinateurs. Dans notre prochain chapitre, nous vous présenterons une autre instruction de contrôle de processus. Il peut contrôler le flux de processus et générer des résultats plus complexes et modifiables. Avec la déclaration if, vous pouvez créer facilement vos propres jeux d'aventure textuels ! Cet article provient du concepteur Wenzy. – Faites fonctionner votre image (première partie) Guide de programmation intéressant pour le concepteur – Faites fonctionner votre image (deuxième partie)

Étape 8: Source

Cet article provient de:

Si vous avez des questions, vous pouvez contacter： [email protected].