הדרכת תכנות מעניינת למעצב-בקרת תהליכי התוכנית- הצהרת לולאה: 8 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:17

בקרת תהליך התוכנית- הצהרת לולאה

מפרק זה, תיצור קשר עם הצהרת נקודת ידע חשובה ורבת עוצמה.

לפני קריאת פרק זה, אם אתה רוצה לצייר 10, 000 מעגלים בתוכנית, אתה יכול לעשות רק בשיטה איומה. כלומר לכתוב 10, 000 שורות של קוד אליפסה. אותם מעצבי קוד עצלנים שרוצים לשפר את היעילות בכל האמצעים, בהחלט לא היו מאפשרים לזה לקרות. אז נוצרת הצהרת לולאה. עם אמירה זו, אתה יכול לחוש באופן אינטואיטיבי את העוצמה של אוטומציה ממוחשבת.

שלב 1: ללולאה

יש הרבה הצהרות לולאה, ביניהן הנפוץ ביותר הוא For Loop. כולנו יודעים ש- function draw פועל באופן רציף במחזור. התחל מהמשפט הראשון בהתחלה, הוא יושם מלמעלה למטה עד המשפט האחרון. לאחר סיום הפעולה, הוא יתחיל מחדש מהמשפט הראשון. כי הצהרה קצת דומה לתפקוד צייר. ניתן לבצע קוד בתוך להצהרה שוב ושוב.

להלן מבנה הדקדוק שלה:

עבור (ביטוי 1; ביטוי 2; ביטוי 3) {

גוף לולאה

}

ברור, משפטים בתוך גוף הלולאה הם מה שציפינו שיושמו שוב ושוב. ביטוי 1 משמש לאתחול והקצאת הערך הראשון למשתנה לולאה. ביטוי 2 מיועד למצב לולאה. ביטוי 3 יעדכן את ערך משתנה הלולאה.

מהו משתנה לולאה? זה למעשה שווה ערך למשתנה מקומי. בואו נסתכל על כתיבה שלמה.

עבור (int i = 0; i <10; i ++) {

גוף לולאה

}

על מנת לממש את פונקציית הלולאה, הצהרה מסתמכת בעיקר על משתנה מקומי, שישמש בסיום הלולאה. המשתנה המקומי בדוגמה שלמעלה הוא i. ביטוי 1 השלים אתחול המשתנה המקומי. מאוחר יותר, בכל פעם שהלולאה פועלת פעם אחת, יש לעדכן את המשתנה הזה. בין הדוגמה לעיל, i ++ בביטוי 3 משמש למימוש פונקציית העדכון. באמצעותו, המשתנה יגדל 1 בכל פעם שהוא מתעדכן. בסופו של דבר, הקוד בתוך גוף הלולאה אינו יכול ללולאה ללא הגבלת זמן, אחרת לא ניתן לבצע את ההצהרות האחרונות. לפיכך, אנו זקוקים למצב סופי. Express 2 הוא בדיוק בשביל זה. כאן, התוכנית תשפוט אם i פחות מ- 10. אם כן, המשך לפעול. אם זה לא זה, אז קפוץ מהלולאה.

לכן, רצף הפעולות של הצהרה הוא בדיוק כך.

ביטוי 1 (אתחול משתנה מקומי)

ביטוי 2 (מרוצה, ולאחר מכן המשך לפעול)

גוף לולאה (מחזור ראשון)

ביטוי 3 (עדכון)

ביטוי 2 (מרוצה, ולאחר מכן המשך לפעול)

גוף לולאה (סיבוב שני)

ביטוי 3 (עדכון)

ביטוי 2 (מרוצה, ולאחר מכן המשך לפעול)

גוף לולאה (מחזור שלישי) …

ביטוי 3 (עדכון)

ביטוי 2 (לא מרוצה, ואז קפוץ מהלולאה)

אתה יכול לדמות את רצף הביצוע הזה בראש שלך מספר פעמים. אבל אי אפשר באמת להבין את הקוד מבלי להקליד אותו ביד אחת. כאשר אנו רוצים לברר מושג מוזר, אנו יכולים להדפיס את הערך במסוף באמצעות הצהרת ההדפסה.

דוגמה לקוד (5-1): הגדרת void () {

עבור (int i = 0; i <10; i ++) {

println ("הפעלה");

}

}

