วันพฤหัสบดีที่ 6 มกราคม พ.ศ. 2554

คำสั่งควบคุมในการทำซ้ำ

คำสั่งควบคุมในการทำซ้ำ
            ใช้ในการทำคำสั่งเดิมซ้ำๆกันโดยมีเงื่อนไขควบคุมจำนวนครั้งในการทำซ้ำ  ดังตัวอย่าง
ตัวอย่างที่1 การพิมพ์ข้อความ Hello World! จำนวน 5 ครั้งแบบไม่ใช่คำสั่งการทำซ้ำ
 
#include <stdio.h>
main()
 {
   printf("Hello World!\n");
   printf("Hello World!\n");
   printf("Hello World!\n");
   printf("Hello World!\n");
   printf("Hello World!\n");
 }

สามารถใช้คำสั่งควบคุมการทำซ้ำได้ซึ่งอธิบายในส่วนต่อไป   สิ่งที่จำเป็นของคำสั่งการวนซ้ำคือ
         1.เงื่อนไขโดยพิจารณาจากตัวแปรหรือพารามิเตอร์ที่ใช้ควบคุมว่าต้องวนซ้ำหรือไม่
          2.ประโยคหรือคำสั่งที่ต้องการวนซ้ำ เช่น ในกรณีข้างบนเป็น printf("Hello World!\n");
          3. การเปลี่ยนแปลงค่าพารามิเตอร์หรือตัวแปรที่ใช้ควบคุมเพื่อนำไปพิจารณาในเงื่อนไขข้อแรกอีกครั้ง

5.1   คำสั่ง while  (The while  Statement)
                  คำสั่ง while  เป็นคำสั่งที่ใช้ในการวนรอบ  ซึ่งจะมีการตรวจสอบค่าเงื่อนไข กรณีไม่เท่ากับศูนย์ (จริง)  จะมีการทำคำสั่ง (Statement) ในแต่ละรอบ  กรณีผลลัพธ์เท่ากับศูนย์ (เท็จ) จะไม่ทำกลุ่มคำสั่ง (Statement) สามารถเขียน Flowchart ได้ดังนี้
Flowchart ของคำสั่ง while
รูปแบบของคำสั่ง สามารถเขียนสรุปได้ดังนี้
คำสั่ง while
         รูปแบบ   :    While (loop repetition condition)
                        statement;

    

ตัวอย่างที่ 2:        การพิมพ์ข้อความ Hello World! จำนวน 5 ครั้งแบบใช้คำสั่งการทำซ้ำแบบ while
#include <stdio.h>
main()
 {              n = 5
                count = 0;
                while (count < n)
                {
                   printf("Hello World!\n");
                   count = count + 1;
                }
}

จากตัวอย่างดังกล่าวดังกล่าวแยกเป็น 3 ส่วนตามที่ได้กล่าวไว้ข้างต้น

1.พารามิเตอร์และเงื่อนไขที่ใช้ในการควบคุม  ในกรณีนี้พารามิเตอร์คือ count และเงื่อนไขคือ count < n  โดยก่อนหน้านั้นมีการกำหนดค่าเริ่มต้นไว้ก่อนคือ count = 0;n = 5;
 
2.ประโยคหรือคำสั่งที่ต้องการวนซ้ำ เช่น ในกรณีข้างบนเป็น printf("Hello World!\n");

3.การเปลี่ยนแปลงค่าพารามิเตอร์  เนื่องจากต้องการให้แสดง Hello World!  5  ครั้ง  เมื่อมีการกระทำโดยการพิมพ์คำว่า Hello World!   1 ครั้ง  ก็ให้มีการเพิ่มการนับลงไปในตัวแปร count
โดยประโยค count = count + 1;  ทำให้ค่าของ count ิ่มขึ้น 1

4.ซึ่งหลังจากนั้นก็จะกลับไปเช็คเงื่อนไขข้อที่ 1 ถ้านับได้น้อยกว่า 5 คือ 0 ,1,2,3,4 ก็จะมีการพิมพ์ Hello World!  ออกทางหน้าจอ  เมื่อcount เป็น 5 ก็จะออกจากการวนซ้ำเพราะเงื่อนไข( 5 < 5) เป็นเท็จ





