ประวัติความเป็นมา

1. ประวัติความเป็นมา

           ภาษาซีไดรับการพัฒนาขึ้นโดยเดนนิส ริทชี (Dennis Ritchie) ขณะที่ทํางานอยูที่เบลแล็บบอราทอรี(Bell Laboratories) โดยพัฒนาขึ้นจากหลักการพื้นฐานของภาษาบี (B) และบีซีพีแอล (BCPL) ในช่วงปี ค.ศ.1971 ถึง1973 แต่ได้เพิ่มชนิดข้อมูลและความสามารถอื่น ๆ ให้มากขึ้น และนําภาษาซีไปใช้พัฒนาระบบปฏิบัติการยูนิกซ (UNIX) บนเครื่องคอมพิวเตอร DEC PDP-11 ภาษาซีเป็นที่นิยมใช้อย่างแพร่หลายในช่วงต้นทศวรรษที่1980 จนกระทั่งมีความพยายามกําหนดมาตรฐานของภาษาเพื่อให้สามารถใช้ภาษาซีได้บนเครื่องคอมพิวเตอรใด ๆ ในปี ค.ศ. 1983 โดย ANSI (The American National Standards Institute) ได้ตั้งคณะกรรมการ X3J11เพื่อรางมาตรฐานดังกลาว และไดรับการตรวจสอบและยอมรับโดย ANSI และ ISO (The InternationalStandards Organization) โดยมีการตีพิมพมาตรฐานของภาษาซีในปี ค.ศ. 1990 จากความมีประสิทธิภาพและสามารถทํางานบนเครื่องคอมพิวเตอร์ใด ๆ ของภาษาซีจึงไดมีการนําภาษาซีไปใช้ในการพัฒนาระบบปฏิบัติการต่าง ๆ และใช้เป็นต้นแบบของภาษาอื่น ๆ ที่สําคัญในปัจจุบัน เช่น ซีพลัสพลัส (C++) จาวา (Java) เป็นต้น

รูปแบบโปรแกรมภาษาซี

2. รูปแบบโปรแกรมภาษาซี

          ในการเขียนภาษาโปรแกรม ผูเขียนโปรแกรมจะตองศึกษารูปแบบพื้นฐานของภาษา และไวยากรณ
ของภาษานั้น รูปแบบพื้นฐานของภาษาจะเขียนโปรแกรมในลักษณะของโมดูลคือมีการแบงออกเปนสวนยอย ๆ
ที่เรียกวา ฟงกชัน (Function)

สวนประกอบที่ 1 สวนหัว (Header) จะเปนสวนที่อยูที่ตอนตนของโปรแกรม โดยอยูนอกสวนที่
เรียกวาฟงกชัน ที่สวนหัวของโปรแกรมจะประกอบดวยคํ าสั่งที่เปนการกํ าหนดคาหรือกํ าหนดตัวแปรตาง ๆ คําสั่งในที่ขึ้นตนดวยสัญลักษณ # เปนคําสั่งที่เรียกวา ตัวประมวลผลกอน (Preprocessor) คือคําสั่งที่จะไดรับการทํากอนที่จะมีการคอมไพลโปรแกรม ตัวประมวลผลกอน ที่สํ าคัญของภาษาซีแบงออกเปน 2 ประเภทดังนี้

• # include
ในภาษาซีจะมีฟงกชันมาตรฐานที่ผูผลิตคอมไพเลอรไดจัดเตรียมไวให ซึ่งมักจะเกี่ยวของ
กับการรับขอมูล การแสดงผลขอมูล การคํ านวณ และอื่น ๆ ซึ่งผูเขียนโปรแกรมสามารถ
เรียกใชงานไดทันที โดยไมตองเขียนโปรแกรมแกรมเอง ในตัวอยางจะมีการใชคํ าสั่ง3
printf( ) ซึ่งเปนคําสั่งที่ใชแสดงขอความออกทางอุปกรณแสดงผลมาตรฐาน เชน จอภาพ
คํ าสั่ง printf( ) เปนการเรียกใชฟงกชันมาตรฐานซึ่งอยูในกลุมที่เรียกวา Standard Input
and Output เมื่อจะเรียกใชฟงกชันใดในกลุมดังกลาว จะตองบอกใหคอมไพเลอรไปอาน
คาที่อยูในอินคลูชไฟลที่ชื่อ stdio.h มาไวที่สวนตนของโปรแกรม โดยใชคํ าสั่ง
#include <stdio.h>เพราะฉะนั้นผูเขียนโปรแกรมควรจะศึกษาฟงกชันมาตรฐานที่คอมไพเลอรแตละบริษัทไดเตรียมไวใหวาคํ าสั่งใดใชคูกับอินคลูชไฟลใด

• # define
ใชสําหรับการกํ าหนดคาคงที่ ตัวอยางเชน
#define YES 1
คําสั่งดังกลาวเปนการกํ าหนดวา หากที่ใดในโปรแกรมมีคํ าวา YES จะถูกแทนที่ดวยคาทาง
ขวามือ ในที่นี้คือ 1นอกจากในสวนหัวของโปรแกรมอาจจะมีการประกาศตัวแปร และสวนของการประกาศโปรโตไทปไวที่สวนหัวของโปรแกรมไดอีกดวย ซึ่งจะกลาวถึงในบทตอ ๆ ไป