אתה יכול לספור את מספר פלט ההפעלה במסוף. כאן הוא בדיוק 10. זה אומר לך כמה פעמים קוד בגוף הלולאה הוצא להורג. עם זאת, עדיין איננו יכולים לזהות אילו שינויים התרחשו בפועל בלולאה. אז נוכל לשנות את התו "להיתקל במשתנה" i ", ולראות מה יקרה.

דוגמה לקוד (5-2): הגדרת void () {

עבור (int i = 0; i <10; i ++) {

println (i);

}

}

כעת, אנו יכולים לראות את הערך i בגוף הלולאה עולה בהתמדה. מאוחר יותר, אנו יכולים להשתמש בערך זה כדי להבין את התהליך הנוכחי של הלולאה.

בדוגמא קוד (5-2), הערך של i משתנה מ- 0 ל- 9. בהשוואה לזמני הלולאה בפועל, נראה כי תמיד יש לו 1 פחות. אם אינך מתרגל לכך, ניתן לכתוב את הביטוי בתוך סוגר של הצהרה לפי הדברים הבאים:

עבור (int i = 1; i <＝ 10; i ++)

לפיכך, אני מתאים בצדק לזמני הלולאה. המשמעות של "<＝" פחותה ומשווה ל. אז כשאני שווה ל 10, זה עדיין יעמוד בתנאי. לכן הוא יפעל שוב בהשוואה לכתיבה ל- i <10. למרות שהוא מתחיל מ -1, זמני הלולאה הם עדיין 10. כמובן שאם לא צריך שום דבר מיוחד, אני רוצה להציע לך לאמץ את שיטת הכתיבה ב דוגמה בהתחלה. מאוחר יותר נציג בפניכם וקטור או מערך, ששניהם משיגים את האלמנט שלו על ידי המנוי שלו. וכל המנויים ברירת המחדל מתחילים מ -0. הגדרת הערך ההתחלתי להיות 0 היא הפרקטיקה הנפוצה יחסית.

בדוגמה שלמעלה, אם נכתוב i הוא מעבר ל- 0, הפוגרם יקרוס. מכיוון שהמשתנה גדל והולך, הוא לעולם לא יעמוד בתנאי זה. זה בדיוק כמו שלעולם לא ניתן לעצור זאת, כך שהתוכנית תתקל בלולאה אינסופית.

משתנים מקומיים בהצהרה for יכולים לא רק להכריז על סוגי פלסטיק, אלא גם להכריז על משתנים בסוגי נקודה צפה. לדוגמה, ניתן לכתוב אותו כ (float i = 0; i <10; i + = 0.02).

שלב 2: השתמש בלולאה לפתרון בעיות מתמטיות

אתה עדיין זוכר סיפור של המתמטיקאי גאוס בילדותו? באותו זמן, גוואס היה בן 10. המורה שלו רצה להטיל משימה בכיתה והשאלה הייתה

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

אם תחשב בעזרת הידיים, זה ייקח לך הרבה זמן. אך נראה כי גאס כבר הבין את שיטת הסיכום של הרצף האריתמטי. אז רגע לאחר שהשאלה ניתנה, הוא דיבר בקלות על התשובה, מה שהפתיע מאוד את המורה שלו.

כעת, אולי עדיין איננו זוכרים מהו סיכום הרצף האריתמטי אך אנו יכולים לקבל את התשובה בצורה פרימיטיבית ואלימה. וזה לולאה. מכיוון שזו רק חתיכה קטנה למחשבים לספור, עלינו לתאר את השאלה לשפה שאפשר לזהות אותה על ידי מחשב, ואז נוכל לקבל את התשובה שלנו בקלות.

דוגמה לקוד (5-3):

הגדרת בטל () {

int answer = 0;

עבור (int i = 1; i <= 100; i ++) {

תשובה += i;

}

println (תשובה);

}

אני מאמין שהתוצאה שתקבל זהה לתשובה שגואס דיווח עליה: היא 5050!

עצות: ניתן לשנות את שם המשתנים המקומיים לולאה כרצונו בתנאי שהוא עומד בתקנות שמות המשתנים. אתה יכול לכתוב את זה כך (int k = 1; k <= 100; k ++). אם לא קרו תנאים מיוחדים, ברירת המחדל היא אותו שם המשתנה.

שלב 3: לציור לולאה

לאחר סדרה של מצעים משעממים לכאורה, סוף סוף נוכל להיכנס לקטע מעניין יותר. כלומר להשתמש בלולאה לציור תמונות. אנו יכולים להניח בצד את החישוב המתמטי המייגע הזה כעת. אנו המעצבים רגישים יותר לגרפיקה.