5.2   คำสั่ง for (for Statement)
                  คำสั่ง for เป็นคำสั่งที่ใช้ในวนรอบอีกชนิดหนึ่ง  ซึ่งการทำงานของการวนรอบ จะขึ้นกับส่วนสำคัญ 3 ส่วน คือ           
1.  ค่าเริ่มต้นของ ตัวแปรควบคุมการวนรอบ(ในการควบคุมแบบ while ค่านี้ถูกกำหนดไว้ก่อน)
2.      ส่วนทดสอบเงื่อนไข
3.      ส่วนเปลี่ยนแปลงค่าของตัวแปรควบคุมการวนรอบ

และอีกส่วนที่สำคัญคือคือประโยคหรือกลุ่มคำสั่งที่ต้องการทำซ้ำ
คำสั่ง for
                  รูปแบบ :                    for (initialization expression;
                        loop repetition condition;
                       update expression)
                 
                 

ตัวอย่างที่ 3:        การพิมพ์ข้อความ Hello World! จำนวน 5 ครั้งแบบใช้คำสั่งการทำซ้ำแบบ for
#include <stdio.h>
main()
 {              n = 5
                count = 0;
                for (count = 0; count <n; count += 1)
                   {
                      printf("Hello World!\n");
                    }
}

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

5.3   คำสั่ง do-while (do-while Statement)
                  จากการศึกษาคำสั่ง while และ for  จะต้องมีการตรวจสอบค่าของเงื่อนไขก่อนว่าเป็นจริงหรือเท็จ  ก่อนที่จะทำคำสั่ง (กลุ่มคำสั่ง) ภายในลูป  แต่การทำงานบางลักษณะจะต้องทำคำสั่งภายในลูป ก่อนอย่างน้อย 1 ครั้ง  ซึ่งการทำงานในลักษณะที่กล่าวนี้สามารถใช้คำสั่ง do-while
คำสั่ง do-while
                                    รูปแบบ:   do
                        statement;
                  while (loop repetition condition);

                      

ตัวอย่างที่ 4:        การพิมพ์ข้อความ Hello World! จำนวน 5 ครั้งแบบใช้คำสั่งการทำซ้ำแบบ do while
#include <stdio.h>
main()
 {              n = 5
                count = 0;
                do
                {
                   printf("Hello World!\n");
                   count = count + 1;
                }
                while (count < n) 
}

ซึ่งไม่ว่าอย่างไรประโยค         printf("Hello World!\n");
                    count = count + 1;

ต้องกระทำอย่างน้อย 1 ครั้ง เพราะเป็นการกระทำก่อนเช็คเงื่อนไข  ซึ่งต่างกับ while และ for ซึ่งในกรณีที่เงื่อนไขเป็นเท็จตั้งแต่ครั้งแรก  ประโยคดังกล่าวไม่ถูกนำมากระทำ

เช่น    ทดลองเขียนโปรแกรมในคอมพิวเตอร์และคอมพาย์ใหม่โดยเปลี่ยนค่าเริ่มต้นของ count ให้เท่ากับ 5หรือ6     
ให้สังเกตว่า              กรณีของ while และ forประโยคที่อยู่ภายในคำสั่ง ไม่ถูกกระทำ  ส่วนกรณีของ do while ประโยคที่กล่าวมาทั้ง 2 ถูกนำมากระทำโดยพิมพ์คำว่า hello world บนหน้าจอก่อนที่จะเช็คเงื่อนไข

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