สวนประกอบที่ 2 ฟงกชัน (Function) สวนของฟงกชันคือสวนของคํ าสั่งที่บอกใหคอมพิวเตอร
ทํางานตาง ๆ เชน การรับขอมูล การคํ านวณ การแสดงผล เปนตน โปรแกรมภาษาซีจะประกอบดวยฟงกชัน
ยอยหลาย ๆ ฟงกชัน แตจะมีฟงกชันหลักฟงกชันหนึ่งที่ชื่อวาฟงกชัน main( ) เสมอ โดยที่การทํ างานของ
โปรแกรมจะตองเริ่มการทํ างานจากฟงกชันนี้
กฎพื้นฐานที่สําคัญในภาษาซี
• การพิมพตัวอักษรตัวพิมพใหญและตัวพิมพเล็กในภาษาซีนั้นในผลลัพธที่แตกตางกัน (Case
Sensitive) ตัวอยางเชน หากมีการพิมพ main( ) กลายไปเปน Main( ) ก็จะเกิดความผิดพลาด
ขึ้น
• ฟงกชันของภาษาซีจะแบงขอบเขตของฟงกชันแตละฟงกชันดวยเครื่องหมาย { } ในตัวอยางมี
ฟงกชัน void main( ) คํ าวา void จะบอกใหรูวาเมื่อฟงกชันนี้ทํ างานเสร็จจะไมมีการคืนคากลับ
ไปยังสิ่งที่เรียกใชงานฟงกชัน ในกรณีของฟงกชัน main( ) ก็คือจะไมมีการคืนคาใด ๆ กลับไปยัง
ระบบปฏิบัติการ หลังฟงกชันจะตองตามดวย ( ) เสมอ โดยที่ภายในวงเล็บจะประกอบดวย
คาที่สงเขามายังฟงกชัน ที่เรียกวาพารามิเตอร (Parameter) หรืออาจจะไมมีคาใด ๆ สงเขามาก็
ได
• คําสั่งตาง ๆ ซึ่งตองเขียนอยูในฟงกชันเสมอ แบงเปน 2 สวนคือสวนของการประกาศตัวแปรที่
ตองการใชในฟงกชัน และสวนของคํ าสั่งเพื่อทํ างานใดงานหนึ่ง ในที่นี้มีเฉพาะคํ าสั่งที่ใชในการ4
แสดงผลลัพธออกทางจอภาพ คือ printf( ) ใชสําหรับการแสดงผลลัพธออกทางจอภาพ หาก
ตองการแสดงขอความใด ๆ ออกทางจอภาพใหเขียนขอความนั้นอยูภายในเครื่องหมาย “ “
• คําสั่งในภาษาซีจะตองปดทายดวยเครื่องหมาย ; (Semicolon) เนื่องจากภาษาซีจะใชเครื่อง
หมาย ; ในการแยกคําสั่งตาง ๆ ออกจากกัน การเวนบรรทัดหรือการเขียนคํ าสั่งไมตอเนื่องกันจะ
ไมมีผลตอคอมไพเลอร แตเปนการชวยใหผูเขียนโปรแกรมอานโปรแกรมไดงายขึ้นเทานั้น
ตัวอยางแสดงตัวอยางโปรแกรมภาษาซีเบื้องตน
#include
<stdio.h>
void
main
(
)
{
/* Display message
to standard
output */
printf
(
“My first program.”
)
;
}

           นอกจากนี้หากผูใชตองการใสคํ าอธิบายลงในโปรแกรม ก็สามารถทํ าไดโดยใชสิ่งที่เรียกวา Commentขอบเขตของ Comment จะขึ้นตนตั้งแต /* จนกระทั่งถึง */ ขอความใด ๆ ที่อยูในขอบเขตของเครื่องหมายดังกลาวจะไมถูกแปลโดยคอมไพเลอร โดยทั่วไปจะมีการใช Comment เพื่ออธิบายวาโปรแกรมนั้นทํ างานอะไรใชอธิบายคําสั่งแตละคํ าสั่ง ใชอธิบายฟงกชันแตละฟงกชัน และใชอธิบายกลุมของคํ าสั่ง โดยเขียนComment ไวดานบนหรือดานขางของสิ่งที่ตองการอธิบาย เชน หากเปนการอธิบายโปรแกรมจะเขียนComment ไวที่ตนของโปรแกรมนั้น หากเขียนอธิบายฟงกชันจะเขียน Comment ไวดานบนของฟงกชันที่ตองการอธิบาย เขียนอธิบายคํ าสั่งอาจจะเขียน Comment ไวดานบนหรือดานขางของคํ าสั่งนั้น ๆ และเขียนอธิบายกลุมคํ าสั่งก็จะเขียนอธิบายไวดานของกลุมคํ าสั่งนั้น

ตัวแปร

3. ตัวแปร
       
       ในการเขียนโปรแกรมคอมพิวเตอรกระบวนการสํ าคัญที่เกิดขึ้น คือ การรับขอมูล การประมวลผล
ขอมูล และการแสดงผลขอมูล จะเห็นวาสิ่งที่เปนสวนสํ าคัญที่สุดคือขอมูล การทํ างานของโปรแกรมขณะใดขณะหนึ่งจะตองมีการเก็บขอมูลไวในคอมพิวเตอร โดยรับขอมูลจากอุปกรณรับขอมูลไปเก็บไวในสวนที่เรียกวาหนวยความจํา และสงขอมูลจากหนวยความจํ าไปประมวลผลในหนวยประมวลผลกลาง โดยผานคํ าสั่งตาง ๆเมื่อประมวลผลเสร็จแลวก็นํ าผลลัพธที่ไดกลับมาเก็บไวที่หนวยความจํ าอีก เมื่อตองการใหแสดงผลก็จะใชคําสั่งใหไปอานขอมูลจากหนวยความจํ าสงขอมูลนั้นไปยังอุปกรณแสดงผล
ในความเปนจริงตําแหนงตางๆไมไดอางดวยเลข 0 1 หรือ 2 แตอางดวยระบบการอางที่อยูซึ่งเปน
ซับซอนกวานั้น การเขียนในลักษณะที่เห็นในตัวอยางเปนการเขียนในภาษาคอมพิวเตอรยุคแรก เชน
แอสเซมบลี (Assembly) เพื่อความสะดวกในการอางถึงขอมูล ณ ตํ าแหนงตาง ๆ ในหนวยความจํ า จึงไดมีการ
พัฒนากันตอมา จนกระทั่งเปนการอางในระบบของชื่อตัวแปร (Variable) ที่ใชในปจจุบัน