השתמש עבור לולאה כדי לצייר מערך מעגל

כאשר אנו רוצים להשתמש ב- loop כדי לייצג קבוצה של אלמנטים חוזרים ונשנים, עלינו לוודא את יחסי הספרות של אלמנטים אלה לפני כן, ואז נוכל להשתמש ב- loop כדי לממש אותו בנוחות במקום לבצע עבודות חוזרות מאסיביות. נניח שאם נרצה לצייר שורת עיגול המפוזרת שווה בכיוון אופקי. הקואורדינטות הסגולות שלה אינן משתנות ואילו הקואורדינטות האופקיות שלה משתנות. ומשמאל לימין, הקואורדינטות האופקיות גדלות ללא הרף והמרחק הגדל זהה. בשלב זה, אנו יכולים להשתמש ב- i עבור לולאה כדי לקבל את הקואורדינטות האופקיות של כל מעגל.

דוגמה לקוד (5-4): הגדרת void () {

גודל (700, 700);

רקע (83, 51, 194);

noStroke ();

}

צייר חלל () {

עבור (int i = 0; i <7; i ++) {

אליפסה (50.0 + i * 100.0, גובה/2.0, 80.0, 80.0);

}

}

50 מייצג את עמדת ההתחלה של המעגל הראשון בצד שמאל. 100 ב i * 100 מייצג את המרחק הגדל.

שלב 4: השתמש עבור לולאה כדי לצייר נקודה עגולה אקראית

העמדה הגרפית לעיל ניתנת לחיזוי. זה ימזער הרבה עניין. אנו יכולים להשתמש בפונקציה אקראית שאליה התייחסנו בפרק הקודם ולנסות לכתוב אותה בפונקציית ציור.

דוגמא לקוד (5-5):

הגדרת בטל () {

גודל (700, 700);

רקע (0);

noStroke ();

}

צייר חלל () {

רקע (0);

עבור (int i = 0; i <10; i ++) {

float randomWidth = אקראי (60.0);

אליפסה (אקראית (רוחב), אקראית (גובה), randomWidth, randomWidth);

}

}

כאן, הסיבה לכך שמיקום המעגל מהבהב ללא הרף היא בגלל שכל פעם פונקציה אקראית פועלת פעם אחת, התוצאה אקראית. מכיוון שברירת המחדל של פונקציה היא הפעלת 60 פריימים לשנייה, כך שכל 10 עיגולים המצוירים בשנייה ישנו את מיקומה במשך 60 פעמים. הבזק מהיר זה גורם לתמונה כאילו יש לה יותר מעשרה עיגולים בלבד. שינוי ערך פשוט בתוכנית יביא לך השפעה שונה בתכלית. אנו יכולים לשנות את זמני הלולאה על ידי שינוי מצב הטרמינל. המצב הסופי בתמונה למטה הוא i <100

1. להלן ההשפעה כאשר המצב הסופי הוא i <1000:
2. זרע אקראי
3. אם אני לא רוצה שמיקום המעגל נוצר באופן אקראי, כמו גם הבזק שלו, מה אני יכול לעשות? שיטה אחת היא לבנות ולאחסן משתנים עצמאיים לכל מעגל ולאתחל משתנים אלה בהגדרה. הקצה למשתנים אלה ערך אקראי. לכן, כאשר משתמשים בפונקציית ציור בתוך תיקו, מה שהפעלנו הוא הערך המאוחסן במשתנים. זה לא ישתנה בשום זמן. כדי לצייר 10 עיגולים נוכל פשוט להשתמש בשיטה זו. אבל מה אם נרצה לצייר 1000 עיגולים, או 10, 000 מעגלים? זה יהיה די בעייתי אם נשתמש בשיטה מסורתית זו כדי לבנות את המשתנים האלה ולתת לו שם. איננו צריכים ללמוד שיטת בנייה חדשה של משתנים. לפניכם שיטה גמישה שיכולה לעזור לנו להשיג מטרה זו. כלומר להשתמש ב- randomSeed. עכשיו, בואו נסתכל על ההשפעה שלו לאחר השימוש. דוגמא לקוד (5-6): [cceN_cpp theme = "dawn"] הגדרת חלל () {size (700, 700); רקע (0); noStroke ();}