ตัวอย่างที่ 5             /* Find first even number input */
                                    do
                                                status = scanf("%d”,&num);
                                    while ( status > 0 && (num%2) ! = 0);

ตัวดำเนินการ (Operator)

ตัวดำเนินการทางคณิตศาสตร์ (Arithmetic Operators)
ตัวดำเนินการทางคณิตศาสตร์ เป็นตัวดำเนินการที่คำนวณทางด้านคณิตศาสตร์ให้มีค่าออกมามีชนิดสอดคล้องกับชนิดของตัวถูกกระทำ ประกอบด้วยตัวดำเนินการต่างๆ ดังนี้


เครื่องหมาย
ความหมาย
ตัวอย่าง
+
การบวก
A+B
-
การลบ
A-B
*
การคูณ
A*B
/
การหาร
A/B
%
การหารเอาแต่เศษไว้ (Modulo)
5%3=1 เศษ 2 จะเก็บแต่เศษ 2 เอาไว้
--
การลดค่าลงครั้งละ 1
A --  จะเหมือนกับ A=A-1
++
การเพิ่มค่าขึ้นครั้งละ 1
A++ จะเหมือนกับ A=A+1

แสดงประเภทของตัวดำเนินการทางคณิตศาสตร์

การโอเปอเรชัน (Operation)  หรือการทำงานของตัวดำเนินการต้องเป็นไปตามลำดับของการวางค่าคงที่หรือตัวแปรที่จะกระทำต่อกัน ซึ่งเรียกว่า ลำดับของการโอเปอเรชัน ซึ่งลำดับการทำงานของโอเปอเรเตอร์โดยคอมไพเลอร์ภาษา C ต้องเป็นไปตาม กฎการกำหนดลำดับการทำงานของตัวดำเนินการ (Precedence) ดังแสดงในตาราง


โอเปอเรเตอร์

ลำดับของการโอเปอเรชัน

( )
ซ้ายไปขวา

-
ซ้ายไปขวา
* - คือแสดงความเป็นลบของตัวเลข
* / %
ซ้ายไปขวา

+ -
ซ้ายไปขวา
* - คือเครื่องหมายลบค่าตัวเลข

ตารางที่ แสดงลำดับของการทำงานของตัวดำเนินการทางคณิตศาสตร์ ตามกฎ Precedence

            ในการคำนวณ  a + b* c   ภาษา C จะกระทำเครื่องหมาย % * และ / ก่อนเครื่องหมาย + และ ดังนั้นถ้า a + b* c   จะคำนวณ b* c ก่อน แล้ว จึงค่อยนำมาบวกกับ a
แต่ถ้าเครื่องหมายมีความเท่าเทียมกันจะกระทำจากซ้ายไปขวา เช่น a+b+c  จะเริ่มทำจาก a บวก แล้วจึงนำค่าที่ได้มาบวก c ถ้าต้องการกำหนดลำดับให้ทำโดยการใส่เครื่องหมายวงเล็บในส่วนที่ต้องการให้ทำงานก่อน

ตัวอย่างลำดับของการทำงานของตัวดำเนินการทางคณิตศาสตร์ ตามกฎ Precedence


 





ตัวดำเนินการ % เป็นตัวดำเนินการทางคณิตศาสตร์เพียงตัวเดียวที่กำหนดให้ใช้กับค่าจำนวนเต็ม เท่านั้น  นอกนั้นสามารถใช้กับค่าอื่นๆ ได้ตัวดำเนินการทางคณิตศาสตร์ที่น่าสนใจอีกตัวหนึ่งคือ เครื่องหมาย /เช่น  a / b

            ถ้าทั้งตัวแปร a และ b เป็น integer ค่าที่ได้จากการดำเนินการของหารจะมีชนิดเป็น  integer  และถ้า a หรือ b ตัวแปรใดตัวแปรหนึ่งเป็นตัวแปรชนิด float จะได้คำตอบเป็นชนิด float 
เช่น
                                                        39 / 5   จะมีค่าเท่ากับ 7
                                                        39.0 / 5            จะมีค่าเท่ากับ 7.8

            จะเห็นได้ว่ามีความแตกต่างที่สำคัญของเครื่องหมายหาร  อย่างที่หนึ่งคือ เครื่องหมายหารสำหรับตัวแปร integer และอีกหนึ่งสำหรับตัวแปรแบบ  floating  ขึ้นอยู่กับชนิดของ operand ที่เราใช้กับเครื่องหมายหารนั้นๆ  สำหรับผู้เริ่มต้นเขียนโปรแกรมเป็นไปได้ว่าจะเกิดการผิดพลาดขึ้น ตัวอย่างเช่น 1/3 (ซึ่งมีค่าเท่ากับ 0) แทนที่จะเป็น 1.0/3.0  ซึ่งมีค่าเท่ากับ 0.333…  โดยการที่การเขียน 1.0/3.0  เราสามารถเขียนได้เป็นว่า 1.0/3 หรือ 1/3.0  และในแต่ละแบบของนิพจน์จะไม่เป็น 0

ตัวดำเนินการเพิ่ม และลดค่า (Increment & Decrement)
ตัวดำเนินการเพิ่ม และลดค่า เป็นตัวดำเนินการในการเพิ่มหรือลดค่าของตัวแปร โดย
-          ตัวดำเนินการเพิ่มค่า ++ จะบวกหนึ่งเข้ากับตัวถูกดำเนินการ 
-          ตัวดำเนินการลดค่า -- จะลบหนึ่งออกจากตัวถูกดำเนินการ 
สาเหตุที่มีตัวดำเนินการนี้ เพราะการดำเนินการเพิ่มหรือลดค่าเกิดขึ้นเสมอ สำหรับตัวดำเนินการ ตัวดำเนินการเพิ่ม และลดค่ามีวิธีใช้งาน 2 แบบคือ
-          ใช้เป็นตัวดำเนินการแบบมาก่อน  (prefix) เช่น ++n 
-          ใช้ตัวดำเนินการแบบตามหลัง (postfix)  ก็ได้เช่น n++ 
ในทั้งสองกรณี ผลลัพธ์คือการเพิ่มค่า 1 ให้กับ n แต่นิพจน์ ++n จะเพิ่มค่าก่อนที่จะนำค่าไปใช้ ขณะที่ n++ จะเพิ่มค่าหลังจากนำค่าไปใช้  ซึ่งหมายความว่าถ้ามีการนำค่าไปใช้ (ไม่เพียงหวังเฉพาะผลลัพธ์) ++n  และ n++  จะแตกต่างกัน  ตัวอย่างดังนี้
ตัวอย่าง                ถ้า n มีค่า 5

                                    x = n++;           จะเป็นการกำหนดค่า x ให้กับ 5
                                    x = ++n;           จะเป็นการกำหนดค่า x ให้กับ 6

ตัวดำเนินการนี้จะใช้ได้กับเฉพาะตัวแปรเท่านั้น  จะใช้กับนิพจน์อื่นๆ ไม่ได้เช่น (i+j)++ 

ตัวอย่างเช่น
#include <stdio.h>
int main()
{   
int x=2;
int y=2;
printf(”x++ = %d\n”, x++);
printf(”x = %d\n”, x) ;
printf(”++y = %d\n”, ++x);
printf(”y = %d\n”, y) ;
     return 0;
}


ผลลัพธ์

x++ = 2
x=3
++y=3
y=3
 
 



ตัวดำเนินการสัมพันธ์และตัวดำเนินการตรรกะ (Relational, Equality, and Logical Operators)  

Operator

เครื่องหมาย

ความหมาย

ตัวดำเนินการสัมพันธ์
< 
น้อยกว่า
(Relational Operator)
> 
มากกว่า

<=
น้อยกว่า หรือ เท่ากับ

>=
มากกว่า หรือ เท่ากับ
ตัวดำเนินการเท่ากับ
==
เท่ากับ
(Equality Operator)
!=
ไม่เท่ากับ
ตัวดำเนินการตรรกะ
!
นิเสธ
(Logical Operator)
&&
และ

||
หรือ

ตารางที่  แสดงตัวดำเนินการสัมพันธ์และตัวดำเนินการตรรกะ

 ตัวดำเนินการสัมพันธ์ (Relational Operator)
            ตัวดำเนินการสัมพันธ์ เป็นเครื่องหมายที่ใช้ในการเปรียบเทียบและตัดสินใจ ซี่งผลของการเปรียบเทียบจะเป็นได้ 2 กรณีเท่านั้นคือ จริงและเท็จ ภาษาซีถือว่าค่าทางตรรกจริงและเท็จมีชนิดเป็น int ดังนั้นผลการกระทำทางตรรกจึงมีค่าเป็นจำนวนเต็ม และมีค่าได้เพียงสองค่าคือ 1 หรือตัวเลขใดๆ แทนค่าความจริงเป็นจริง และ 0 แทนค่าความจริงเป็นเท็จ  (0 เป็นเท็จ ส่วนตัวเลขอื่นๆ ทั้งหมดมีค่าเป็นจริง)
                เครื่องหมายที่เป็นตัวดำเนินการสัมพันธ์มี 4 ตัวคือ
<  (น้อยกว่า)   
>  (มากกว่า)    
<= (น้อยกว่าเท่ากับ)      และ    
>= (มากกว่าเท่ากับ)

ตัวอย่างการใช้งาน   เช่น
                            a<3      /* ถ้า a มีค่าเป็น 5 ประโยคนี้จะได้ผลลัพธ์เป็น 0 (เท็จ) */
                            a>b        /* ถ้า a=10  b=8 ประโยคนี้จะได้ผลลัพธ์เป็น 1 (จริง) */
                            -1 >= (2.2*X+3.3)
                            a<b<c              /* รูปแบบถูกต้อง แต่ลำดับการวางตัวแปรอาจทำให้สับสนได้ โดยจะทำ
การเปรียบเทียบค่า b และ c ก่อน จึงนำผลลัพธ์มาเปรียบเทียบกับ a */

ตัวอย่างการใช้งานผิดแบบ
            a =<    b                       /* ผิดลำดับ   เครื่องหมาย = มาก่อน < */
            a <  =  b                       /* ผิดรูปแบบ ห้ามเว้นวรรคระหว่าง < และ = */

ตัวดำเนินการเท่ากับ (Equality Operator)
ตัวดำเนินการเท่ากับ ใช้ในการเปรียบเทียบค่า 2 ค่า ว่ามีค่าเท่า หรือไม่เท่ากัน ผลลัพธ์ที่ได้ จะมีเพียง 2 ค่าเช่นเดียวกับผลลัพธ์ของตัวดำเนินการสัมพันธ์คือ จริง และ เท็จ
เครื่องหมายที่เป็นตัวดำเนินการเท่ากับมี 2 ตัวคือ
==  (เท่ากับ)  
!=  (ไม่เท่ากับ)

ตัวอย่างการใช้งาน  เช่น
            c == ‘A’                                /* ถ้าตัวแปร c เก็บค่าอักขระ A ผลลัพธ์จะได้ค่าจริง */
            k != -2                                  /* ถ้าตัวแปร k เก็บค่าตัวเลข –2 ผลลัพธ์จะได้ค่าเท็จ */
            x+y  == 2 * z – 5         
ตัวอย่างการใช้งานผิดแบบ
            a=b                  /* การเปรียบเทียบค่าตัวแปร a กับ b ว่ามีค่าเท่ากันหรือไม่
กลายเป็นการให้ค่าตัวแปร a ด้วยค่าตัวแปร b */
            a= =b -1          /* ใช้งานผิดรูปแบบ โดยมีช่องว่างระหว่างเครื่องหมาย = ทั้ง 2 ตัว */

 ตัวดำเนินการตรรกะ (Logical Operator)
                ตัวดำเนินการตรรกะ ใช้ในการเปรียบเทียบ และกระทำทางตรรกะกับค่าตัวเลข หรือค่าที่อยุ่ใน     ตัวแปร ผลลัพธ์ที่ได้ จะมีเพียง 2 ค่าเช่นเดียวกับผลลัพธ์ของตัวดำเนินการสัมพันธ์คือ จริง และ เท็จ
                เครื่องหมายที่เป็นตัวดำเนินการทางตรรกะ มี 3 ตัวคือ

                            ! (นิเสธ)           
&&    (และ)        
||  (หรือ)

**หมายเหตุ  นิเสธ คือการกลับค่าความจริงของค่าตัวเลข หรือตัวแปรที่ตามหลังเครื่องหมาย

ตัวดำเนินการนิเสธ            ต้องการตัวถูกกระทำการเพียง 1 ตัวเท่านั้น
ตัวอย่างการใช้งาน
            !a                            /* ถ้าค่าความจริงของตัวแปร a มีค่าจริง ผลลัพธ์จากการนิเสธจะได้ค่าเป็นเท็จ */
            !(x+7.7)              
            !(a<b || c<d)      /* a มากระทำกับ b แล้วเอาผลลัพธ์มา || กับ ผลลัพธ์ระหว่างการกระทำระหว่าง
c กับ d    จากนั้นนำผลลัพธ์ที่ได้จากการ || มา ทำการนิเสธอีก */

ตัวอย่างการใช้งานผิดแบบ
            a!         /* ผิดลำดับ      เครื่องหมาย ! มาก่อนตัวแปร */
            a! = b   /* ผิดความต้องการ โดยความต้องการคือ กลายเป็นการใช้เครื่องหมาย != ไป */

ตัวดำเนินการ && และ ||                  ต้องการตัวถูกกระทำ 2 ตัว
ตัวอย่างการใช้งาน
            a&&b                     /* a และ b     ถ้าค่าความจริงของ a เป็นจริง และ ค่าความจริง b เป็นจริง
ผลลัพธ์ที่ได้จะมีค่าความจริงเป็นจริง */
            a || b                      /* a หรือ b     ถ้าค่าความจริงของ a เป็นเท็จ และ ค่าความจริง b เป็นเท็จ
ผลลัพธ์ที่ได้จะมีค่าความจริงเป็นเท็จ */
            !(a<b) && C       /* นำ a มาเปรียบเทียบกับ b แล้วนำผลลัพธ์มานิเสธ จากนั้นมา && กับ C */
            3 && (-2 * a + 7)          /* หาค่าภายในวงเล็บก่อน แล้วนำค่าผลลัพธ์ที่ได้มา && กับ 3 */

ตัวอย่างการใช้งานผิดแบบ
            a &&                     /* ตัวกระทำไม่ครบ */
            a|  |b                     /* เว้นช่องว่างระหว่างเครื่องหมาย || */
            a & b                    /* เครื่องหมาย && ไม่ครบ */
            &b                        /* ตำแหน่งในหน่วยความจำของตัวแปร b */

การหาค่าของตัวดำเนินการตรรกะ
·       && (และ)
            นำค่าความจริง 2 ค่ามาเปรียบเทียบกัน ได้ผลของการเปรียบเทียบตามตาราง

P
Q
P && Q
0
0
0
0
1
0
1
0
0
1
1
1

 แสดงผลของตัวดำเนินการ && ระหว่างตัวแปร P และ Q

·       || (หรือ)
                        นำค่าความจริง 2 ค่ามาเปรียบเทียบกัน ได้ผลของการเปรียบเทียบตามตาราง

P
Q
P || Q
0
0
0
0
1
1
1
0
1
1
1
1
           
แสดงผลของตัวดำเนินการ || ระหว่างตัวแปร P และ Q

·       ! (นิเสธ)
                        นำค่าความจริงมาเปรียบเทียบ ได้ผลของการเปรียบเทียบตามตาราง

P
!P
0
1
1
0

แสดงผลของตัวดำเนินการ ! กับตัวแปร P

ตัวดำเนินการประกอบ (Compound Operator)
                ตัวดำเนินการประกอบ คือ ตัวดำเนินการที่เป็นรูปแบบย่อ ของตัวดำเนินการ+ตัวแปรที่ถูกดำเนินการ  โดยตัวดำเนินการประกอบในภาษาซี มีทั้งหมด 10 ตัวดังนี้
                                    +=        -=         /=         %=
                                    <<=     >>=     !=         ^=

Variable Operator = expression;
 
            การกำหนดรูปแบบของตัวดำเนินการประกอบให้กับตัวแปรมีรูปแบบดังนี้


                        จะมีความหมายเท่ากับ


Variable = variable Operator expression;
 
 



                        ตัวอย่างเช่น
                        i = i + 1;                       ตัวดำเนินการประกอบคือ i += 1;
                        i = i – a;                        ตัวดำเนินการประกอบคือ i - = a;
                        i = i * (a + 1);               ตัวดำเนินการประกอบคือ i *=a+1;
                        i = i / (a-b);                   ตัวดำเนินการประกอบคือ i /= a-b;