ชนิดข้อมูล

4. ชนิดขอมูล

        ในการใชงานตัวแปรนั้นสิ่งสํ าคัญที่จะตองคํ านึงถึงคือขอมูลที่เก็บอยูภายในตัวแปรนั้น ขอมูลแตละชนิดมีคุณสมบัติแตกตางกันไป เชน เปนเลขจํ านวนเต็ม เปนเลขจํ านวนจริง เปนตัวอักษร เปนตน ผูเขียนโปรแกรมจะตองกํ าหนดชนิดขอมูลใหกับตัวแปรโดยสอดคลองกับขอมูลที่ตองการเก็บ ภาษาซีแบงขอมูลออกเปนชนิดตาง ๆ ซึ่งมีขนาดพื้นที่ที่ตองใชเก็บขอมูลในหนวยความจํ าแตกตางกันขึ้นอยูกับชนิดขอมูลและบริษัทผูผลิตคอมไพเลอร ซึ่งสามารถดูรายละเอียดไดจากอินคลูชไฟล limits.h และ float.h

เมื่อนํามาจัดเปนประเภทขอมูลเราสามารถแบงชนิดของขอมูลในภาษาซี
ออกเปนประเภทหลักได 3 ชนิด คือ
1. จํานวนเต็ม ไดแกขอมูลชนิด int, short, long, unsigned int, unsigned short และ unsigned long
2. จํ านวนจริง คือ ขอมูลที่เปนเลขจํ านวนจริง มีทศนิยม หรืออยูในรูปของนิพจนวิทยาศาสตร ได
แกขอมูลชนิด float และ double
3. ตัวอักขระและสตริง (String) ไดแกขอมูลชนิด char ซึ่งเก็บขอมูลได 1 อักขระ และขอมูลที่เปน
ชุดของขอมูล char (Array of char) ที่ใชเก็บสตริงซึ่งจะกลาวถึงตอไป

• รูปแบบการเขียนคาตาง ๆ ที่เปนไปไดของขอมูลแตละชนิด ไดแก
- จํานวนเต็ม กรณีเขียนเปนเลขฐาน 10 เชน 125 0 -154
 กรณีเขียนเปนเลขฐาน 8 ใหขึ้นตนดวย 0 เชน 0377 0177 0000 01
 กรณีเขียนเปนเลขฐาน 16 ใหขึ้นตนดวย 0x หรือ 0X เชน 0XFF 0x14 0x4B
 กรณีขอมูลเปนชนิด long ใหลงทายดวย l หรือ L เชน 123L 0437l 0x4FFL

- จํานวนจริง เขียนรูปแบบทศนิยม เชน 12.524 0.1259 0.00001
 เขียนรูปแบบนิพจนวิทยาศาสตร เชน 1.0E4 12.432e-4 1E-4 2E+3
 กรณีขอมูลเปน float เชน 1.4321F 472.324f
 กรณีขอมูลเปน double เชน 232.98D 1.2323d

- ตัวอักขระ เชน ‘a’ ‘W’ ‘\a’ ‘\t’ โดยที่อักขระใดขึ้นตนดวย \
 แสดงวาเปนอักขระพิเศษ เชน ‘\a’ แทนการสงเสียง
‘\t’ แทนการยอหนา
‘\n’ แทนการขึ้นบรรทัดใหม
‘\0’ แทนคา NULL ซึ่งหมายถึงคาวาง
นอกจากนี้ยังสามารถใชในลักษณะเลขฐาน 8 และเลขฐาน 16 ไดดังนี้ ตัวอยาง
เชน ‘X’ ในตาราง ASCII ตรงกับเลขฐาน 8 คือ 130 และเลขฐาน 16 คือ 58
เขียนแทนคาคงที่อักขระไดคือ ‘\130’ และ ‘\x58’ ตามลํ าดับ
char ch1=’X’;
char ch2 = ‘\130’;
char ch3 = ‘\x58’;
ถาสั่งใหพิมพคาตัวแปร ch1 ch2 และ ch3 จะพิมพคาเดียวกันคือ X

- สตริง จะเขียนอยูในเครื่องหมาย “ เชน “Hello” โดยที่ในสตริงทุกตัวจะมีอักขระพิเศษที่
ไมสามารถมองเห็นคือ ‘\0’ หรือ NUL เปนตัวสุดทายเสมอ ในขณะที่อักขระจะจอง
พื้นที่หนวยความจํ าเพียง 1 ไบต ในตัวอยางจะไดวาเกิดการจองพื้นที่ขึ้น 6 ตัว
อักษร ตัวอยางการประกาศตัวแปรสตริง
char msg[ ] = “Hello”

การใช้ตัวแปร

5. การใชตัวแปร
เมื่อตองการใชตัวแปร จะตองมีการประกาศชื่อตัวแปรที่ตองการใชงานนั้น มีรูปแบบคือ

