การใช้ Do While: เขียนโปรแกรมโดยไม่ใช้ Marks

การใช้ do while ในภาษา C++

Do-while คืออะไร?

อะไรคือ Do-while loop?

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

โครงสร้างของคำสั่ง do while

โครงสร้างของคำสั่ง do while ในภาษา C++ มีรูปแบบดังนี้:

do {
// กลุ่มคำสั่งที่ต้องการทำซ้ำ
} while (เงื่อนไข);

แต่ละส่วนของโครงสร้างประกอบด้วยคำสั่งและเงื่อนไขดังนี้:

– do: คำสั่งที่ต้องการให้ทำซ้ำ
– { เงื่อนไข }: ส่วนของเงื่อนไขจะกำหนดเงื่อนไขที่จำเป็นต้องเป็นจริงเพื่อทำให้ลูปทำงานซ้ำ
– while: เงื่อนไขที่จำเป็นต้องเป็นจริงเพื่อทำให้ลูปทำงานซ้ำ ถ้าเงื่อนไขเป็นเท็จ จะออกจากลูปทันที

การทำงานของคำสั่ง do while

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

ตำแหน่งของเงื่อนไขในคำสั่ง do while

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

ตัวอย่างการใช้งาน do while เพื่อทำซ้ำประโยคเดียว

สมมติว่าคุณต้องการให้ผู้ใช้ป้อนตัวเลขจำนวนเต็มบวกเรื่อยๆ จนกว่าจะป้อนค่าที่น้อยกว่า 1 โปรแกรมที่ใช้ do while สามารถเขียนได้ดังนี้:

“`cpp
#include
using namespace std;

int main() {
int num;

do {
cout << "ป้อนตัวเลขจำนวนเต็มบวก: "; cin >> num;
} while (num >= 1);

cout << "ค่าที่ป้อนเป็นค่าติดลบ โปรแกรมจบการทำงาน"; return 0; } ``` ในตัวอย่างโปรแกรมข้างต้น คำสั่งที่อยู่ในบรรทัดที่ 8-9 จะถูกทำซ้ำซ้ำเมื่อผู้ใช้ป้อนค่าที่มากกว่าหรือเท่ากับ 1 และถ้าผู้ใช้ป้อนค่าที่น้อยกว่า 1 โปรแกรมจะออกจากลูป do while และแสดงข้อความ "ค่าที่ป้อนเป็นค่าติดลบ โปรแกรมจบการทำงาน" การใช้งาน do while เพื่อทำซ้ำกับลำดับคำสั่งหลายๆ คำสั่ง โดยปกติแล้วคำสั่งในบรรทัดที่อยู่ในเครื่องหมายวงเล็บปีกกาปิดของคำสั่ง do จะถูกใช้ในการทำงานซ้ำ แต่หากคุณต้องการให้ทำงานซ้ำแบบเดียวกับลำดับคำสั่งหลายๆ คำสั่ง คุณสามารถใช้วงเล็บปีกกาเพื่อรวมคำสั่งเหล่านั้นไว้ในบรรทัดเดียวกัน ตัวอย่างการใช้งาน do while เพื่อทำซ้ำกับลำดับคำสั่งหลายคำสั่ง: ```cpp #include
using namespace std;

int main() {
int i = 1;

do {
cout << "ค่าของ i: " << i << endl; i++; } while (i <= 5); return 0; } ``` ในตัวอย่างโปรแกรมข้างต้น คำสั่งที่อยู่ในบรรทัดที่ 7-9 จะถูกทำซ้ำซ้ำเมื่อค่าของตัวแปร i มีค่าน้อยกว่าหรือเท่ากับ 5 และถ้าค่าของตัวแปร i เกิน 5 โปรแกรมจะออกจากลูป do while และจบการทำงาน ข้อดีและข้อเสียของการใช้งานคำสั่ง do while ข้อดี: 1. กำหนดให้ตัวแปรถูกประมวลผลอย่างน้อย 1 ครั้งก่อนที่เงื่อนไขจะถูกตรวจสอบ ดังนั้นจะมีการประมวลผลอย่างน้อยหนึ่งครั้งถึงแม้ว่าเงื่อนไขเริ่มต้นจะเป็นเท็จเมื่อเริ่มต้นในการทำงาน 2. ทำให้ลูปทำงานมากกว่าหนึ่งครั้งเมื่อเงื่อนไขเป็นจริง ข้อเสีย: 1. อาจทำให้โปรแกรมทำงานไปทำนานไม่จำเป็นเมื่อเงื่อนไขเริ่มต้นเป็นเท็จในทันที 2. หากมีตัวแปรหรือสถานะที่มีค่าเริ่มต้นไม่ถูกต้อง อาจทำให้โปรแกรมติดลูปและไม่สามารถทำงานต่อได้ การออกจากลูป do while ทันที ในบางกรณีคุณอาจต้องการออกจากลูป do while ทันทีหากเงื่อนไขที่กำหนดเป็นเท็จ ในกรณีนี้คุณสามารถใช้คำสั่ง break เพื่อออกจากลูปได้ ตัวอย่างการใช้งานคำสั่ง break เพื่อออกจากลูป do while: ```cpp #include
using namespace std;

int main() {
int i = 1;

do {
if (i == 3) {
break;
}

cout << "ค่าของ i: " << i << endl; i++; } while (i <= 5); cout << "โปรแกรมจบการทำงาน"; return 0; } ``` ในตัวอย่างโปรแกรมข้างต้น เมื่อค่าของตัวแปร i เท่ากับ 3 โปรแกรมจะใช้คำสั่ง break เพื่อออกจากลูป do while ทันที และพิมพ์ข้อความ "โปรแกรมจบการทำงาน" การป้องกันการทำซ้ำไม่จบในคำสั่ง do while เงื่อนไขในคำสั่ง do while เป็นสิ่งสำคัญในการป้องกันการทำซ้ำไม่จบ เมื่อเงื่อนไขเป็นเท็จ ลูปจะถูกทำงานเพียงครั้งเดียวและโปรแกรมจะดำเนินการไปยังคำสั่งถัดไปที่หลังลูป ตัวอย่างการใช้งานคำสั่ง do while ซึ่งไม่มีเงื่อนไขที่จะเป็นเท็จ: ```cpp #include
using namespace std;

int main() {
int i = 1;

do {
cout << "ค่าของ i: " << i << endl; i++; } while (i <= 5); cout << "โปรแกรมจบการทำงาน"; return 0; } ``` ในตัวอย่างโปรแกรมข้างต้น เงื่อนไขในลูป do while คือ i <= 5 ซึ่งเป็นเงื่อนไขที่จะเป็นจริงเสมอในขณะที่ i มีค่าไม่เกิน 5 ดังนั้นลูปจะทำงานซ้ำจนกว่า i จะมีค่าเกิน 5 และภายหลังจากนั้นโปรแกรมจะดำเนินการต่อไป การใช้คำสั่ง break และ continue ในคำสั่ง do while คำสั่ง break ใช้สำหรับการออกจากลูป do while อย่างกะทันหัน โดยไม่สนใจเงื่อนไขใดๆ นอกเหนือจากเงื่อนไขเริ่มต้นของลูป และคำสั่ง continue ใช้ในการกระโดดผ่านคำสั่งที่เหลือในลูป do while และเริ่มต้นรอบถัดไป ตัวอย่างการใช้คำสั่ง break และ continue ในคำสั่

Do-while คือ อะไร?

ในการเขียนโปรแกรม อาจมีความจำเป็นที่จะต้องทำซ้ำขั้นตอนในบางครั้ง โดยไม่รู้จำนวนการทำซ้ำล่วงหน้า ในกรณีเช่นนี้ โครงสร้างควบคุมลูป do-while จะเป็นเครื่องมือที่มีประโยชน์ เพื่อช่วยให้สามารถทำซ้ำขั้นตอนได้โดยอัตโนมัติจนกว่าเงื่อนไขจะเป็นเท็จ (false)

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