4. צייר חלל () {

   רקע (0);

   randomSeed (1);

   עבור (int i = 0; i <10; i ++) {

   float randomWidth = אקראי (20.0, 60.0);

   אליפסה (אקראית (רוחב), אקראית (גובה), randomWidth, randomWidth);

   }

   } [/cceN_cpp]

   בהשוואה לקוד שלפני כן, אין בו שינויים פרט לביצוע טווח הרדיוס של מעגל מ -10 למעבר ל -30 עם משפט של ofSeedRandom בלבד. לאחר הוספת משפט זה, נראה שהגרפיקה הפכה לסטטית.

   הפעלת פורמט:

   randomSeed (א);

   בין פורמט זה, ההגדרה של a היא זרע. עליך למלא מספר שלם (כתוב ערך נקודה צפה ב- P5, הוא לא ישתבש אלא יתייחס אליו כאל מספר שלם) לתוכו. הפונקציה של randomSeed היא להגדיר את הזרע לערך אקראי. ואז הוא יפיק מערך אקראי שונה על פי זרעים שונים. לאחר מכן, אנו מפעילים פונקציה אקראית כך שתוצאת החזרה תהיה מובהקת. כאן, ההגדרה היא לא שהתוצאה היא ערך מוגדר אלא עבור המערך שנוצר. זאת אומרת שתוצאת החזרה היא מוגדרת יחסית לזמני הפנייה.

   דוגמה לקוד (5-7): [cceN_cpp theme = "dawn"] הגדרת חלל () {

   randomSeed (0);

   עבור (int i = 0; i <5; i ++) {

   println (אקראי (10));

   }

   } [/cceN_cpp]

   כעת אנו ממשיכים להשתמש ב- println לביצוע ניסוי. לאחר שימוש ב- randomSeed, בכל פעם שתסגור את התוכנית ותפעיל מחדש את התוכנית, היא תחזור למחרוזת של אותה תוצאה. הערך יתאים לרצף בזה אחר זה. אם תמחק אותו, כל פעם הוא יחזור לערך אחר. למה יש לו את ההגדרה הזו? הסיבה לכך היא שהערך האקראי עצמו בתוכנית הוא פסאודו אקראי. התוצאה נראית אקראית אך למעשה היא נוצרת על ידי שיטת חישוב קבועה וניתנת לחיזור. זה שווה ערך לייחס ערך פרימיטיבי עבור randomSeed, ואז התוצאה הבאה תחושב על פי זרע זה. עם זאת, אם לא נקבע את הזרע, התוכנית תהיה ברירת מחדל להשתמש בזמן הנוכחי של המערכת ליצירת זרעים. לכן התוצאה של כל פעולה שונה. הדוגמה להלן יכולה לעזור לך להבין טוב יותר את randomSeed.

   קוד דוגמה (5-8): [cceN_cpp theme = "dawn"] הגדרת חלל () {

   גודל (700, 700);

   רקע (0);

   noStroke ();

   }

   צייר חלל () {

   randomSeed (1);

   עבור (int i = 0; i <10; i ++) {

   float randomWidth01 = אקראי (10, 60);

   אליפסה (אקראית (רוחב), אקראית (גובה), randomWidth01, randomWidth01);

   println (randomWidth01);

   }

   randomSeed (1);

   עבור (int i = 0; i <10; i ++) {

   float randomWidth02 = אקראי (10, 60);

   אליפסה (אקראית (רוחב), אקראית (גובה), randomWidth02, randomWidth02);

   println (randomWidth02);

   }

   } [/cceN_cpp]

   נסה לשנות את randomSeed השני (1) ל- randomSeed (0) ולהשוות את התוצאות הסופיות.

   טיפים: ב- P5 עלינו להפעיל את פונקציית noLoop רק בסיום ההגרלה, כך שנוכל לקבל את אותו האפקט. תפקידו לסיים את התוכנית. זה שונה לגמרי מעקרונות העבודה לעיל בטבע.

שלב 5: השתמש עבור לולאה לציור קו

לאחר שהשתלטנו על השימוש ב- randomSeed, נוכל לשנות את פונקציית הציור. לדוגמה, שנה ציור מעגל לציור קו. רק אם נתכנן כמה תקנות משתנות עד סוף הקו, נוכל להשתמש בהרבה קווים המשולבים כדי ליצור תבנית ייחודית.

דוגמא לקוד (5-9):

[cceN_cpp theme = "dawn"] הגדרת חלל () {

גודל (700, 700);

רקע (0);

}