ประเภทขอมูล ชื่อตัวแปร ;

ตัวอยางของการประกาศตัวแปร เชน
float score;
int age;
 char ch;
float width, height, length;

กรณีที่มีตัวแปรมากกวา 1 ตัวที่มีชนิดเดียวกัน สามารถประกาศไวในคํ าสั่งเดียวกันไดโดยใชเครื่อง
หมาย , คั่นระหวางตัวแปรแตละตัว
กฎการตั้งชื่อ
ในภาษาซีมีการกํ าหนดกฎในการตั้งชื่อ Identifier ตาง ๆ อันไดแก ชื่อตัวแปร ชื่อฟงกชัน ชื่อคาคงที่
ดังนี้
• ใหใชตัวอักษร a ถึง z A ถึง Z เลข 0 ถึง 9 และ _ (Underscore) ประกอบกันเปนชื่อ
• ขึ้นตนดวยตัวอักษรหรือ _
• ตัวอักษรตัวพิมพใหญ ตัวพิมพเล็กมีผลตอการตั้งชื่อและการเรียกใชงาน
• ชื่อนั้นจะตองไมซํ้ ากับคํ าหลัก (Keyword) ซึ่งภาษาซีจองไวใช คือ
auto          double     int           struct
break        else          long        switch
case          enum        register   typedef
char          extern       return     union
const        float          short      unsigned
continue    for            signed    void
default      goto          sizeof     volatile
do            if               static      while

คำาแนะนําในการตั้งชื่อ
ในการเขียนโปรแกรมที่ดีนั้นเราควรทําการตั้งชื่อของตัวแปร คาคงที่ ฟงกชัน ใหอยูในรูปแบบมาตร
ฐานดังนี้
• ใหตั้งชื่อที่สื่อความหมายบอกใหรูวาตัวแปรนั้นใชทํ าอะไร
• ขึ้นตนดวยตัวอักษร
• กรณีตั้งชื่อตัวแปรมักจะหรือฟงกชันมักจะใชตัวอักษรตัวพิมพเล็ก
• คาคงที่ที่กํ าหนดโดย #define มักจะใชตัวอักษรตัวพิมพใหญทั้งหมด
• กรณีที่ชื่อตัวแปรประกอบดวยคํ าหลาย ๆ คํ า อาจจะใชตัวอักษรตัวพิมพใหญขึ้นตนคํ าในลํ าดับ
ตอมา หรือใช _ แยกระหวางคํ า เชน totalScore หรือ total_score
ตัวอยางการตั้งชื่อตัวแปร เชน
        totalscore = score1 + score2 + score3;
ยอมจะทํ าความเขาใจไดงายกวา
        robert = willy + bird + smith;

          เมื่อมีการประกาศตัวแปร จะเกิดกระบวนการจองพื้นที่ในหนวยความจํ าใหกับตัวแปรตัวนั้นมีขนาด
เทากับชนิดของขอมูลที่กํ าหนด เมื่อใดที่มีการอางถึงชื่อตัวแปรก็จะเปนการอางถึงคาที่เก็บอยูในพื้นที่หนวยความจํานั้น สิ่งที่ตองระวังคือ ควรจะมีการกํ าหนดคาเริ่มตนใหกับตัวแปรนั้น ๆ เสมอ เพราะพื้นที่ในหนวยความจําที่ถูกจองนั้นอาจจะมีคาบางอยางอยูภายใน ตัวอยางของการกํ าหนดคาเริ่มตนใหกับตัวแปร คือ
                        int sum=0;
                        float height=0.0f;
          จากคําสั่งขางตนระบบจะทํ าการจองพื้นที่ในหนวยความจํ าใหกับตัวแปรชื่อ sum มีขนาดเทากับ int (2ไบต) และกํ าหนดใหมีคาเริ่มตนเทากับ 0 เมื่อมีการอางถึงชื่อตัวแปรก็จะไดคาคือ 0 และจองพื้นที่ในหนวยความจํ าใหกับตัวแปร height มีขนาดเทากับ float (4 ไบต) และกํ าหนดใหมีคาเริ่มตนเทากับ 0.0

คำสั่ง if

1. คําสั่ง if

        คําสั่ง if เปนคําสั่งที่ใชในการเขียนแบบเงื่อนไข ตัวอยางของประโยคในลักษณะเงื่อนไขเปนตัวอยางที่สามารถพบเห็นไดในชีวิตประจําวัน เชน ถาวันนี้ฝนไมตก ฉันจะเดินไปโรงเรียน แตถาฝนตก ฉันจะขอใหคุณพอไปสงที่โรงเรียนหรือตัวอยางเชน ถาฉันสอบไดคะแนนดี คุณพอและคุณแมจะภูมิใจ
จะใหวาประโยคเงื่อนไขดังกลาวมีอยู 2 ลักษณะ คือ ถาเงื่อนไขเปนจริงเกิดเหตุการณหนึ่ง แตถาไมจริงจะเกิดอีกเหตุการณหนึ่ง กับประโยคในลักษณะที่ถาเงื่อนไขเปนจริงจึงจะเกิดเหตุการณขึ้นเทานั้น
1.1 คําสั่ง if-else
        คําสั่ง if ในรูปแบบแรกจะคํ าสั่งที่ตองทํ าทั้งในกรณีที่เงื่อนไขเปนจริงและเปนเท็จ โดยใช