รูปแบบการใช้งานของ do-while คือ:
“`
do {
// โค้ดที่ต้องการให้ทำซ้ำ
} while (เงื่อนไขที่ต้องการตรวจสอบ);
“`

การทำงานของ do-while เริ่มต้นที่การทำซ้ำของโค้ดภายใน do จากนั้นนำเงื่อนไขใน while มาตรวจสอบ ถ้าเงื่อนไขเป็นจริง (true) โปรแกรมจะทำการทำซ้ำภายใน do อีกครั้ง ในกรณีที่เงื่อนไขเป็นเท็จ (false) โปรแกรมจะออกจากการทำงานใน do-while และดำเนินการทำงานในส่วนต่อไปของโค้ด

ตัวอย่างการใช้งาน do-while:

“`
int count = 1;
do {
System.out.println(“รอบที่ ” + count);
count++;
} while (count <= 5); ``` ผลลัพธ์ที่ได้จากโค้ดด้านบนจะเป็นการพิมพ์ข้อความ "รอบที่" ตามด้วยตัวเลข 1-5 บรรทัดละรอบ โดยที่เงื่อนไขใน while คือ ตัวแปร count น้อยกว่าหรือเท่ากับ 5 ในขณะแทรกภายในลูป ค่าของตัวแปร count จะเพิ่มขึ้นทีละ 1 ไปเรื่อยๆ ซึ่งจะทำให้เงื่อนไขเป็นเท็จ และสิ้นสุดลูปการทำงานเมื่อค่าของตัวแปร count เท่ากับ 6 คำถามที่พบบ่อยเกี่ยวกับ do-while: 1. ต่างจาก while อย่างไร? do-while และ while เป็นโครงสร้างควบคุมลูปที่ใช้ในการทำซ้ำหนึ่งรอบ โดย while จะตรวจสอบเงื่อนไขก่อนทำงานในลูป ในขณะที่ do-while จะทำซ้ำก่อน แล้วค่อยตรวจสอบเงื่อนไข 2. ทำไมถึงต้องใช้ do-while แทน while? do-while มักถูกใช้ในกรณีที่ต้องการให้โค้ดภายในลูปทำงานอย่างน้อยหนึ่งครั้ง โดยไม่ว่าเงื่อนไขจะเป็นจริงหรือเท็จ 3. อาจใช้ do-while ในสถานการณ์ใดบ้าง? do-while สามารถใช้กับสถานการณ์ที่ต้องการให้โค้ดภายในลูปทำงานอย่างน้อยหนึ่งครั้ง และไม่สามารถทราบจำนวนรอบการทำซ้ำล่วงหน้าได้ เช่น การอ่านข้อมูลจากพอร์ตซีเรียล (serial port) ที่จะต้องรอรับข้อมูลจากอุปกรณ์ภายนอกจนกว่าจะมีข้อมูลเข้ามา 4. ต้องการทำซ้ำมากสุดกี่ครั้งใน do-while? จำนวนครั้งการทำซ้ำใน do-while ไม่มีจำกัด มันจะทำซ้ำเป็นเวลาไม่จำกัดตามเงื่อนไขที่กำหนด โดยจะเก็บรอค่าของเงื่อนไขที่ใช้ในการตรวจสอบซ้ำเพื่อตัดสินใจว่ายังคงทำงานภายในลูปหรือไม่ 5. เงื่อนไขใน do-while เป็นจริงเริ่มต้น โค้ดภายในทำงานกี่ครั้ง? เมื่อเงื่อนไขใน do-while เป็นจริงเริ่มต้น โค้ดภายในจะถูกทำงานอย่างน้อยหนึ่งครั้ง แล้วตรวจสอบเงื่อนไขใหม่ เพื่อหาว่าควรทำซ้ำอีกครั้งหรือไม่ 6. จะทำซ้ำแม้แต่ในกรณีเงื่อนไขเป็นเท็จ ได้หรือไม่? ไม่ ถ้าเงื่อนไขใน do-while เป็นเท็จอยู่แล้ว โค้ดภายในจะไม่ถูกทำซ้ำ เนื่องจาก do-while ต้องทำซ้ำเพียงครั้งเดียวก่อนที่จะตรวจสอบเงื่อนไข การใช้งานโครงสร้างควบคุมลูป do-while สามารถช่วยให้โปรแกรมเขียนโค้ดที่ทำงานในรูปแบบการทำซ้ำเงื่อนไข โดยที่ไม่จำเป็นต้องรู้จำนวนการทำซ้ำล่วงหน้า สามารถเพิ่มความยืดหยุ่นให้แก่โค้ดที่เขียนได้ และใช้ในสถานการณ์ที่ต้องการาารทำซ้ำอย่างน้อยหนึ่งครั้ง ไม่ว่าจะมีผลในเงื่อนไขหรือไม่ก็ตาม