צייר חלל () {

randomSeed (0);

עבור (int i = 0; i <2000; i ++) {

לצוף x1 = רוחב/2.0;

float x2 = אקראי (50.0, 650.0);

שבץ (255, 20);

קו (x1, 50, x2, 650);

}

} [/cceN_cpp]

צור מברשת פשוטה

חזור שוב ללופ. הדוגמאות לעיל אינן אינטראקטיביות. אם אנחנו רוצים להפוך את התוצאה למעניינת יותר, לא נשכח לשלב את mouseX ו- mouseY בקוד שלנו.

דוגמא לקוד (5-10):

[cceN_cpp theme = "dawn"] הגדרת חלל () {

גודל (700, 700);

רקע (255);

noStroke ();

}

צייר חלל () {

עבור (int i = 0; i <1000; i ++) {

מילוי (0, 30);

צף x = mouseX + אקראי (-50, 50);

צף y = עכבר Y + אקראי (-50, 50);

אליפסה (x, y, 2, 2);

}

} [/cceN_cpp]

נוצרת מברשת "נקודות פיזור". מכיוון שכל נקודה מיני אינטנסיבית אינטנסיבית מבוססת על מיקום העכבר, היא יכולה להזיז כיוונים מוגבלים מארבעת הכיוונים של שמאל, ימין, למעלה ולמטה. אז התפשטות הצורה הסופית של המברשת דומה לריבוע.

דוגמא לקוד (5-11):

[cceN_cpp theme = "dawn"] הגדרת חלל () {

גודל (700, 700);

רקע (255);

noStroke ();

}

צייר חלל () {

עבור (int i = 0; i <1000; i ++) {

יחס צף = mouseX/(float) רוחב;

צף x = mouseX + אקראי (-50, 50);

צף y = עכבר Y + אקראי (-50, 50);

מילוי (0, יחס * 255, 255 * (1 - יחס), 30);

אליפסה (x, y, 2, 2);

}

}

[/cceN_cpp]

אם נשתמש בערך musX כדי להשפיע על צבע המילוי, נקבל שיפוע צבע קסום הרבה יותר.

שלב 6: לולאה מקוננת

שכן לולאה יכולה להיות מקוננת. אתה יכול לכתוב שוב לולאת for לולאת ה- for. כאשר אתה צריך לצייר מטריצת נקודות דו -ממדית, אתה יכול לבחור בשיטה זו.

דוגמא לקוד (5-12):

[cceN_cpp theme = "dawn"] הגדרת חלל () {

גודל (700, 700, P2D);

רקע (202, 240, 107);

}

צייר חלל () {

מילוי (0);

עבור (int i = 0; i <5; i ++) {

עבור (int j = 0; j <5; j ++) {

לצוף x = 150 + i * 100;

לצוף y = 150 + j * 100;

אליפסה (x, y, 60, 60);

println (i + ":" + j);

}

}

}

[/cceN_cpp]

כדי להשתמש בלולאה המקוננת בפעם הראשונה, עליך להבין את יחסי ההיגיון שלה. יישום הקוד בתוכנית הוא תמיד מלמעלה למטה. לכן, המיושם הראשון הוא בהחלט הלולאה החיצונית ביותר. בכל פעם שהלולאה החיצונית תפעל פעם אחת, הלולאה הפנימית תפעל ברציפות עד שהיא לא תוכל לספק את התנאי עוד. לאחר מכן, הוא יתחיל את פעולת הלולאה החיצונית השנייה. לאחר תחילת הפעולה השנייה, הלולאה הפנימית תמשיך לפעול עד שהיא לא תוכל לספק את התנאי. חזרה כזאת היא עושה עד שלא ניתן למלא את כל התנאים והיא קופצת מהלולאה.

בקוד לעיל, גוף הלולאה בלולאה החיצונית פעל בסך הכל 5 פעמים, בעוד גוף הלולאה בלולאה הפנימית פעל 25 פעמים. בתוך 25 פעמים, על פי ההבדל בערך i, j, אנו יכולים להבטיח את הקואורדינטות האופקיות והאנכיות של המעגל בנפרד. הטמנתי קטע הדפסה, אתה יכול לצפות בפלט הנתונים ולחשוב על השינוי בו. עם שתי לולאות מקוננות בלבד, אנו יכולים לחוות את כל הצירופים של נתוני i, j.

טיפים