นิพจนตรรกศาสตรมาเปนเครื่องมือชวยในการตรวจสอบเงื่อนไข มีรูปแบบคํ าสั่ง คือ
                   
                         if ( เงื่อนไข )
                         คํ าสั่งที่ 1;
                   else
                         คํ าสั่งที่ 2;

          ตัวอยางเชน หากรับขอมูลจากผูใชและตองการตรวจสอบวาเลขที่รับเขามามีคามากกวา 10
ใหพิมพขอความวา “Number XXXX is over than 10” แตถาไมใชใหพิมพขอความวา “Number
XXXX is not over than 10” จะเขียนเปนคําสั่งไดวา

                    scanf(“%d”, &number);
                    if (number > 10)
                        printf(“Number %d is over than 10”, number);
                   else
                        printf(“Number %d is not over than 10”, number);

          แตหากเงื่อนไขเปนจริงหรือเท็จแลวตองทํ าคํ าสั่งมากกวา 1 คํ าสั่ง จะตองใชเขียน if-else ใน
รูปแบบที่ใชเครื่อง { } ซึ่งแสดงขอบเขตของการทํ าเงื่อนไข ครอบคํ าสั่งที่ตองทํ าในแตละเงื่อนไข มีรูป
แบบดังนี้
                          if ( เงื่อนไข ) {
                              คํ าสั่งที่ 1;
                              คํ าสั่งที่ 2;
                               ….
                    } else {
                              คํ าสั่งที่ 3;
                              คํ าสั่งที่ 4;
                               …
                     }

           ตัวอยางเหมือนในตัวอยางกอนหนานี้ แตเพิ่มเงื่อนไขวา ถาเลขนั้นมีคามากกวา 10 ใหลด
เลขนั้นลง 5 แสดงไดดังตัวอยาง

                  scanf(“%d”, &number);
                  if (number > 10) {
                       printf(“Number %d is over than 10”, number);
                       number = number – 5;
               } else
                       printf(“Number %d is not over than 10”, number);

1.2 คําสั่ง if
           ในกรณีที่ประโยคเงื่อนไขมีการทํ างานเฉพาะเงื่อนไขที่เปนจริงเทานั้น โดยไมมีการทํ างานใด
ในเงื่อนไขที่เปนเท็จ ดังแสดงในรูปที่ 3.1 (ข) สามารถเขียนแทนดวยคํ าสั่ง if โดยไมตองใสคําสั่ง
else แสดงดังรูปแบบ
                 
                    if ( เงื่อนไข )
                        คํ าสั่งที่ 1;

           แตถาเงื่อนไขเปนจริงแลวมีการทํ าคํ าสั่งมากกวา 1 คํ าสั่งขึ้นไป ก็ใชรูปแบบของเครื่องหมาย
{ } ซึ่งใชในกรณีที่มีคํ าสั่งที่ตองทํ าในเงื่อนไขและการวนซํ้ ามากกวา 1 คํ าสั่ง เพื่อแสดงขอบเขตของ
การทํ างานนั้น
           ตัวอยางเชน ใหรับขอมูลจํ านวนเต็มจากผูใช หากขอมูลนั้นมีคามากกวา 60 หรือนอยกวา
20 ใหขึ้นขอความวา “Number XXXX is out of range” เขียนไดดังตัวอยาง
               
                   scanf(“%d”, &number);
                   if (number < 20 || number > 60)
                        printf(“Number %d is out of range”, number);

1.3 คําสั่ง if แบบซับซอน
           ในบางกรณีประโยคเงื่อนไขอาจจะมีความซับซอน มีการเปรียบเทียบเงื่อนไขเดียวกันกับหลายคา เชน ใหรับขอมูลชั้นปของนักศึกษาและใหพิมพขอความตรงกับชั้นป กํ าหนดวาชั้นปที่ 1 พิมพวา“Freshman” ชั้นปที่ 2 พิมพวา “Sophomore” ชั้นปที่ 3 พิมพวา “Junior” ชั้นปที่ 4 พิมพวา “Senior” ชั้นปอื่น ๆ พิมพวา “Super”
               
                 scanf(“%d”, &year);
                 if (year == 1)
                      printf(“Freshman”);
               else if (year == 2)
                      printf(“Sophomore”);
              else if (year == 3)
                      printf(“Junior”);
              else if (year == 4)
                     printf(“Senior”);
              else
                     printf(“Super”)

การรับขอมูลและแสดงผลขอมูล

6. การรับขอมูลและแสดงผลขอมูล

         ภาษาซีไดเตรียมฟงกชันมาตรฐานที่ใชในการรับและแสดงผลขอมูลใหกับผูพัฒนาโปรแกรมหลาย
ฟงกชัน แตในที่นี้จะกลาวถึงเฉพาะฟงกชันในการรับขอมูล คือ ฟงกชัน scanf( ) และฟงกชันในการแสดงผลขอมูลคือฟงกชัน print( ) ในสวนของการใชงานพื้นฐาน ซึ่งกอนจะใชงานฟงกชันดังกลาวที่สวนหัวของโปรแกรมจะตองมีคําสั่ง
                     #include   <stdio.h>
6.1 การรับขอมูล
      ฟงกชันที่ใชในการรับขอมูลมีรูปแบบของการใชงานคือ

          scanf ( รูปแบบ , อารกิวเมนต1, อารกิวเมนต2, … ) ;

           ในการรับขอมูลผูเขียนโปรแกรมจะตองกํ าหนดรูปแบบของขอมูลที่ตองการรับซึ่งสอดคลองกับชนิดของขอมูลที่ตองการรับเขา โดยที่ผูใชตองสงตํ าแหนง (หรือแอดเดรสในหนวยความจํ า – Address) ของตัวแปรที่ตองการรับเขาไปยังฟงกชัน โดยระบุในตํ าแหนงของอารกิวเมนต
