เนื้อหา

• แผนภูมิเปรียบเทียบ
• คำจำกัดความของ for loop
• วากยสัมพันธ์
• สำหรับแต่ละลูปและไวยากรณ์
• ตัวอย่าง
• คำจำกัดความของ while loop
• วากยสัมพันธ์
• ตัวอย่าง
• บันทึก:
• สรุป:

ใน C ++ และ Java คำสั่งการวนซ้ำสำหรับลูปในขณะที่ลูปและ do-while ลูปอนุญาตให้ชุดคำสั่งถูกเรียกใช้ซ้ำหลายครั้งจนกว่าเงื่อนไขจะเป็นจริงและสิ้นสุดลงทันทีที่เงื่อนไขเป็นเท็จ เงื่อนไขในคำสั่งการวนซ้ำอาจกำหนดไว้ล่วงหน้าเป็นในวงรอบหรือปลายเปิดในขณะที่วง

มีรูปแบบวนรอบสำหรับ ’ใน C ++ ที่มีนัยเพื่อเพิ่มการบังคับใช้พลังงานและความยืดหยุ่น ตัวอย่างเช่น the for loop ช่วยให้เราสามารถใช้ตัวแปรมากกว่าหนึ่งตัวในลูปเพื่อควบคุมมันและการใช้ฟังก์ชัน converge ด้วย with for ’ ในทางกลับกันขณะที่ลูปเราไม่สามารถใช้รูปแบบต่าง ๆ ได้ซึ่งจะต้องใช้กับไวยากรณ์มาตรฐาน

มีความแตกต่างที่สำคัญบางอย่างระหว่างและถึงลูปซึ่งจะอธิบายเพิ่มเติมด้วยความช่วยเหลือของกราฟเปรียบเทียบ

1. แผนภูมิเปรียบเทียบ
2. คำนิยาม
3. ความแตกต่างที่สำคัญ
4. ข้อสรุป

แผนภูมิเปรียบเทียบ