ללולאה בשכבה השנייה בדרך כלל מתעבים עם Tab בתחילת הדרך. זה יכול להפוך את מבנה הקוד ברור יותר. עליך לתת שם למשתנים מקומיים בשתי השכבות של לולאה עם שמות שונים. ביניהם, "i", "j", "k" הוא הנפוץ ביותר.

שימוש גמיש "i", "j"

שני שם המשתנים של "i", "j" מייצגים משתנים מקומיים של שתי השכבות של לולאה. הדוגמה שלהלן תעמיק את ההבנה שלך לגבי "i" "j". על פי הערך השונה של "i", "j", אנו יכולים להזין פרמטרים לקיבוץ האלמנטים.

דוגמא לקוד (5-13): [cceN_cpp theme = "dawn"] הגדרת חלל () {

גודל (700, 700);

רקע (0);

noStroke ();

}

צייר חלל () {

רקע (0);

מילוי (250, 233, 77);

עבור (int i = 0; i <7; i ++) {

עבור (int j = 0; j <7; j ++) {

pushMatrix ();

תרגם (50 + i * 100, 50 + j * 100);

// הגדרה 1

// זווית צף = sin (מילי ()/1000.0) * PI/2;

// הגדרה 2

// יחס צף = i/7.0;

// זווית צף = sin (מילי ()/1000.0 + יחס * (PI/2)) * PI/2;

// הגדרה 3

יחס צף = (i * 7 + j) /49.0;

זווית צף = sin (מילי ()/1000.0 + יחס * (PI/2)) * PI/2;

לסובב (זווית);

rectMode (CENTER);

// צייר תמונה 1

rect (0, 0, 80, 80);

// צייר תמונה 2

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

// צייר תמונה 3

// rect (0, 0, יחס * 50);

popMatrix ();

}

}

} [/cceN_cpp]

הסבר קוד

rectMode (CENTER) יכול לשנות את שיטת הרישום של ריבוע. שני הפרמטרים הראשוניים של המקורי של rect משמשים להגדרת הקואורדינטות של הפינה השמאלית העליונה של המרובע. לאחר שהתחלנו בפקודה זו, שני הפרמטרים הללו ישמשו לקביעת הקואורדינטות של נקודת המרכז המרובעת.מכיוון שכאן אנו מפעילים את סיבוב הפטררן באמצעות סיבוב, לכן עלינו להשתמש בשיטה זו כדי לצייר את נקודת המרכז לנקודה המקורית של הקואורדינטות.

millis () רוכש את הזמן מתחילת התוכנית ועד היום. היחידה היא ms. ערך זה ישפיע על המהירות המשתנה של ערך תפוקת החטא. אם נכתוב מילי ישירות, הסולם המשתנה גדול מדי. לפיכך, עלינו לחלק אותו ב- 1000.0.

בחלק זה של הקוד, אנו משתמשים בסמל ההערה "//" כדי להסתיר מספר הגדרות. אתה יכול לשנות אפקטים על ידי התחלה או סגירה. לדוגמה, אם נתחיל משפטים מאחורי "הגדרה 3", עלינו להשתמש בסמל הערה כדי לסגור בלוקים של קוד ביחס ל"הגדרה 1 "ו"הגדרה 2". באשר לדוגמאות למבנה תוכניות דומה זה עם משתנים מקומיים שונים, אנו יכולים לכתוב בפורמט זה. לפיכך איננו צריכים לאחסן מספר מסמכים הנדסיים בנפרד. אנו יכולים להשתמש במיומנות זו לעתים קרובות במהלך תרגול ויצירה ולשמור כמה הגדרות פרמטרים מספקות.

ביניהם, ההשפעה של ערך i, j לתוכנית מיוצגת בעיקר על ידי הזזת "הגדרה 1 (הגדרה 2) (הגדרה 3)". תוכל להשוות את תוצאות הפלט להלן.

צייר תמונה 1: הגדרה 1

צייר תמונה 1: הגדרה 2

צייר תמונה 1: הגדרה 3

צייר תמונה 2: הגדרה 1

צייר תמונה 2: הגדרה 2

צייר תמונה 2: הגדרה 3