ตัวอยางเชน ตองการรับขอมูลเดือนและปเปนจํ านวนเต็ม จะตองใชคําสั่ง

          int month, year;
          scanf(“%d %d”, &month, &year);12

          จากตัวอยางรูปแบบ คือ “%d %d” บอกใหรูวาตองรับขอมูล 2 ตัว โดยที่ขอมูลนั้นแยกจากกันดวย
ชองวาง %d ตัวแรกแทนขอมูลตัวแรกที่ปอนเขาสูระบบจะนํ าไปเก็บที่ตัวแปร month %d ตัวที่ 2 แทนขอมูลตัวที่ 2 ที่ปอนเขาสูระบบจะถูกนํ าไปเก็บที่ตัวแปร year ในที่นี้จะระบุตํ าแหนงของตัวแปรในหนวยความจําดวยเครื่องหมาย & (Address Operator)

                                ตาราง 1.2 แสดงรูปแบบของการรับขอมูล
                     
                          รูปแบบ                          คําอธิบายการใชงาน
                             d, i           รับขอมูลจํ านวนเต็มและแปลงขอมูลเปน int
                              ld            รับขอมูลจํ านวนเต็มและแปลงขอมูลเปน long
                              u             รับขอมูลเปนจํ านวนเต็มบวกและแปลงขอมูลเปน unsigned
                              o             รับขอมูลเปนจํ านวนเต็มบวกของเลขฐาน 8 และแปลงขอมูลเปนunsigned
                              x             รับขอมูลเปนจํ านวนเต็มบวกของเลขฐาน 16 และแปลขอมูลเปน unsigned
                              c             รับขอมูลเปนอักขระ 1 ตัว
                              s             รับขอมูลเปนสตริง
                              f              รับขอมูลทศนิยมและแปลงขอมูลเปน float
                              lf             รับขอมูลทศนิยมและแปลงขอมูลเปน double

6.2 การแสดงผลขอมูล
         การแสดงผลขอมูลสามารถทํ าไดโดยการเรียกใชฟงกชัน printf( ) มีรูปแบบคือ

                 printf ( รูปแบบ , อารกิวเมนต1 , อารกิวเมนต2 , … ) ;

          ผูเขียนโปรแกรมสามารถสงขอความใด ๆ มายังฟงกชัน print( ) หรือสงตัวแปรมาพิมพคาโดยสงผานมาทางอารกิวเมนต ใหสอดคลองกับรูปแบบที่กํ าหนด ตัวอยางเชน
               char name[ ] = “Mickey”;
               int age = 20;
               printf(“%s is %d years old.”, name, age);

ผลลัพธที่ไดคือ
              Mickey is 20 years old.

            โดยที่ %s ตัวแรกจะถูกแทนที่ดวยคาของอารกิวเมนตตัวที่ 1 คือ ตัวแปร name และ %d ตัวที่ 2 จะ
ถูกแทนที่ดวยคาของอารกิวเมนตตัวที่ 2 คือ ตัวแปร age

             นอกจากนี้ผูใชยังสามารถใช printf( ) ในการพิมพขอความใด ๆ ออกทางจอภาพโดยไมจํ าเปนตองสงอารกิวเมนตเขาไปยังฟงกชันก็ได ตัวอยางเชน
                  printf(“Good morning.”);

ผลลัพธที่ไดคือ
                  Good morning.

         คําสั่ง \n เปนอักขระพิเศษที่ไดกลาวถึงแลวคือ อักขระที่ใชสั่งใหมีการเวนบรรทัด (New Line) ในที่นี้
หลังจากพิมพขอความเสร็จจะมีการเวนวรรทัดเกิดเขึ้น จากตัวอยางจะเห็นวา %d ตัวที่ 3 เกิดจากการนําคาของตัวแปร x มาบวกกับตัวแปร y ไดผลลัพธเทาใดจึงสงใหกับ %d ตัวที่ 3 แสดงผล

ขอควรระวัง
 - การปอนขอมูลที่เปนสตริงไมจํ าเปนตองใสเครื่องหมาย & นํ าหนาตัวแปรสตริง
- หากชื่อที่ปอนเขาสูโปรแกรมมีชองวาง เชนผูใชปอนชื่อและนามสกุล โดยมีชองวางระหวางชื่อและ
นามสกุล โปรแกรมจะรับไดเฉพาะขอมูลชื่อเทานั้น โปรแกรมไมสามารถรับขอมูล ที่มีชองวางเขามาเก็บในตัวแปรได้

คำสั่ง switch