บทความ: ลูป Do-While ในภาษาไทย

ในภาษาโปรแกรมมิ่งมากมาย เราสามารถใช้ลูป (loop) เพื่อทำซ้ำขั้นกระบวนการบางอย่างได้ เพื่อให้โปรแกรมทำงานได้อย่างมีประสิทธิภาพและจัดการกับข้อมูลทั้งหมดที่เราต้องการ มีหลายลูปที่เราสามารถใช้ได้ อย่างไรก็ตาม ในบทความนี้ เราจะพูดถึงลูป Do-While ซึ่งเป็นวิธีการลูปที่สำคัญและเป็นที่นิยมในการเขียนโปรแกรม

ลูป Do-While ใช้เพื่อให้โปรแกรมทำซ้ำกระบวนการในบล็อกของโค้ดไว้จนกว่าเงื่อนไขที่กำหนดในวงเล็บของ Do จะเป็นเท็จ (false) การทำงานของลูปทำให้โปรแกรมสามารถทำซ้ำโค้ดในบล็อกได้หลายครั้ง โดยมักใช้งานร่วมกับการรับข้อมูลจากผู้ใช้หรือการประมวลผลข้อมูลในรูปแบบที่ต้องการและไม่รู้ล่วงหน้า

คำสั่งของลูป Do-While จะมีรูปแบบดังนี้:

“`
do {
// โค้ดที่จะทำซ้ำ
} while (เงื่อนไข);
“`

เงื่อนไขเป็นตัวควบคุมที่ต้องเป็นชนิดข้อมูลชนิด Boolean ซึ่งเมื่อเงื่อนไขเป็นจริง (true) โปรแกรมจะทำซ้ำโค้ดในบล็อก และเมื่อเงื่อนไขกลายเป็นเท็จ (false) การทำงานของลูปจะสิ้นสุด หากเงื่อนไขเป็นเท็จทันทีเมื่อรันครั้งแรก คำสั่งในบล็อกย่อยอาจไม่ได้รันเลย

ตัวอย่างการใช้งานลูป Do-While:

