สารบัญ:
- ขั้นตอนที่ 1: สำหรับ Loop
- ขั้นตอนที่ 2: ใช้สำหรับวนซ้ำเพื่อแก้ปัญหาทางคณิตศาสตร์
- ขั้นตอนที่ 3: สำหรับการวาดแบบวนซ้ำ
- ขั้นตอนที่ 4: ใช้สำหรับวนซ้ำเพื่อวาดจุดกลมแบบสุ่ม
- ขั้นตอนที่ 5: ใช้สำหรับวนเพื่อวาดเส้น
- ขั้นตอนที่ 6: สำหรับ Loop Nested
- ขั้นตอนที่ 7: ในขณะที่วนรอบ
- ขั้นตอนที่ 8: แหล่งที่มา
วีดีโอ: คำแนะนำการเขียนโปรแกรมที่น่าสนใจสำหรับนักออกแบบ -- โปรแกรมควบคุมกระบวนการ- คำสั่งวนรอบ: 8 ขั้นตอน
2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:09
การควบคุมกระบวนการของโปรแกรม - คำสั่งวนรอบ
จากบทนี้ คุณจะได้สัมผัสกับคำชี้แจงแบบวนซ้ำที่สำคัญและมีประสิทธิภาพ
ก่อนอ่านบทนี้ ถ้าคุณต้องการวาดวงกลม 10,000 วงกลมในโปรแกรม คุณสามารถทำได้ด้วยวิธีที่แย่มากเท่านั้น นั่นคือการเขียนโค้ดวงรี 10,000 บรรทัด บรรดานักออกแบบรหัสขี้เกียจที่ต้องการปรับปรุงประสิทธิภาพโดยวิธีการทั้งหมดจะไม่ยอมให้สิ่งนี้เกิดขึ้นอย่างแน่นอน ดังนั้นคำสั่งลูปจึงถูกสร้างขึ้น ด้วยคำกล่าวนี้ คุณจะสัมผัสได้ถึงพลังของระบบอัตโนมัติของคอมพิวเตอร์โดยสัญชาตญาณ
ขั้นตอนที่ 1: สำหรับ Loop
มีคำสั่งวนซ้ำจำนวนมาก ซึ่งคำที่ใช้กันอย่างแพร่หลายที่สุดคือ For Loop เราทุกคนทราบดีว่าการวาดฟังก์ชันทำงานอย่างต่อเนื่องในการหมุนเวียน เริ่มจากประโยคแรกตั้งแต่ต้น จะใช้จากบนลงล่างจนถึงประโยคสุดท้าย หลังจากดำเนินการเสร็จสิ้นแล้ว จะเริ่มใหม่อีกครั้งตั้งแต่ประโยคแรก สำหรับคำสั่งนั้นคล้ายกับการวาดฟังก์ชันเล็กน้อย รหัสภายในสำหรับคำสั่งสามารถดำเนินการซ้ำ ๆ
นี่คือโครงสร้างไวยากรณ์:
สำหรับ (นิพจน์ 1; นิพจน์ 2; นิพจน์ 3) {
ตัวห่วง
}
เห็นได้ชัดว่าประโยคภายใน loop body คือสิ่งที่เราคาดว่าจะนำมาใช้ซ้ำๆ นิพจน์ 1 ใช้เพื่อเริ่มต้นและกำหนดค่าแรกให้กับตัวแปรลูป นิพจน์ 2 ใช้สำหรับเงื่อนไขลูป นิพจน์ 3 จะอัปเดตค่าตัวแปรลูป
ตัวแปรลูปคืออะไร? ที่จริงแล้วมันเทียบเท่ากับตัวแปรท้องถิ่น มาดูงานเขียนฉบับสมบูรณ์กัน
สำหรับ (int i = 0;i < 10;i++){
ตัวห่วง
}
เพื่อให้ทราบถึงฟังก์ชันลูป สำหรับคำสั่งส่วนใหญ่อาศัยตัวแปรโลคัล ซึ่งจะถูกใช้เมื่อสิ้นสุดลูป ตัวแปรโลคัลในตัวอย่างข้างต้นคือ i นิพจน์ 1 ได้เสร็จสิ้นการเริ่มต้นของตัวแปรท้องถิ่น ต่อมา ทุกครั้งที่ลูปทำงานเพียงครั้งเดียว ตัวแปรนี้ต้องได้รับการอัปเดต จากตัวอย่างข้างต้น i++ ในนิพจน์ 3 ใช้เพื่อรับรู้ฟังก์ชันการอัพเดท ผ่านมัน ตัวแปรจะเพิ่มขึ้น 1 ทุกครั้งที่อัปเดต ในท้ายที่สุด โค้ดภายใน loop body ไม่สามารถวนซ้ำได้อย่างไม่มีกำหนด มิฉะนั้น คำสั่งหลังจะไม่สามารถดำเนินการได้ ดังนั้นเราจึงต้องการเงื่อนไขเทอร์มินัล ด่วน 2 เป็นเพียงสำหรับมัน ที่นี่โปรแกรมจะตัดสินว่าผมมีค่าน้อยกว่า 10 หรือเปล่า ถ้าใช่ก็ดำเนินการต่อไป ถ้าไม่ใช่ก็กระโดดออกจากวง
ดังนั้น ลำดับการทำงานของ for statement จึงเป็นแบบนี้
นิพจน์ 1 (การกำหนดค่าเริ่มต้นตัวแปรในเครื่อง)
นิพจน์ 2 (พอใจแล้วดำเนินการต่อไป)
วงรอบ (การไหลเวียนครั้งแรก)
นิพจน์ 3 (อัปเดต)
นิพจน์ 2 (พอใจแล้วดำเนินการต่อไป)
วงรอบ (circultaion ที่สอง)
นิพจน์ 3 (อัปเดต)
นิพจน์ 2 (พอใจแล้วดำเนินการต่อไป)
วงรี (รอบที่สาม) …
นิพจน์ 3 (อัปเดต)
นิพจน์ 2 (ไม่พอใจแล้วกระโดดออกจากลูป)
คุณสามารถจำลองลำดับการดำเนินการในหัวของคุณได้หลายครั้ง แต่มันเป็นไปไม่ได้เลยที่จะเข้าใจโค้ดโดยไม่ได้พิมพ์ด้วยมือของคุณสักครั้ง เมื่อเราต้องการค้นหาแนวคิดแปลก ๆ เราสามารถพิมพ์ค่าในคอนโซลผ่านคำสั่ง println
ตัวอย่างโค้ด (5-1): การตั้งค่าเป็นโมฆะ (){
สำหรับ(int i = 0; i < 10; i++){
println ("วิ่ง");
}
}
คุณสามารถนับจำนวนรันเอาท์พุตในคอนโซลได้ ตรงนี้คือ 10 ทีเดียว ซึ่งจะบอกคุณว่าโค้ดใน loop body ถูกเรียกใช้งานกี่ครั้ง อย่างไรก็ตาม เรายังตรวจไม่พบการเปลี่ยนแปลงที่เกิดขึ้นจริงในลูป ดังนั้นเราจึงสามารถลองเปลี่ยนอักขระ "run เป็นตัวแปร "i" และดูว่าจะเกิดอะไรขึ้น
ตัวอย่างโค้ด (5-2): การตั้งค่าเป็นโมฆะ (){
สำหรับ(int i = 0; i < 10; i++){
พิมพ์ (i);
}
}
ตอนนี้เราสามารถเห็นค่า i ในตัวลูปเพิ่มขึ้นอย่างต่อเนื่อง ต่อมา เราสามารถใช้ค่านี้เพื่อทำความเข้าใจกระบวนการปัจจุบันของลูปได้
ในตัวอย่างโค้ด (5-2) ค่าของ i จะเปลี่ยนจาก 0 เป็น 9 เมื่อเทียบกับรอบเวลาจริง ดูเหมือนว่าจะมีค่าน้อยกว่า 1 เสมอ ถ้าคุณไม่คุ้นเคยกับมัน นิพจน์ภายในวงเล็บของคำสั่ง for สามารถเขียนได้ดังต่อไปนี้:
สำหรับ(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: ใช้สำหรับวนซ้ำเพื่อแก้ปัญหาทางคณิตศาสตร์
คุณยังจำเรื่องราวของนักคณิตศาสตร์เกาส์ในวัยเด็กของเขาได้หรือไม่? ในขณะนั้น Guass อายุ 10 ขวบ ครูของเขาต้องการมอบหมายงานในชั้นเรียนและคำถามคือ
1＋2＋3＋4……＋97＋98＋99+100＝？
หากคุณคำนวณด้วยมือของคุณเอง จะใช้เวลามาก แต่ดูเหมือนว่า Guass จะคิดวิธีการบวกลำดับเลขคณิตได้แล้ว หลังจากถามคำถาม เขาก็พูดคำตอบออกมาได้อย่างง่ายดาย ซึ่งทำให้ครูของเขาประหลาดใจอย่างมาก
ตอนนี้ เราอาจยังจำไม่ได้ว่าผลรวมของลำดับเลขคณิตคืออะไร แต่เราได้คำตอบด้วยวิธีดั้งเดิมและรุนแรง และนั่นคือสำหรับลูป เนื่องจากเป็นเพียงส่วนเล็กๆ ของเค้กสำหรับคอมพิวเตอร์ที่จะนับ เราต้องอธิบายคำถามเป็นภาษาที่คอมพิวเตอร์สามารถจดจำได้ จากนั้นเราจึงสามารถหาคำตอบได้อย่างง่ายดาย
ตัวอย่างโค้ด (5-3):
การตั้งค่าเป็นโมฆะ (){
คำตอบ int = 0;
สำหรับ(int i = 1; i <= 100; i++){
ตอบ += ผม;
}
println(คำตอบ);
}
ฉันเชื่อว่าผลลัพธ์ที่คุณได้รับนั้นเหมือนกับคำตอบของ Guass ที่รายงาน: มันคือ 5050!
เคล็ดลับ: ชื่อของตัวแปรโลคัลใน for loop สามารถเปลี่ยนแปลงได้ตามต้องการโดยมีเงื่อนไขว่าต้องเป็นไปตามข้อบังคับการตั้งชื่อตัวแปร คุณสามารถเขียนเป็น (int k = 1;k <= 100;k++) หากไม่มีเงื่อนไขพิเศษเกิดขึ้น ค่าเริ่มต้น i เป็นชื่อของตัวแปร
ขั้นตอนที่ 3: สำหรับการวาดแบบวนซ้ำ
หลังจากชุดเครื่องนอนที่ดูน่าเบื่อแล้ว ในที่สุดเราก็มาถึงส่วนที่น่าสนใจกว่านี้ได้ คือใช้สำหรับวนซ้ำเพื่อวาดภาพ เราสามารถแยกการคำนวณทางคณิตศาสตร์ที่น่าเบื่อออกไปได้แล้ว นักออกแบบของเรามีความอ่อนไหวต่อกราฟิกมากกว่า
ใช้สำหรับวนซ้ำเพื่อวาดอาร์เรย์วงกลม
เมื่อเราต้องการใช้ for loop เพื่อแสดงกลุ่มขององค์ประกอบที่เกิดซ้ำ เราต้องแน่ใจว่าความสัมพันธ์เชิงตัวเลขขององค์ประกอบเหล่านี้ล่วงหน้า จากนั้นเราจึงสามารถใช้ for loop เพื่อให้เข้าใจได้ง่าย แทนที่จะทำงานซ้ำจำนวนมาก สมมติถ้าเราต้องการวาดแถวของวงกลมให้แผ่เท่ากันในแนวนอน พิกัดเสมือนของมันจะไม่เปลี่ยนแปลงในขณะที่พิกัดแนวนอนเปลี่ยนไป และจากซ้ายไปขวา พิกัดแนวนอนจะเพิ่มขึ้นเรื่อยๆ และระยะทางที่เพิ่มขึ้นก็เท่าเดิม ในตอนนี้ เราสามารถใช้ i in for loop เพื่อหาพิกัดแนวนอนของแต่ละวงกลมได้
ตัวอย่างโค้ด (5-4): การตั้งค่าเป็นโมฆะ (){
ขนาด (700, 700);
พื้นหลัง (83, 51, 194);
ไม่มีจังหวะ ();
}
ถือเป็นโมฆะวาด (){
สำหรับ (int i = 0; i <7; i++){
วงรี(50.0 + i * 100.0, ความสูง/2.0, 80.0, 80.0);
}
}
50 หมายถึงตำแหน่งเริ่มต้นของวงกลมแรกทางด้านซ้าย 100 ใน i * 100 หมายถึงระยะทางที่เพิ่มขึ้น
ขั้นตอนที่ 4: ใช้สำหรับวนซ้ำเพื่อวาดจุดกลมแบบสุ่ม
ตำแหน่งกราฟิกด้านบนสามารถคาดเดาได้ สิ่งนี้จะลดความสนใจให้เหลือน้อยที่สุด เราสามารถใช้ฟังก์ชัน Random ที่เราอ้างถึงในบทที่แล้วและลองเขียนในฟังก์ชันการวาด
ตัวอย่างโค้ด (5-5):
การตั้งค่าเป็นโมฆะ (){
ขนาด (700, 700);
พื้นหลัง(0);
ไม่มีจังหวะ ();
}
ถือเป็นโมฆะวาด (){
พื้นหลัง(0);
สำหรับ (int i = 0;i < 10;i++){
ลอยสุ่มความกว้าง = สุ่ม (60.0);
วงรี (สุ่ม (กว้าง), สุ่ม (สูง), สุ่มความกว้าง, สุ่มความกว้าง);
}
}
ในที่นี้ สาเหตุที่ตำแหน่งของวงกลมกะพริบอย่างต่อเนื่องนั้นเป็นเพราะทุกครั้งที่ฟังก์ชันสุ่มทำงานเพียงครั้งเดียว ผลลัพธ์จะเป็นแบบสุ่ม เนื่องจากการวาดฟังก์ชันถูกตั้งค่าเริ่มต้นให้รัน 60 เฟรมต่อวินาที ดังนั้นทุกๆ 10 วงกลมที่วาดในหนึ่งวินาทีจะเปลี่ยนตำแหน่งเป็น 60 ครั้ง แฟลชที่รวดเร็วนี้ทำให้ภาพดูมีวงกลมมากกว่า 10 วง การเปลี่ยนค่าอย่างง่ายในโปรแกรมจะทำให้คุณได้เอฟเฟกต์ที่แตกต่างไปจากเดิมอย่างสิ้นเชิง เราสามารถเปลี่ยนเวลาวนซ้ำได้โดยการแก้ไขเงื่อนไขเทอร์มินัล เงื่อนไขเทอร์มินัลในภาพด้านล่างคือ i < 100
- นี่คือเอฟเฟกต์เมื่อเงื่อนไขเทอร์มินัลคือ i < 1000:
- RandomSeed
- หากฉันไม่ต้องการให้สร้างตำแหน่งของวงกลมแบบสุ่มและแฟลช ฉันควรทำอย่างไร วิธีหนึ่งคือการสร้างและจัดเก็บตัวแปรอิสระสำหรับแต่ละวงกลมและเริ่มต้นตัวแปรเหล่านี้ในการตั้งค่า กำหนดตัวแปรเหล่านี้เป็นค่าสุ่ม ดังนั้น เมื่อใช้ฟังก์ชันการวาดภายในการวาด สิ่งที่เราเรียกใช้คือค่าที่เก็บไว้ในตัวแปร มันจะไม่เปลี่ยนแปลงตลอดเวลา ในการวาดวงกลม 10 วง เราสามารถใช้วิธีนี้ได้ แต่ถ้าเราต้องการวาดวงกลม 1,000 วง หรือ 10,000 วงกลมล่ะ มันจะค่อนข้างลำบากถ้าเราใช้วิธีการดั้งเดิมนี้เพื่อสร้างตัวแปรเหล่านี้และตั้งชื่อมัน เราไม่ต้องเรียนรู้วิธีสร้างตัวแปรใหม่ นี่เป็นวิธีที่ยืดหยุ่นซึ่งสามารถช่วยให้เราบรรลุเป้าหมายนี้ได้ นั่นคือการใช้ randomSeed ทีนี้มาดูผลกระทบของมันหลังจากใช้งานกัน ตัวอย่างโค้ด (5-6):[cceN_cpp theme="dawn"] void setup(){ size(700, 700); พื้นหลัง(0);noStroke();}
-
ถือเป็นโมฆะวาด (){
พื้นหลัง(0);
RandomSeed(1);
สำหรับ (int i = 0;i < 10;i++){
float randomWidth = สุ่ม (20.0, 60.0);
วงรี (สุ่ม (กว้าง), สุ่ม (สูง), สุ่มความกว้าง, สุ่มความกว้าง);
}
} [/cceN_cpp]
เมื่อเทียบกับโค้ดก่อนหน้านี้ จะไม่มีการเปลี่ยนแปลงใดๆ เว้นแต่ทำให้ช่วงรัศมีของวงกลมเปลี่ยนจาก 10 เป็นเกิน 30 ด้วยประโยคของ SeedRandom เท่านั้น หลังจากเพิ่มประโยคนี้แล้ว ภาพกราฟิกดูเหมือนนิ่ง
เรียกใช้รูปแบบ:
RandomSeed(ก);
ในรูปแบบนี้ การตั้งค่าของ a คือเมล็ด คุณต้องเติมจำนวนเต็ม (เขียนค่าจุดลอยตัวใน P5 จะไม่ผิดพลาด แต่จะถือว่าเป็นจำนวนเต็ม) ลงไป หน้าที่ของ randomSeed คือการตั้งค่าเมล็ดสำหรับค่าสุ่ม จากนั้นจะสร้างอาร์เรย์สุ่มที่แตกต่างกันตามเมล็ดที่แตกต่างกัน หลังจากนั้นเราเรียกใช้ฟังก์ชันแบบสุ่มเพื่อให้ผลลัพธ์ของการกลับมานั้นแน่นอน ในที่นี้ ค่าที่แน่นอนไม่ได้มีไว้สำหรับผลลัพธ์ แต่เป็นค่าที่แน่นอน แต่สำหรับอาร์เรย์ที่สร้างขึ้น กล่าวคือผลลัพธ์ของการกลับมานั้นแน่นอนเมื่อเทียบกับเวลาที่เรียก
ตัวอย่างโค้ด (5-7):[cceN_cpp theme="dawn"] void setup(){
RandomSeed(0);
สำหรับ (int i = 0;i <5;i++){
println(สุ่ม(10));
}
} [/cceN_cpp]
ตอนนี้เราใช้ println เพื่อทำการทดลองต่อไป หลังจากใช้ randomSeed ทุกครั้งที่คุณปิดโปรแกรมและรีสตาร์ทโปรแกรม โปรแกรมจะกลับไปเป็นสตริงของผลลัพธ์เดียวกัน ค่าจะสอดคล้องกับลำดับทีละรายการ หากคุณลบมัน ทุกครั้งที่มันจะกลับเป็นค่าที่แตกต่างกัน ทำไมถึงมีการตั้งค่านี้? เป็นเพราะค่าสุ่มในโปรแกรมนั้นสุ่มหลอก ผลลัพธ์ดูเหมือนสุ่ม แต่จริง ๆ แล้วถูกสร้างขึ้นโดยวิธีการคำนวณแบบคงที่และทำซ้ำได้ เทียบเท่ากับการกำหนดค่าดั้งเดิมสำหรับ randomSeed จากนั้นผลลัพธ์ต่อไปนี้จะถูกคำนวณตามเมล็ดพันธุ์นี้ อย่างไรก็ตาม หากเราไม่กำหนดเมล็ดพันธุ์ โปรแกรมจะตั้งค่าเริ่มต้นให้ใช้เวลาปัจจุบันของระบบเพื่อสร้างเมล็ดพันธุ์ ดังนั้นผลลัพธ์ของการดำเนินการทุกครั้งจึงแตกต่างกัน ตัวอย่างด้านล่างสามารถช่วยให้คุณเข้าใจ randomSeed ได้ดีขึ้น
ตัวอย่างโค้ด (5-8):[cceN_cpp theme="dawn"] void setup(){
ขนาด (700, 700);
พื้นหลัง(0);
ไม่มีจังหวะ ();
}
ถือเป็นโมฆะวาด (){
RandomSeed(1);
สำหรับ (int i = 0;i < 10;i++){
float randomWidth01 = สุ่ม (10, 60);
วงรี (สุ่ม (กว้าง), สุ่ม (สูง), randomWidth01, randomWidth01);
พิมพ์ (randomWidth01);
}
RandomSeed(1);
สำหรับ (int i = 0;i < 10;i++){
float randomWidth02 = สุ่ม (10, 60);
วงรี (สุ่ม (กว้าง), สุ่ม (สูง), randomWidth02, randomWidth02);
พิมพ์ (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++){
float x1 = ความกว้าง/2.0;
ลอย x2 = สุ่ม (50.0, 650.0);
จังหวะ (255, 20);
เส้น(x1, 50, x2, 650);
}
} [/cceN_cpp]
สร้างแปรงอย่างง่าย
กลับมาที่ลูปอีกครั้ง ตัวอย่างข้างต้นไม่ได้มีการโต้ตอบ หากเราต้องการทำให้ผลลัพธ์น่าสนใจยิ่งขึ้น เราต้องไม่ลืมที่จะรวม mouseX และ mouseY เข้ากับโค้ดของเรา
ตัวอย่างโค้ด (5-10):
[cceN_cpp theme="dawn"] การตั้งค่าเป็นโมฆะ (){
ขนาด (700, 700);
พื้นหลัง (255);
ไม่มีจังหวะ ();
}
ถือเป็นโมฆะวาด (){
สำหรับ (int i = 0;i <1000;i++){
เติม(0, 30);
float x = mouseX + สุ่ม (-50, 50);
float y = mouseY + สุ่ม (-50, 50);
วงรี(x, y, 2, 2);
}
} [/cceN_cpp]
แปรง "จุดกระเจิง" ถูกสร้างขึ้น เนื่องจากจุดกลมขนาดเล็กแบบเข้มข้นทุกจุดจะขึ้นอยู่กับตำแหน่งของเมาส์ จึงสามารถย้ายทิศทางที่จำกัดจากสี่ทิศทางทั้งซ้าย ขวา ขึ้นและลงได้ ดังนั้นการเกลี่ยรูปร่างขั้นสุดท้ายของแปรงจึงคล้ายกับสี่เหลี่ยมจัตุรัส
ตัวอย่างโค้ด (5-11):
[cceN_cpp theme="dawn"] การตั้งค่าเป็นโมฆะ (){
ขนาด (700, 700);
พื้นหลัง (255);
ไม่มีจังหวะ ();
}
ถือเป็นโมฆะวาด (){
สำหรับ (int i = 0;i <1000;i++){
อัตราส่วนลอย = mouseX/(ลอย)ความกว้าง;
float x = mouseX + สุ่ม (-50, 50);
float y = mouseY + สุ่ม (-50, 50);
เติม(0, อัตราส่วน * 255, 255 * (1 - อัตราส่วน), 30);
วงรี(x, y, 2, 2);
}
}
[/cceN_cpp]
หากเราใช้ค่าของ mouseX เพื่อส่งผลต่อสีเติม เราจะได้การไล่ระดับสีที่วิเศษกว่ามาก
ขั้นตอนที่ 6: สำหรับ Loop Nested
สำหรับลูปสามารถซ้อนกันได้ คุณสามารถเขียน for loop อีกครั้งใน for loop เมื่อคุณต้องการวาดดอทเมทริกซ์สองมิติ คุณสามารถเลือกวิธีนี้ได้
ตัวอย่างโค้ด(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 + ผม * 100;
ลอย y = 150 + j * 100;
วงรี(x, y, 60, 60);
println(i + ":" + j);
}
}
}
[/cceN_cpp]
ในการใช้ลูปที่ซ้อนกันเป็นครั้งแรก คุณต้องหาความสัมพันธ์เชิงตรรกะของมัน การนำโค้ดไปใช้ในโปรแกรมนั้นมักจะเริ่มจากล่างขึ้นบน ดังนั้นการดำเนินการครั้งแรกจึงเป็นวงรอบนอกสุดอย่างแน่นอน ทุกครั้งที่วงนอกทำงานครั้งเดียว ลูปภายในจะทำงานอย่างต่อเนื่องจนกว่าจะไม่เป็นไปตามเงื่อนไขอีกต่อไป หลังจากนั้นจะเริ่มการทำงานของวงรอบนอกที่สอง หลังจากการดำเนินการที่สองเริ่มต้นขึ้น ลูปภายในจะดำเนินการต่อไปจนกว่าจะไม่เป็นไปตามเงื่อนไข การทำซ้ำเช่นนี้จะเกิดขึ้นจนกว่าเงื่อนไขทั้งหมดจะไม่เป็นที่น่าพอใจและหลุดออกจากลูป
ในโค้ดข้างต้น เนื้อหาลูปในลูปด้านนอกทำงานทั้งหมด 5 ครั้ง ในขณะที่เนื้อหาลูปในลูปภายในทำงาน 25 ครั้ง ภายใน 25 เท่า ตามความแตกต่างของค่า i, j เราสามารถรับรองพิกัดแนวนอนและแนวตั้งของวงกลมแยกกันได้ ฉันได้ฝังส่วนของ print คุณสามารถสังเกตผลลัพธ์ของข้อมูลและคิดถึงการเปลี่ยนแปลงได้ ด้วยสองลูปที่ซ้อนกันเท่านั้น เราสามารถสัมผัสกับการรวมกันของข้อมูล i, j
เคล็ดลับ
สำหรับการวนซ้ำในเลเยอร์ที่สองมักจะควบแน่นด้วยแท็บที่จุดเริ่มต้น ซึ่งจะทำให้โครงสร้างโค้ดมีความชัดเจนมากขึ้น คุณต้องตั้งชื่อตัวแปรท้องถิ่นในสองชั้นของ for loop ด้วยชื่อที่ต่างกัน ในหมู่มัน "i", "j", "k" เป็นคำที่ใช้กันมากที่สุด
ใช้ "i", "j" ได้อย่างยืดหยุ่น
ชื่อตัวแปรสองตัวของ "i", "j" แทนตัวแปรโลคัลของเลเยอร์ 2 ของ for loop ตัวอย่างด้านล่างจะทำให้คุณเข้าใจ "i" "j" ได้อย่างลึกซึ้งยิ่งขึ้น ตามค่าต่างๆ ของ "i", "j" เราสามารถป้อนพารามิเตอร์เพื่อจัดกลุ่มองค์ประกอบได้
ตัวอย่างโค้ด (5-13): [cceN_cpp theme="dawn"] การตั้งค่าเป็นโมฆะ () {
ขนาด (700, 700);
พื้นหลัง(0);
ไม่มีจังหวะ ();
}
โมฆะวาด () {
พื้นหลัง(0);
เติม(250, 233, 77);
สำหรับ (int i = 0; i <7; i++) {
สำหรับ (int j = 0; j <7; j++) {
pushMatrix();
แปล(50 + ฉัน * 100, 50 + j * 100);
// การตั้งค่า 1
// มุมลอย = บาป (มิลลิวินาที () / 1000.0) * PI/2;
// การตั้งค่า 2
//อัตราส่วนลอย = i/7.0;
// มุมลอย = บาป (มิลลิวินาที () / 1000.0 + อัตราส่วน * (PI/2)) * PI/2;
// การตั้งค่า 3
อัตราส่วนลอย = (i * 7 + j)/49.0;
มุมลอย = บาป (มิลลิวินาที () / 1000.0 + อัตราส่วน * (PI/2)) * PI/2;
หมุน(มุม);
โหมดแก้ไข (CENTER);
// วาดรูป 1
ตรง(0, 0, 80, 80);
// วาดรูป 2
// เรียง(0, 0, 100, 20);
// วาดรูป 3
//rect(0, 0, อัตราส่วน * 50);
popMatrix();
}
}
} [/cceN_cpp]
คำอธิบายรหัส
rectMode(CENTER) สามารถเปลี่ยนวิธีการวาดสี่เหลี่ยม พารามิเตอร์สองแบบเดิมของ rect ใช้เพื่อกำหนดพิกัดของมุมบนซ้ายของ sqaure หลังจากที่เราเริ่มคำสั่งนี้ พารามิเตอร์ทั้งสองนี้จะใช้ในการตั้งค่าพิกัดสำหรับจุดศูนย์กลางสี่เหลี่ยมเนื่องจากที่นี่เราใช้การหมุนแบบเดิมผ่านการหมุน ดังนั้นเราจึงต้องใช้วิธีนี้เพื่อวาดจุดศูนย์กลางไปยังจุดเดิมของพิกัด
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 ในที่สุด ค่าเหล่านี้มีอิทธิพลต่ออินพุตพารามิเตอร์ของฟังก์ชัน sin ผ่านอัตราส่วน สิ่งนี้ได้เปลี่ยนการเปลี่ยนแปลงมุมเป็นระยะ เนื่องจากเอฟเฟกต์จริงของการตั้งค่า 2 และการตั้งค่า 3 นั้นไม่ชัดเจนนักในกราฟิกแอนิเมชั่น เราจึงสามารถสังเกตได้จากภาพหน้าจอต่อไปนี้
วาดภาพ 2 (ซ้าย: การตั้งค่า 2; ขวา: การตั้งค่า 3)
วาดภาพ 3 (ซ้าย: การตั้งค่า 2; ขวา: การตั้งค่า 3)
ในภาพแรก อัตราส่วนจะใช้ส่งผลต่อมุมการหมุนของสี่เหลี่ยมจัตุรัส ในขณะที่ภาพที่ 2 จะเป็นการควบคุมรัศมีของวงกลมโดยตรง เราจะเห็นว่ามันใช้ประโยคค่าของ i:
อัตราส่วนลอย = i/7.0;
การเปลี่ยนแปลงองค์ประกอบแนวตั้งนั้นสอดคล้องกัน เนื่องจากพิกัดแนวนอนสำหรับการควบคุมรูปภาพนั้นขึ้นอยู่กับค่าของ i เท่านั้น ดังนั้น patterms ที่มีพิกัดแนวนอนเหมือนกันจะเหมือนกัน และค่าอัตราส่วน มุมหมุน และรัศมีของวงกลมก็เหมือนกันด้วย
ในเวลาเดียวกัน เราใช้ i, j ประโยค:
อัตราส่วนลอย = (i * 7 + j)/49.0;
มันสามารถอธิบาย "การไล่ระดับสี" ที่นี่ ด้วยวิธีคูณปัจจัย มันรวมอิทธิพลของแถวและคอลัมน์ ดังนั้นแต่ละองค์ประกอบจึงแตกต่างกัน
ขั้นตอนที่ 7: ในขณะที่วนรอบ
มีพี่ชายสำหรับลูป นั่นคือในขณะที่วนรอบ สิ่งที่ลูปทำได้ ในขณะที่ลูปก็ทำได้เช่นกัน แต่ความถี่การใช้ของ while loop ใน creativeCoding นั้นไม่สูงเท่ากับการวนซ้ำ
ตัวอย่างโค้ด (5-14):[cceN_cpp theme="dawn"] void setup(){
int a = 0;
ในขณะที่ (<10){
println(ก);
++;
}
} [/cceN_cpp]
โครงสร้างไวยากรณ์ของ while เข้าใจง่ายกว่าสำหรับ. เราสามารถสร้างตัวแปรก่อนในขณะที่คำสั่ง จากนั้นกรอกนิพจน์ภายในวงเล็บเหลี่ยม เมื่อพอใจแล้ว ให้ดำเนินการประโยคภายใน loop body ในที่สุดเราก็ใส่นิพจน์ในเนื้อหาของลูปเพื่ออัปเดตตัวแปร จากนั้นในขณะที่ลูปเสร็จสิ้น สำหรับ loop time ที่มั่นใจ เรามักใช้ for loop สำหรับค่าตัวแปรอนันต์ เราขอแนะนำให้คุณใช้ while loop
คิด:
พยายามใช้องค์ประกอบพื้นฐานทุกประเภทเพื่อแทนที่องค์ประกอบการวาดใน for loop เพื่อสร้างพู่กันต่างๆ
รวมกับฟังก์ชันตรีโกณมิติที่อ้างถึงในบทที่แล้ว พยายามแก้ไขแปรง "จุดกระเจิง" ให้เป็นแปรงทรงกลม
พยายามสร้างดอทเมทริกซ์สองมิติด้วย for loop เท่านั้น
Next Chapter Preview เช่นเดียวกับหลักสูตรนี้ คุณจะพบทุกความรู้ใหม่ที่คุณเรียนรู้ ความเป็นไปได้ของการเล่นจะเพิ่มขึ้นอย่างมากในทันที โปรแกรมเป็นกล่องแพนดอร่า ทุกสิ่งที่คุณจินตนาการได้ มันสามารถทำให้คุณได้ ดังนั้นจึงไม่มีเหตุผลที่เราจะไม่ได้เรียนภาษานี้ซึ่งสามารถสื่อสารกับคอมพิวเตอร์ได้ ในบทต่อไป เราจะแนะนำคำสั่งควบคุมกระบวนการอื่นหากคุณ สามารถควบคุมการไหลของกระบวนการและสร้างผลลัพธ์ที่ซับซ้อนและเปลี่ยนแปลงได้ ด้วยคำสั่ง if คุณสามารถสร้างเกมผจญภัยด้วยข้อความของคุณเองได้อย่างง่ายดาย! บทความนี้มาจากนักออกแบบ Wenzy การอ่านที่เกี่ยวข้อง: คำแนะนำการเขียนโปรแกรมที่น่าสนใจสำหรับนักออกแบบ -- การประมวลผลการสัมผัสเบื้องต้น คำแนะนำการเขียนโปรแกรมที่น่าสนใจสำหรับนักออกแบบ -- สร้างโปรแกรมการประมวลผลครั้งแรกของคุณ คำแนะนำการเขียนโปรแกรมที่น่าสนใจสำหรับนักออกแบบ – ทำให้ภาพของคุณทำงาน (ตอนที่หนึ่ง) คำแนะนำการเขียนโปรแกรมที่น่าสนใจสำหรับนักออกแบบ – ทำให้ภาพของคุณทำงาน (ส่วนที่สอง)
ขั้นตอนที่ 8: แหล่งที่มา
บทความนี้มาจาก:
หากคุณมีคำถามใด ๆ คุณสามารถติดต่อ: [email protected]