2. คําสั่ง switch
       
         คําสั่ง switch เปนคําสั่งที่ใชในการเขียนประโยคเงื่อนไข มักจะใชกับกรณีที่เปนเงื่อนไข if แบบซับซอน ตัวอยางเชน ในเรื่องของการตรวจสอบชั้นปของนักศึกษา และใหพิมพขอความตามชั้นปที่กํ าหนด ดังตัวอยางที่ แสดงในหัวขอ 3.1.3 จะเห็นวามีการตรวจสอบนิพจนเงื่อนไข คือ ชั้นปของนักศึกษาในทุกเงื่อนไขเหมือนกันประโยคในลักษณะเชนนี้สามารถใชคํ าสั่ง switch มาชวยในการเขียน เพื่อชวยใหอานเขาใจไดมากยิ่งขึ้น ทั้งนี้เงื่อนไขที่จะนํ ามาตรวจสอบในคํ าสั่ง switch ไดจะตองมีคาเปนเลขจํ านวนเต็มหรือตัวอักขระเทานั้น ไมสามารถใชกับการตรวจสอบสตริง หรือขอมูลที่มีลักษณะเปนชวง มีรูปแบบของคํ าสั่ง switch คือ

               switch ( เงื่อนไข ) {
                    case คาคงที่1 : คํ าสั่ง1 ;
                    case คาคงที่2 : คํ าสั่ง2 ;
 
                 
                    default : คํ าสั่ง N ;
                  }

             การทํางานของคําสั่ง switch จะตรวจสอบเงื่อนไข วาตรงกับคา case ใด ก็จะไปทํ างานที่คํ าสั่งที่อยูใน case นั้น คํ าสั่งหนึ่งที่มักจะใชคูกับคํ าสั่ง switch คือ คํ าสั่ง break คําสั่งนี้ใชในการบอกใหโปรแกรมหยุด การทํางาน และกระโดดออกจากขอบเขตของ { } ที่ใกลที่สุด ซึ่งสามารถใชคํ าสั่งนี้รวมกับคํ าสั่งวนซํ้าอื่น ๆ อีกดวย

             คําสั่ง default ใน switch จะมีคาเหมือนกับ else ในคํ าสั่ง if-else ก็คือคาใด ๆ ก็ตามที่ไมใชคาที่
กําหนดใน case จะมาทํ าที่คํ าสั่ง default ซึ่งคํ าสั่ง default นี้จะมีหรือไมมีก็ได
 

คําสั่ง for

3. คําสั่ง for

        คำสั่ง for เปนคําสั่งวนซํ้ าในลักษณะที่รูจํ านวนรอบของการวนซํ้ าที่แนนอน โดยแบงรูปแบบหลักออกเปน 3 สวน ไดแก
• สวนที่ใชกํ าหนดคาเริ่มตนหรือกํ าหนดคาตัวนับของการวนซํ้ า
• สวนที่ตรวจเงื่อนไขการวนซํ้ า
• สวนของการจัดการคาตัวนับของการวนซํ้า

                   for ( กําหนดคาตัวนับ ; เงื่อนไขการวนซํ้ า ; จัดการคาตัวนับ ) {
                             คําสั่ง1;
                             คําสั่ง2;
                    }

ขั้นตอนของการทํางานเมื่อพบคํ าสั่ง for มีดังนี้
1. ทําคําสั่งในการกําหนดคาตัวนับ
2. ตรวจสอบเงื่อนไขการวนซํ้า หากเปนเท็จจะหยุดและออกจากการทํางานของคําสั่ง for ไปทํางาน
คําสั่งหลังจากนั้น 49
3. กรณีเงื่อนไขการวนซํ้าเปนจริง จะทําคําสั่งในขอบเขตของ for นั้น คือภายใตเครื่อง { } จนกระทั่ง
หมด และไปทําคําสั่งจัดการคาตัวนับ ซึ่งอาจจะเปนการเพิ่มคาหรือลดคาตัวนับ หลังจากนั้นจะ
กลับทําตรวจสอบเงื่อนไขการวนซํ้าในขั้นตอนที่ 2 ทําเชนนี้เรื่อยไปจนกระทั่งเงื่อนไขการวนซํ้าเปน
เท็จ

          หากคําสั่งที่ตองทําในการวนซํ้ามีเพียง 1 คําสั่ง รูปแบบการเขียนจะเขียนเครื่องหมาย { } ครอบคําสั่งนั้นไวหรือไมก็ได แตถามีคําสั่งที่ตองทํ าซํ้ ามากกวา 1 คํ าสั่ง จะตองมีเครื่องหมาย { } แสดงขอบเขตของการทําวนซํ้าเสมอ

สิ่งที่ตองระวังในการเขียนคือ

              for (i = 0; i < 5; i++);
              printf(“Hello\n”);

            การใสเครื่องหมาย ; ตอทายคําสั่ง for เครื่องหมาย ; เปนคําสั่งที่เรียกวา Null Statement นับเปน
คําสั่ง 1 คําสั่ง โดยที่คําสั่งนี้จะไมทําอะไรเลย เพราะฉะนั้นในตัวอยางดังกลาว จะมีการวนทําซํ้าโดยไมทําอะไรเลย 5 รอบ แลวจึงพิมพขอความ Hello เพียงขอความเดียว แทนที่จะพิมพขอความ Hello 5 ครั้ง

คําสั่ง while

4. คําสั่ง while

        คําสั่ง while เปนคําสั่งวนซํ้า มักใชในกรณีที่ตองทํางานซํ้ากันหลาย ๆ ครั้ง โดยไมทราบจํานวนรอบ
ของการทําซํ้าที่แนนอน ตัวอยางเชน
        ตองการรับขอมูลเลขจํานวนเต็มบวกจากผูใชจํานวนหนึ่งเพื่อนํามาหาคาเฉลี่ยของตัวเลขที่ปอนเขามาทั้งหมด
        การทํางานดังกลาวจะตองมีการทํางานวนซํ้าเพื่อรับขอมูลและหาผลรวมของขอมูลที่รับเขามานั้น ในกรณีเชนนี้ผูที่ใชงานโปรแกรมซึ่งปอนจํานวนขอมูลเขาสูระบบอาจจะปอนขอมูลในจํ านวนที่ไมเทากัน หากตองการเขียนโปรแกรมเพื่อใหทํางานกับผูใชคนใด ๆ มักจะใชคํ าสั่ง while เขามาชวยในการเขียนโปรแกรม ในกรณีตัวอยางเราทราบวาขอมูลที่รับเขามาตองเปนขอมูลจํานวนเต็มบวกเทานั้นจึงจะนํามาหาคาเฉลี่ย ซึ่งผูเขียนโปรแกรมสามารถตั้งเงื่อนไขวา หากมีการปอนขอมูลเปนเลขจํานวนเต็มลบใหแสดงวาผูใชตองการหยุดการปอนขอมูลนั้น การทํางานของคําสั่ง while