“`
int count = 0;
do {
Console.WriteLine(“จำนวน: ” + count);
count++;
} while (count < 5); ``` ในตัวอย่างข้างต้น เราได้ประกาศตัวแปร count และให้ค่าเริ่มต้นเป็น 0 โดยทุกครั้งที่ลูปถูกทำซ้ำ เราจะพิมพ์ข้อความ "จำนวน: " และค่าของ count บนหน้าจอ จากนั้นเราจะเพิ่มค่าของ count ลงไปหนึ่งครั้ง และเมื่อ count น้อยกว่า 5 ลูปจะทำงานซ้ำไปเรื่อยๆจนกว่า count จะเป็น 5 และเมื่อ count เป็น 5 เงื่อนไขจะกลายเป็นเท็จ ลูปจะถูกสิ้นสุดการทำงาน ลูป Do-While นั้นมีความคล้ายคลึงกับลูป While แต่มีความแตกต่างบางอย่างที่สำคัญ ในลูป While เงื่อนไขจะถูกตรวจสอบก่อนที่โค้ดในลูปจะถูกทำ แต่ในลูป Do-While เงื่อนไขจะถูกตรวจสอบหลังจากที่โค้ดในลูปถูกทำ ดังนั้น โค้ดในลูป Do-While อาจถูกทำซ้ำอย่างน้อยหนึ่งครั้ง แม้ว่าเงื่อนไขอาจจะเป็นเท็จทันทีที่เริ่มรัน ลูป Do-While มีประโยชน์และความยืดหยุ่นในการใช้งานเมื่อเราไม่ทราบจำนวนครั้งที่ต้องการทำซ้ำล่วงหน้า แต่ต้องการให้โปรแกรมทำซ้ำรอบแรกอย่างแน่นอน ลูปนี้ยังเหมาะสำหรับการใช้งานร่วมกับการรับข้อมูลจากผู้ใช้ระหว่างทำซ้ำ โดยอาจถามผู้ใช้ว่าต้องการทำซ้ำต่อหรือไม่ก่อนที่จะตรวจสอบเงื่อนไขในวงเล็บ FAQs: 1. Q: ในสถานการณ์ใดบ้างที่ควรใช้ลูป Do-While? A: ลูป Do-While เหมาะสำหรับสถานการณ์ที่ต้องการให้โปรแกรมทำซ้ำบล็อกโค้ดอย่างน้อยหนึ่งครั้งโดยไม่รู้มาก่อนว่าเงื่อนไขจะเป็นเท็จหรือไม่ 2. Q: สีเดียวกันกับลูป While แต่ควรเลือกใช้ลูปอันใด? A: เลือกใช้ลูป Do-While เมื่อใช้งานที่ต้องการให้โปรแกรมทำซ้ำอย่างน้อยหนึ่งครั้งแม้ว่าเงื่อนไขจะเป็นเท็จตั้งแต่เริ่มต้น 3. Q: ผมสามารถหยุดลูป Do-While ก่อนที่จะเงื่อนไขจะกลายเป็นเท็จได้ไหม? A: การหยุดลูปก่อนที่จะเงื่อนไขจะเป็นเท็จจำเป็นต้องทำการตรวจสอบเงื่อนไขข้างในวงเล็บและใช้คำสั่ง break เมื่อต้องการหยุดลูปทันที 4. Q: จำเป็นจะต้องใช้ลูป Do-While กับการรับข้อมูลจากผู้ใช้หรือไม่? A: ไม่จำเป็น แต่ลูป Do-While เป็นเครื่องมือที่ดีในการใช้งานกับการรับข้อมูลเมื่อต้องการทำซ้ำได้หลายครั้งและตรวจสอบเงื่อนไขรับข้อมูลก่อนการทำงาน 5. Q: ภายในลูป Do-While ของภาษาไทยสามารถมีการซ้อนลูปอื่น ๆ ได้หรือไม่? A: ใช่ ภายในลูป Do-While คุณสามารถใช้ภาษาไทยอื่น ๆ เช่น if-else, for หรือ while และลูปอื่น ๆ ประกอบไปด้วย ในส่วนของลูป Do-While ในภาษาไทย เราได้เรียนรู้ถึงการใช้งาน รูปแบบการเขียนโค้ด และบทนำเกี่ยวกับลูปอื่น ๆ ที่ใช้ในภาษาโปรแกรมมิ่ง การทราบเกี่ยวกับการใช้งานลูปอาจจะช่วยให้เราเขียนโค้ดที่มีประสิทธิภาพและง่ายต่อการทำความเข้าใจได้มากขึ้น

มี 17 ภาพที่เกี่ยวข้องกับหัวข้อ การใช้ do while.