พื้นฐานสำหรับการเปรียบเทียบ	สำหรับ	ในขณะที่
การประกาศ	สำหรับ (การกำหนดค่าเริ่มต้น; เงื่อนไข; การทำซ้ำ) { // เนื้อหาของ for loop }	ในขณะที่ (เงื่อนไข) { งบ; // body of loop }
รูป	การกำหนดค่าเริ่มต้นการตรวจสอบเงื่อนไขคำสั่งการทำซ้ำจะถูกเขียนที่ด้านบนของลูป	มีเพียงการเริ่มต้นและการตรวจสอบสภาพที่ทำที่ด้านบนของลูป
ใช้	ห่วงสำหรับใช้เฉพาะเมื่อเรารู้จำนวนการวนซ้ำแล้ว	ห่วง while ใช้เฉพาะเมื่อไม่ทราบจำนวนซ้ำซ้ำอย่างแน่นอน
เงื่อนไข	หากเงื่อนไขไม่ได้ถูกนำไปใช้สำหรับลูปดังนั้นลูปจะวนซ้ำไม่มีที่สิ้นสุด	หากเงื่อนไขไม่ได้ถูกวางในขณะที่ลูปจะมีข้อผิดพลาดในการรวบรวม
การเริ่มต้น	ในการวนรอบการเริ่มต้นครั้งเดียวจะไม่ซ้ำ	ในขณะที่ลูปถ้าเริ่มต้นจะทำในระหว่างการตรวจสอบสภาพจากนั้นเริ่มต้นจะทำในแต่ละครั้งที่วนซ้ำ
คำสั่งซ้ำ	ในสำหรับคำสั่งวนซ้ำจะถูกเขียนที่ด้านบนดังนั้นดำเนินการเฉพาะหลังจากที่งบทั้งหมดในวงจะถูกดำเนินการ	ในขณะที่ลูปคำสั่งวนซ้ำสามารถเขียนได้ทุกที่ในลูป

คำจำกัดความของ for loop

ใน Java มีสองรูปแบบ สำหรับ ลูป รูปแบบแรกคือรูปแบบ "ดั้งเดิม" และรูปแบบที่สองคือรูปแบบ "สำหรับแต่ละคน"

วากยสัมพันธ์

รูปแบบทั่วไปของดั้งเดิมสำหรับคำสั่งวนรอบ

สำหรับ (การกำหนดค่าเริ่มต้น; เงื่อนไขการทำซ้ำ) {// body of for loop}

• การเริ่มต้น - การเริ่มต้นของตัวแปรควบคุมการวนรอบของ for loop นั้นจะดำเนินการเพียงครั้งเดียวในระหว่างการทำซ้ำครั้งแรกของการวนซ้ำ ที่นี่ตัวแปรการควบคุมลูปจะเริ่มต้นได้บางครั้งหากไม่ได้ใช้ตัวแปรลูปอีกครั้งที่ใดก็ได้ในโปรแกรมและใช้เป็นตัวแปรการควบคุมของลูปก็จะมีการประกาศและเริ่มต้นในลูป ‘for’
• เงื่อนไข - เงื่อนไขของลูป ‘for’ จะถูกดำเนินการทุกครั้งที่วนซ้ำ
• การเพิ่มและการวนซ้ำ- คำสั่งวนซ้ำเป็นนิพจน์ที่เพิ่มหรือลดตัวแปรควบคุมการวนซ้ำ

เมื่อใดก็ตามที่ลูปถูกดำเนินการเงื่อนไขการเตรียมใช้งานจะถูกดำเนินการก่อน จากนั้นตรวจสอบสภาพ หากเงื่อนไขเป็นที่พอใจร่างกายของลูปจะถูกดำเนินการแล้วคำสั่งการทำซ้ำจะถูกดำเนินการ จากนั้นอีกครั้งเงื่อนไขจะถูกตรวจสอบเพื่อทราบว่าลูปจะวนซ้ำอีกหรือจะยุติ

ใน Java คำสั่งการเริ่มต้นและคำสั่งการวนซ้ำอาจมีมากกว่าหนึ่งคำสั่ง แต่ละคำสั่งถูกคั่นด้วยเครื่องหมายจุลภาคโดยคั่นด้วยเครื่องหมายจุลภาคใน Java เครื่องหมายจุลภาคเป็นตัวคั่นขณะที่ใน C ++ หมายถึง "เครื่องหมายจุลภาค" เป็นตัวดำเนินการที่สามารถใช้ในนิพจน์ที่ถูกต้องใด ๆ

สำหรับแต่ละลูปและไวยากรณ์

แบบฟอร์ม "for-each" เป็นการปรับปรุงสำหรับลูป รูปแบบทั่วไปของการวนซ้ำแต่ละครั้งมีดังนี้

for (พิมพ์ iter_variable: collection) statement-block

ที่นี่“ ประเภท” ระบุประเภทของตัวแปรการทำซ้ำตามด้วยตัวแปรการทำซ้ำ ตัวแปรการวนซ้ำจะได้รับองค์ประกอบจากตัวแปรการรวบรวม ประเภทจะต้องเหมือนกับประเภทขององค์ประกอบที่เก็บไว้ในตัวแปรคอลเลกชัน for for each form ของลูปจะทำการวนซ้ำของลูปโดยอัตโนมัติตั้งแต่เริ่มต้นจนสิ้นสุดการเข้าถึงค่าตามลำดับ

ตัวอย่าง

มีคอลเลกชันหลากหลายประเภทที่ใช้สำหรับลูป มาพูดคุยกับอาร์เรย์เป็นชุดสะสม

public class main {โมฆะ static public main (String args) {int array = {10, 20, 30, 40, 50, 60} int เพิ่ม = 0; สำหรับ (int c: array) {System.out.ln ("ค่าใน c" + c); เพิ่ม = เพิ่ม + c; } System.out.ln ("additon ขององค์ประกอบอาร์เรย์คือ" + เพิ่ม); }} // ค่าเอาต์พุตใน c 10 ค่าใน c 20 ค่าใน c 30 ค่าใน c 40 ค่าใน c 50 ค่าใน c 60 additon ขององค์ประกอบอาร์เรย์คือ 210

ที่นี่ ‘c’ เป็นตัวแปรการทำซ้ำ มันได้รับค่าจากอาร์เรย์หนึ่งครั้งจากดัชนีต่ำสุดไปจนถึงดัชนีสูงสุดในอาร์เรย์ ที่นี่วนซ้ำจนกว่าองค์ประกอบทั้งหมดของอาร์เรย์จะมีการตรวจสอบ มีความเป็นไปได้ที่จะยุติการวนซ้ำระหว่างโดยใช้“ break” อย่างไรก็ตามการเปลี่ยนแปลงในตัวแปรการวนซ้ำไม่มีผลกับอาเรย์เนื่องจากเป็นเพียงตัวแปรแบบอ่านอย่างเดียว

คำจำกัดความของ while loop

ในขณะที่ loop เป็น loop พื้นฐานที่สุดที่มีใน C ++ และ Java การทำงานของ a while loop นั้นคล้ายกันในทั้ง C ++ และ Java

วากยสัมพันธ์

การประกาศของลูป while นั้นเป็นดังนี้

ในขณะที่ (เงื่อนไข) {คำสั่ง; // body of loop}

ในขณะที่ลูปเริ่มต้นตรวจสอบเงื่อนไขแล้วดำเนินการคำสั่งจนกว่าเงื่อนไขในขณะที่ลูปกลายเป็นจริง เงื่อนไขในขณะที่ลูปสามารถเป็นนิพจน์บูลีนใด ๆ เมื่อนิพจน์ส่งคืนค่าที่ไม่เป็นศูนย์เงื่อนไขจะเป็นจริงและหากนิพจน์ส่งคืนค่าศูนย์เงื่อนไขจะกลายเป็นเท็จ

ถ้าเงื่อนไขเป็นจริงแล้ววนซ้ำตัวเองและถ้าเงื่อนไขกลายเป็นเท็จแล้วการควบคุมผ่านไปยังบรรทัดถัดไปของรหัสทันทีตามด้วยวง ประโยคคำสั่งหรือ body loop อาจเป็นข้อความว่างเปล่าหรือข้อความเดี่ยวหรือบล็อกข้อความสั่งก็ได้

ตัวอย่าง

เรามาพูดคุยเกี่ยวกับการทำงานของลูปสักครู่ ในตัวอย่างด้านล่างรหัสจะมีตั้งแต่ 1 ถึง 10

// ตัวอย่างอยู่ใน Java public class main {public static void main (String args) {int n = 0; ในขณะที่ (n <10) {n ++; System.out.ln ("n =" + n); }}} // เอาต์พุต n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10

ที่นี่ค่าเริ่มต้นของ "n" คือ 0 ซึ่งทำให้เงื่อนไขในขณะที่วงจริง จากนั้นการควบคุมจะเข้าสู่เนื้อความของ while loop และค่า n ’จะเพิ่มขึ้นตามคำสั่งแรกในเนื้อหาของ a while loop ค่าของ ‘n’ เป็น ed จากนั้นการควบคุมกลับไปที่เงื่อนไขในขณะที่ลูปตอนนี้ค่าของ ‘n’ เป็น 1 ซึ่งเป็นไปตามเงื่อนไขอีกครั้งและร่างกายของลูปจะดำเนินการอีกครั้ง สิ่งนี้จะดำเนินต่อไปจนกว่าเงื่อนไขจะเป็นจริงทันทีที่เงื่อนไขเป็นเท็จการวนซ้ำจะถูกยกเลิก

เช่นเดียวกับ ‘for’ loop ‘while’ สามารถเริ่มต้นตัวแปรควบคุมที่ด้านบนของ loop เช่นในระหว่างการตรวจสอบสภาพ

// ตัวอย่างเช่นในขณะที่ ((ch = getchar ())! = A) {System.out.ln ("ตัวอักษรอินพุต" + ch); }

ที่นี่ตัวแปรควบคุม 'ch' จะเริ่มต้นได้และเงื่อนไขของลูปจะได้รับการยืนยันที่ด้านบนของลูป

บันทึก:

อาจเป็นห่วงหรือห่วงชั่วขณะหากมีเพียงคำสั่งเดียวในเนื้อความของลูปไม่จำเป็นต้องใช้เครื่องมือจัดฟันแบบโค้งในสภาพนั้น

1. ใน สำหรับ วนซ้ำการเริ่มต้นการตรวจสอบเงื่อนไขและการเพิ่มหรือลดลงของตัวแปรการทำซ้ำจะทำอย่างชัดเจนในไวยากรณ์ของวงเท่านั้น เมื่อเทียบกับใน ในขณะที่ วนเราสามารถเริ่มต้นและตรวจสอบสภาพในไวยากรณ์ของวน
2. เมื่อเราทราบจำนวนการวนซ้ำที่ต้องเกิดขึ้นในการประมวลผลของลูปเราจะใช้ สำหรับ ห่วง ในทางกลับกันหากเราไม่ทราบจำนวนการวนซ้ำที่ต้องเกิดขึ้นในการวนซ้ำเราจะใช้ ในขณะที่ ห่วง
3. หากคุณล้มเหลวที่จะนำคำสั่งเงื่อนไขมา สำหรับ ลูปมันจะนำไปสู่การวนซ้ำที่ไม่สิ้นสุดของลูป ในทางตรงกันข้ามหากคุณไม่สามารถใส่คำสั่งเงื่อนไขใน ในขณะที่ มันจะนำไปสู่ข้อผิดพลาดในการรวบรวม
4. คำสั่งการเริ่มต้นในรูปแบบของ สำหรับ วนรอบจะดำเนินการเพียงครั้งเดียวเมื่อเริ่มต้นการวนรอบ ในทางกลับกันถ้า ในขณะที่ loop กำลังดำเนินการคำสั่งการเริ่มต้นในไวยากรณ์แล้วคำสั่งเริ่มต้นในขณะที่วงจะดำเนินการในแต่ละครั้งที่วนซ้ำ
5. คำสั่งการทำซ้ำใน สำหรับ วงจะดำเนินการหลังจากที่ร่างกายสำหรับการดำเนินการวง ในทางตรงกันข้ามคำสั่งการวนซ้ำสามารถเขียนได้ทุกที่ในเนื้อหาของ ในขณะที่ วนรอบดังนั้นอาจมีคำสั่งบางคำสั่งที่เรียกใช้งานหลังจากการดำเนินการคำสั่งวนซ้ำในเนื้อความของ while loop

สรุป:

สำหรับลูปและขณะที่ลูปทั้งคู่เป็นคำสั่งการวนซ้ำ แต่ทั้งคู่มีคุณสมบัติที่แตกต่างกัน for loop มีการประกาศทั้งหมด (การกำหนดค่าเริ่มต้น, เงื่อนไข, การทำซ้ำ) ที่ด้านบนของเนื้อความของลูป ในทางกลับกันในขณะที่ลูปเริ่มต้นเท่านั้นและเงื่อนไขอยู่ที่ด้านบนของร่างกายของลูปและการทำซ้ำอาจถูกเขียนที่ใดก็ได้ในร่างกายของลูป