ตัวอยาง  รับขอมูลจํานวนเต็มจากผูใช จนกวาผูใชจะปอนเลข -9999 ใหหาวามีเลขจํานวน
เต็มลบ (ไมรวม –9999) อยูกี่จํานวน และมีเลขจํานวนเต็มบวก (รวมทั้งเลขศูนย) อยูกี่จํานวน

          #include <stdio.h>

   
           void main( ) {
                   int countPlus, countMinus, num;
                   countPlus = countMinus = 0;
                   printf(“Enter number (-9999 for end) : “);
                   scanf(“%d”, &num);
                  while (num != -9999) {
                         if (num < 0)
                              countMinus++;
                        else
                              countPlus++;
                       printf(“Enter number (-9999 for end) : “);
                       scanf(“%d”, &num);
                  }
                printf(“Number less than zero = %d, more than or equal to zero = %d”,
                                                                                                     countMinus, countPlus);
            }

              ในกรณีของการใชคําสั่งวนซํ้ าตาง ๆ สิ่งที่ตองระวังคือการนํ าเอาเลขจํ านวนจริงมาเปนคาควบคุมการวนซํ้า พิจารณาจากตัวอยาง เนื่องจากเรารูวา 1/3 + 1/3 + 1/3 มีคาเทากับ 1 เราจึงจะใชวิธีการดังกลาวมาเปนตัวควบคุมการทํ างานวนซํ้ า เชน57

                   float x, y;
                  x = 1.0f;
                  y = 1/3;
                 while (x != y) {
                           printf(“\n55555”);
                           y += 1/3;
                   }

                หากทดลองเรียกใชโปรแกรมดังกลาว จะเกิดการพิมพคา 55555 ไปเรื่อย ๆ ทํ าใหเกิดสิ่งที่เรียกวา การวนซํ้าแบบอนันต หรือการวนซํ้ าแบบไมรูจบ ทั้งนี้เกิดจากการหาของภาษาซี 1 และ 3 เปนจํ านวนเต็ม เมื่อนํามาหารจะไดคาเทากับ 0 สามารถทดลองงาย ๆ ดวยคํ าสั่งเงื่อนไข
                     x = 1.0f;
                     y = (1/3) + (1/3) + (1/3);
                     if (x == y)
                           printf(“Equal”);
                    else
                           printf(“Not equal”);
             
               คําตอบที่ไดคือ Not equal เพราะฉะนั้นหากใชเลขจํานวนจริงและการคํานวณเปนเปนสิ่งควบคุม การวนซํ้าหรือนําไปเปรียบเทียบเงื่อนไขจะตองระมัดระวังในการเขียนโปรแกรม

คําสั่ง do-while

5. คําสั่ง do-while

        คําสั่ง do-while จะตองมีการทํางานคําสั่ง1 และคําสั่ง2 เสมอ หลังจากนั้นจะมีการตรวจสอบเงื่อนไข หากเงื่อนไขเปนจริงก็จะกลับไปทํ าคํ าสั่งใน do-while อีก จนกวาเงื่อนไขนั้นจะเปนเท็จ เขียนในรูปแบบของคําสั่งไดวา
                          do {
                                คํ าสั่ง1 ;
                                คํ าสั่ง2 ;
                         } while ( เงื่อนไข ) ;

         คําสั่ง do-while จะตางกับคําสั่ง while ตรงที่จะมีการทํางานคําสั่งกอนตรวจสอบเงื่อนไข ในขณะที่
คําสั่ง while จะมีการตรวจสอบเงื่อนไขกอนการทํางานเสมอ
พิจารณาจากตัวอยางการรัขอมูลใหอยูในชวงที่ตองการ สมมติใหอยูในชวงตั้งแต 10 ถึง 20 ซึ่งเปนที่แนนอนวาจะตองมีการรับขอมูลเขามากอน จากนั้นจะตรวจสอบวาขอมูลถูกตองหรือไม หากเขียนในรูปแบบของคํ าสั่ง do-while จะไดวา
                              do {
                                      printf(“Enter number (between 10 and 20) : “);
                                      scanf(“%d”, &num);
                               } while (num < 10 || num > 20);

           จากตัวอยางจะมีการรับขอมูล แลวตรวจสอบวาขอมูลอยูนอกชวงที่กํ าหนด คือ นอยกวา 10 หรือมากกวา 20 ถือวาขอมูลไมถูกตองใหไปรับขอมูลใหมจนกวาจะถูกตอง

ตัวอยาง  รับขอมูลจํานวนเต็มจากผูใช และหาคาเฉลี่ยของขอมูลที่รับเขามา จนกวาผูใชจะปอนเลข 9999

                         #include <stdio.h>
                         void main( ) {
                         int num, count=0;
                         float sum=0.0f, average;
                        do {
                               printf(“Enter number : “):
                               scanf(“%d”, &num);
                               if (num != 9999) {
                                     count++;
                                     sum += num;
                               }
                         } while (num != 9999);
                         average = sum / count;
                         printf(“Average is %.2f”, average);
                      }