בהגדרה 1, לא השתמשנו ב- i ו- j כדי להשפיע על זווית הסיבוב של כל אלמנט. כך אנו יכולים לראות שהתנועה של כל יסוד זהה. בעוד שבמסגרת 2, השתמשנו ב- i ערך והן ב- i והן ב- j בהגדרה 3. לבסוף הם השפיעו על קלט הפרמטרים של חטא הפונקציה באמצעות יחס. זה שינה את שינוי הזווית התקופתי. מכיוון שההשפעה בפועל של הגדרה 2 והגדרה 3 אינה כה ברורה בגרפיקה המונפשת, אנו יכולים לצפות בה מתוך צילום המסך הבא.

צייר תמונה 2 (משמאל: הגדרה 2; ימין: הגדרה 3)

צייר תמונה 3 (משמאל: הגדרה 2; ימין: הגדרה 3)

בתמונה הראשונה, יחס משמש להשפעת זווית הסיבוב המרובעת. בעוד התמונה השנייה, היא נועדה לשלוט ברדיוס המעגל ישירות. אנו יכולים לראות כי הוא השתמש במשפט i value:

יחס צף = i/7.0;

שינוי האלמנט האנכי שלו עקבי. מכיוון שהקואורדינטות האופקיות לשליטה בתמונה תלויות רק בערך i, כך שתבניות עם אותו קואורדינטות אופקיות יהיו זהות. וגם ערך היחס, זווית סיבוב ורדיוס המעגל זהה.

במקביל, אנו משתמשים במשפט i, j:

יחס צף = (i * 7 + j) /49.0;

הוא יכול לתאר "שיפוע". כאן, בשיטת הכפלת גורם, הוא שילב את ההשפעה של שורות ועמודות. אז כל אלמנט שונה.

שלב 7: בעוד לולאה

יש אח עבור לולאה. כלומר לולאה. מה לולאה יכולה לעשות, בעוד לולאה יכולה לעשות זאת. אבל תדירות השימוש ב- while loop ב- creativeCoding אינה גבוהה כמו לולאה.

דוגמה לקוד (5-14): [cceN_cpp theme = "dawn"] הגדרת חלל () {

int a = 0;

בעוד (a <10) {

println (א);

a ++;

}

} [/cceN_cpp]

קל יותר להבין את מבנה הדקדוק של בעוד מאשר. אנו יכולים ליצור משתנים לפני משפט. לאחר מכן מלא את הביטוי בתוך סוגר מרובע. כאשר הוא מרוצה, הפעל את המשפטים בתוך גוף הלולאה. לבסוף שמנו ביטוי בגוף הלולאה כדי לעדכן את המשתנים, ואז תוך סיום הלולאה. באשר לזמני הלולאה הבטוחים, לעתים קרובות אנו משתמשים בלולאה. באשר לערך משתנה בלתי מוגדר, אנו ממליצים לך להשתמש בעוד לולאה.

לַחשׁוֹב:

נסה להשתמש בכל מיני אלמנטים בסיסיים כדי להחליף רכיבי ציור ללולאה ליצירת מברשות שונות.

שלב עם פונקציה טריגונומטרית שהוזכר בפרק האחרון, נסה לשנות את מברשת "נקודות הפיזור" למברשת בצורת עגול.

נסה ליצור מטריצת נקודות דו -ממדית עם לולאה בלבד.

כמו בתוכנית המקדימה של הפרק הבא, כמו בקורס זה, תוכלו למצוא כל ידע חדש שתלמדו, האפשרות לשחק תגדל מיד באופן מיידי. התוכנית היא קופסת פנדורה. כל מה שאתה יכול לדמיין, הוא יכול לעשות זאת עבורך. אז אין סיבה שלא נלמד את השפה הזו שיכולה לתקשר עם מחשבים. בפרק הבא, נציג הצהרת בקרת תהליכים נוספת אם לך. הוא יכול לשלוט בזרימת התהליך וליצור תוצאות מסובכות וניתנות לשינוי. עם הצהרת if, אתה יכול ליצור משחקי הרפתקאות טקסט משלך בקלות! מאמר זה בא ממעצב Wenzy. קריאות רלטיביות: הדרכה תכנות מעניינת למעצב-עיבוד מגע ראשוני הדרכת תכנות מעניינת למעצב-צור תכנית עיבוד ראשונה שלך הדרכת תכנות מעניינת למעצב –קבל את ריצת התמונה שלך (חלק ראשון) הנחיית תכנות מעניינת למעצב – הפעל את התמונה שלך (חלק שני)

שלב 8: מקור

מאמר זה הוא מתוך:

אם יש לך שאלות, תוכל ליצור קשר עם: [email protected].