วันเสาร์ที่ 11 กรกฎาคม พ.ศ. 2552

ภาษา C

ภาษาซี เป็นภาษาคอมพิวเตอร์ ที่ใช้เขียนโปรแกรมคอมพิวเตอร์ ที่มีประสิทธิภาพสูงมาก มีผู้ผลิตหลายบริษัทที่ผลิตโปรแกรม(compiler)ที่ใช้เปลี่ยนชุดคำสั่งที่เขียนในรูปแบบของภาษาซีไปเป็นภาษาเครื่องที่สั่งให้คอมพิวเตอร์ทำงานตามต้องการได้ เช่น ไมโครซอฟต์ อินไพรส์(เดิมชื่อบอร์แลนด์) เป็นต้น และแต่ละบริษัทอาจมีในหลายชื่อหลายรุ่น ซึ่งแต่ละรุ่นอาจมีความแตกต่างกันบ้าง แต่ส่วนใหญ่จะเป็นไปตามมาตรฐานของสถาบัน ANSI (American Standard National Institute) ซึ่งได้กำหนดมาตรฐานของภาษาซีไว้ ภาษาซีที่เป็นตามมาตรฐานทุกประการเรียกว่า ANSI C ในการเรียนการสอนรายวิชานี้ใช้ของบริษัทอินไพรส์ คือ Borland C/C++ 5.5 ซึ่งเป็นโปรแกรมที่แจกฟรีโดยการ download จากเว็บไซต์ของบริษัทแต่ไม่ได้แจก โปรแกรมที่ใช้สร้างชุดคำสั่ง(ที่เรียกว่า editor) มาให้แต่บอกแหล่งที่แจกโปรแกรม editor ซึ่งไม่ใช่ของบริษัทอินไพรส์ให้ เช่น โปรแกรม SC1.EXE ซึ่งใช้ในการเรียนการสอนวิชานี้ แต่ปกติก็สามารถใช้โปรแกรมประเภท text editor เช่น notepad เขียนชุดคำสั่งได้

ขั้นตอนการสร้างโปรแกรมจากภาษาซี
1. เขียนโปรแกรมต้นฉบับ (source program หรือ source code) และบันทึกโดยระบุส่วนขยายของไฟล์ เป็น .c เช่น pro1.c
2. แปลโปรแกรมต้นฉบับเป็นโปรแกรมภาษาเครื่อง(object program) ซึ่งมีส่วนขยายเป็น .obj เช่น pro1.obj ซึ่งขั้นตอนนี้เป็นการทำงานของ compiler
3. เชื่อมโยงฟังก์ชัน(library function)ในห้องสมุดของฟังก์ชันที่โปรแกรมที่สร้างมีการเรียกใช้เข้ากับโปรแกรมภาษาเครื่อง ซึ่งขั้นตอนนี้เป็นการทำงานของ linker จะได้โปรแกรม(execute program )ที่สามารถทำงานได้ตามลำพัง ได้เป็นไฟล์ที่มีส่วนขยายเป็น .EXE เช่น pro1.exe
4. ให้โปรแกรม execute program ที่ได้ทำงาน(run)โดยการป้อนชื่อโปรแกรมนั้น เช่น pro1.exe

โครงสร้างของโปรแกรมที่เขียนด้วยภาษา C
โปรแกรมที่เขียนด้วยภาษา C จะมีโครงสร้าง อย่างง่าย ดังนี้
#include หรือ header file
ส่วนประกาศ หรือ declaration part ส่วนนี้ใช้ประกาศตัวแปร ค่าคงที่ ชนิดของข้อมูล แบบ global
main() ฟังก์ชันหลักของโปรแกรม
{
คำสั่งต่าง ๆ ค่าคงที่ ฯลฯ
}
ฟังก์ชันย่อย (sub function)
{
คำสั่งต่าง ๆ ค่าคงที่ ฯลฯ
}
ไฟล์ส่วนหัว(header file) ประกอบด้วย #include ซึ่งจัดเป็น preprocessor directives เมื่อคอมไพล์โปรแกรม compiler ยังไม่ต้องการ source code แต่จะเรียก preprocessor เพื่อตรวจสอบ source ว่ามีการเรียกใช้ฟังก์ชันใดบ้างมีอยู่ในheader file ที่เรียกใช้หรือไม่ header file จะมีส่วนขยายเป็น .h จะเป็นที่เก็บรวบรวมฟังก์ชันใน library โดยที่แต่ละ header file จะจัดเก็บฟังก์ชันต่าง ๆ ไว้ แตกต่างกันไป เช่น stdiol.h จะเกี่ยวฟังก์ชันต่าง ๆที่เกี่ยวกับ I/O ต่าง ๆ โดย preprocessor directives จะเริ่มต้นด้วย # และไม่ต้องจบด้วย เครื่องหมาย ; เพราะไม่ใช่คำสั่งหรือฟังก์ชัน โดย directive มีหลายตัว เช่น include , define โดยการเขียนโปรแกรมบางครั้งอาจต้องเรียกใช้ header file หลายไฟล์เพราะมีการเรียกใช้ฟังก์ชันที่อยู่ใน library ที่เก็บไว้โดย header file ต่างกัน
Declaration part เป็นส่วนที่ใช้ในการประกาศ ชนิด ค่าของตัวแปร ค่าคงที่ ที่เป็นแบบ global เพราะถูกเรียกไปใช้ได้ในทุก ๆ ฟังก์ชัน ของโปรแกรม ในส่วนนี้ยังเป็นที่ใช้ประกาศว่ามีฟังก์ชันย่อยใดบ้างในโปรแกรม
main() เป็นฟังก์ชันหลักของโปรแกรม ซึ่งต้องมีอย่างน้อย 1 ฟังก์ชัน การทำงานของฟังก์ชันนี้นอกจากใช้คำสั่งต่าง ๆ ใช้ฟังก์ชันต่าง ๆ จาก library แล้วยังสามารถเรียกใช้ฟังก์ชันย่อย ๆ ต่าง ๆ ได้
ฟังก์ชันย่อย (sub function) เป็นฟังก์ชันที่มีการสร้างขึ้นเพื่อให้โปรแกรมเพื่อให้โปรแกรมสามารถทำงานได้ตามต้องการ

สิ่งควรรู้เป็นเบื้องต้นของภาษา C
1. ฟังก์ชัน main() จะไม่ส่งค่าให้ฟังกชันอื่น ๆ และไม่ต้องรับค่า จึงอาจเขียนว่า void main(void) โดย void หมายความว่าไม่ส่งค่ากลับไป ส่วน(void) หมายความว่าไม่มีอาร์กูเมนต์(argument) คือไม่ต้องรับค่า
2. ขอบเขตของฟังก์ชัน จะเริ่มต้นด้วยเครื่องหมาย { และสิ้นสุดขอบเขตด้วยเครื่องหมาย } นั่นคือจะเขียนฟังก์ชันใดต้องเริ่มต้นด้วย { และจบด้วย } ทำนองเดียวกันกับเมื่อนำคำสั่งหลาย ๆ คำสั่งมาประกอบกันเป็นชุดเดียวกันก็จะเริ่มด้วย { และจบด้วย } เช่นเดียวกัน
3. คำสั่งแต่ละคำสั่งจะต้องจบด้วยเครื่องหมาย ; (semicolon)
4. ชื่อฟังก์ชันและคำสั่งต่าง ๆ ในภาษาซีจะต้องใช้ตัวอักษรตัวเล็ก (lowercase)
5. ชื่อตัวแปรจะใช้ตัวอักษรตัวเล็กหรือตัวอักษรตัวใหญ่(uppercase) ก็ได้และภาษา C จะถือว่าตัวอักษรตัวเล็กตัวใหญ่ต่างกัน (case sensitive) ตัวแปรในฟังก์ชันต่างกันอาจชื่อเหมือนกันได้แต่ในฟังก์ชันเดียวกันจะมีตัวแปรชื่อเหมือนกันไม่ได้

ตัวอย่างโปรแกรม
/* นี่คือตัวอย่าง */ หรือ // ตัวอย่างนะจ๊ะ
#include /* บรรทัดที่1 */
main() // บรรทัดที่ 2
{ /* บรรทัดที่3 */
printf("Bodindecha is a school in Bangkok. \n"); // บรรทัดที่4
} // บรรทัดที่ 5
บรรทัดที่ 1 #include เป็นการเรียกใช้แฟ้มที่บรรจุความหมายรูปแบบของฟังก์ชันที่จำเป็นต้องใช้ในที่นี้คือ printf() อยู่ในแฟ้มนี้
บรรทัดที่ 2ไม่มีชนิดของฟังก์ชันนำหน้าชื่อ main และ ไม่มีอาร์กูเมนต์ในวงเล็บ หรือ อาจเขียน เป็น void main(void) แสดงว่าไม่มีการส่งค่าจากฟังก์ชันนี้และไม่มีการรับค่าที่ส่งมา
บรรทัดที่ 3 { บอกว่าฟังก์ชัน main() มีจุดเริ่มตั้งแต่ตำแหน่งนี้
บรรทัดที่ 4 เป็นการให้พิมพ์คำว่า Bodindecha is a school in Bangkok.ที่จอภาพแล้วให้ขึ้นบรรทัดใหม่ (\n)
บรรทัดที่ 5 } แสดงว่าสิ้นสุดขอบเขตของฟังก์ชัน main()
ส่วนเครื่องหมาย /* ................. */ ใช้สำหรับเขียนหมายเหตุในโปรแกรม โดย compiler จะไม่ดำเนินการกับข้อความที่อยู่ระหว่างเครื่องหมาย /* */ ในกรณีที่หมายเหตุอยู่ในบรรทัดเดียว อาจใช้นำหน้าด้วย // บอกให้รู้ว่าสิ่งที่อยู่ต่อจาก // compiler จะไม่ดำเนินการกับข้อความเหล่านั้น













ค่าคงที่ ตัวแปร ตัวดำเนินการในภาษาซี













องค์ประกอบพื้นฐานของภาษา C
อักขระ(characters) ค่าคงที่(constants) ตัวแปร(variables) ตัวดำเนินการ(operators) นิพจน์(expressions)
Characters แบ่งเป็น
ตัวเลข (digits) คือ ตัวเลข 0 ถึง 9 และเลขฐานสิบหก คือ A B C D E และ F
ตัวอักษร(letters) คือตัวอักษรในภาษาอังกฤษ เป็นตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก คือ A-Z และ a-z
อักขระพิเศษ(special characters) คือ ! * + " < # ( = > % ) ~ : / ^ - [ ; ? , & _ ] ' . space ในภาษาซี ถือว่า เครื่องหมายขีดเส้นใต้เป็นตัวอักษร ตัวหนึ่ง characters ต่าง ๆ นี้จะใช้เป็นค่าคงที่ ตัวแปร ตัวดำเนินการ
Constants เป็นค่าที่มีค่าไม่เปลี่ยนแปลง แบ่งเป็น
ค่าคงที่ประเภทเลขจำนวนเต็ม (integer constant) คือเลขจำนวนเต็ม ที่อยู่ระหว่าง -32768 ถึง 32767 เช่น -25 หรือ 0 หรือ 236 ค่าเหล่านี้แต่ละค่าใช้หน่วยความจำในการเก็บ 2 ไบต์ ค่าเหล่านี้เขียนในรูปเลขฐานสิบ ฐานแปด(เขียนโดยใช้เลขศูนย์นำหน้า เช่น 045) เลขฐานสิบหก(เขียนโดย ใช้เลขศูนย์และx นำหน้า เช่น 0x28 0X2AF)
ค่าคงที่ชนิดตัวเลขทศนิยม(floating point constants) เป็นตัวเลขทศนิยม เช่น 1.0 1.6 E+09 ค่านี้ใช้หน่วยความจำในการเก็บค่าละ 4 ไบต์ และมีค่าอยู่ในช่วง 1.2 E -38 ถึง 3.4E+38 โดย 3 ไบต์แรกเก็บค่าตัวทศนิยม ส่วนไบต์สุดท้ายเก็บเลขยกกำลัง
ค่าคงที่ชนิดตัวเลขทศนิยมความละเอียดสองเท่า (double floating point) เรียกสั้น ๆ ว่า double เก็บจำนวน 2.2E-308 ถึง 1.8E+308 เท่านั้น ใช้หน่วยความจำ 8 ไบต์ 7 ไบต์แรกเก็บเลขทศนิยม ไบต์สุดท้ายเก็บเลขยกกำลัง
ค่าคงที่ชนิดตัวอักขระ (single character constant) เก็บตัวอักขระ 1 ตัว โดยใช้เครื่องหมาย ' และ ' ล้อม 1 ตัวอักขระใช้ 1 ไบต์ เช่น 'E' 'X'
ค่าคงที่ชนิดข้อความ (string constant) ใช้เก็บข้อความ มีความยาวตั้งแต่ 1 ตัวอักขระ เก็บในรูปอาร์เรย์ แต่ละตัวใช้หน่วยความจำ 1 ไบต์ เรียงต่อกันโดยไบต์สุดท้ายจะต้องเก็บ \0 (null charactor) เพื่อบอกว่าจบข้อความแล้ว เช่น "Bodindecha" ใช้หน่วยความจำ 11ไบต์

ตัวแปร(variables)
เป็นชื่อที่ตั้งเพื่อใช้อ้างอิงถึงข้อมูลต่าง ๆ โดยตัวแปรจะมีการใช้เนื้อที่ในหน่วยความจำในปริมาณที่ต่างกันขึ้นกับชนิดของข้อมูล ข้อมูล พื้นฐานในภาษาซี มี 5 ชนิด คือ อักขระ (char) จำนวนเต็ม(int) จำนวนจริง(float) จำนวนจริงละเอียด2เท่า(double) ไม่ให้ค่าใด ๆ (void) นอกจากนี้เพื่อความสามารถในการใช้งานจึงมีการเพิ่มชนิดของตัวแปรขึ้นมาดังตาราง













ตารางแสดงชนิดของตัวแปร










การตั้งชื่อตัวแปร
1. ต้องขึ้นต้นด้วยตัวอักษรเท่านั้น ตัวต่อไปจะเป็นตัวเลขหรือตัวอักษรได้ ความยาวไม่เกิน 31 ตัว
2. ชื่อตัวแปรควรสื่อความหมายของตัวแปรเพื่อป้องกันความสับสนของการพิจารณาโปรแกรม
3.ห้ามตั้งชื่อตรงกับคำสงวนในภาษาซี ซึ่งมี 33 คำ ดังนี้
asm auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

การประกาศตัวแปร
ในการจะใช้งานตัวแปรจะต้องมีการประกาศชนิดและชื่อของตัวแปรนั้นก่อน โดยการประกาศตัวแปรใช้รูปแบบ คือ ชนิดของตัวแปร ชื่อตัวแปร โดยถ้ามีตัวแปรชนิดเดียวอาจประกาศพร้อมกันโดยใช้ คอมมา คั่นระหว่างชื่อของตัวแปร ถ้ามีการกำหนดค่าให้ใช้เครื่องหมาย = และใช้เครื่องหมายแสดงการจบคำสั่งเมื่อสิ้นสุด คำสั่ง ตัวอย่าง เช่น
char name, day = 'S' , surname[20] ="Kodedee";
int x=5 ,y,z[100]; float a=5.00 ,b,c; double k=1.234567, m ;



ตัวดำเนินการ(operator)
ตัวดำเนินการมีหลายประเภทลักษณะการดำเนินการแตกต่างกันไป ในที่นี้จะกล่าวถึงบางประเภทเท่านั้น
ตัวดำเนินการทางคณิตศาสตร์ (mathematical operators)

ตัวดำเนินการความสัมพันธ์หรือการเปรียบเทียบ (relational operators)


สัญลักษณ์ การดำเนินการ ตัวอย่าง
< น้อยกว่า 2<3 ผลลัพธ์ จริง(1)
> มากกว่า 2>3 ผลลัพธ์ เท็จ(false)(0)
<= น้อยกว่าหรือเท่ากับ 2<= 3 ผลลัพธ์ จริง(true)
>= มากกว่าหรือเท่ากับ 2>= 3 ผลลัพธ์ เท็จ(false)
== เท่ากับ 4==4 ผลลัพธ์ จริง(true)
!= ไม่เท่ากับ 2!= 2 ผลลัพธ์ เท็จ(false)

ตัวดำเนินการตรรกะ (logical operators)
สัญลักษณ์ การดำเนินการ ตัวอย่าง
&& และ(AND) (2<3)&&(3>1) ผลลัพธ์ จริง
น้อยกว่า(OR) (2>3)(4<1) ผลลัพธ์ เท็จ(false)
! ไม่(NOT) !(2> 3) ผลลัพธ์ จริง(true)


ตัวดำเนินการกำหนดค่า (assignment operators)
สัญลักษณ์ การดำเนินการ ตัวอย่าง
= กำหนดค่า(assignment) a=2 ความหมายคือ กำหนดให้a มีค่าเป็น2
+= การบวก(addition) a+=b ความหมายคือ(a=a+b)
*= การคูณ(multiplication) a*=b ความหมายคือ(a=a*b)
-= การลบ(subtraction) a-=b ความหมายคือ(a=a-b)
/= การหาร(division)a /=b ความหมายคือ(a=a/b)
%= การหารหาเศษ(remainder) a%=b ความหมายคือ(a=a%b)
-- ลดค่า(decrement) a-- หรือ --a ความหมายคือ a=a-1
++ เพิ่มค่า(increment) a++ หรือ ++a ความหมายคือ a=a+1

ลำดับการดำเนินการของตัวดำเนินการ (operator precedence)
ลำดับที่ ตัวดำเนินการ ลักษณะการทำงาน
1 ( ) [ ] . -> ซ้าย ไป ขวา
2 - ~ * & ขวา ไป ซ้าย
3 ++ -- ขวา ไป ซ้าย
4 * / % ซ้าย ไป ขวา
5 + - ซ้าย ไป ขวา
6 << >> ซ้าย ไป ขวา
7 < > <= >= ซ้าย ไป ขวา
8 == != ซ้าย ไป ขวา
9 &(bitwise AND) ซ้าย ไป ขวา
10 ^(bitwise XOR) ซ้าย ไป ขวา
11 (bitwise OR) ซ้าย ไป ขวา
12 && ซ้าย ไป ขวา
13 ซ้าย ไป ขวา
14 ?: ซ้าย ไป ขวา
15 = += -= /= %= ขวา ไป ซ้าย
16 <<= >>= ขวา ไป ซ้าย

โดยตัวดำเนินการที่มีลำดับน้อยกว่าจะดำเนินก่อนตัวดำเนินการที่มีลำดับสูงกว่า เช่น
X = 2 + 5 * 3 จะมีลำดับการดำเนินการ คือ
ลำดับที่ 1 5 * 3 (เพราะ * มีลำดับเป็น 4 ส่วน + อยู่ลำดับ 5)
ลำดับที่ 2 2 + 15
ลำดับที่ 3 17 เป็นค่าของ X

นิพจน์ (expression)
เกิดจากการนำ ค่าคงที่ หรือ ตัวแปร และตัวดำเนินการมาประกอบกัน โดยนิพจน์มีหลายชนิด เช่นนิพจน์ทางคณิตศาสตร์ นิพจน์ทางตรรกะ นิพจน์ทางการเปรียบเทียบ นิพจน์เกี่ยวกับเงือนไข นิพจน์เกี่ยวกับข้อความ เช่น
2 + x * 5 เป็นตัวอย่างของนิพจน์ทางคณิตศาสตร์ (2>3)&&(5>=4) เป็นนิพจน์ทางตรรกะและการเปรียบเทียบ !(a) เป็นนิพจน์ทางตรรกะ if(x==y) เป็นนิพจน์เงื่อนไข
ตัวอย่าง การหาผลลัพธ์ของนิพจน์
กำหนด int a = 10 , b = 12, c =3; จงหาผลลัพธ์ของ 2 * a + b % c ดำเนินการดังนี้ (2 * a) + (b %c) ผลลัพธ์ คือ 20 + 0 คือ 20
จากข้อกำหนดด้านบน จงหาผลลัพธ์ ของ (a>b)&&(c<=b) ซึ่งเราอาจพิจารณา ดังนี้
(เท็จ)&& (จริง) ดังนั้น ผลลัพธ์ คือ เท็จ
จากความรู้ที่เรียนมาในใบความรู้ที่ 1 และ 2 ควรจะเขียนโปรแกรมเป็นภาษาซีได้บ้างแล้ว
ตัวอย่าง กำหนดให้ x y z เป็นจำนวนเต็ม จงเขียนโปรแกรม หา ค่า ของ z ที่มีความสัมพันธ์กับ x y เป็นสมการทางคณิตศาสตร์ ดังนี้ z = 5x + 10y โดย x มีค่าเป็น 6 ส่วน y มีค่า 7 และแสดงผลลัพธ์ทางจอภาพ
โปรแกรม อาจเป็นทำนองนี้
/* program name 2_1_1.c */
#include
int x = 6,y=7,z;
main()
{
z = (5 * x) +( 10 * y);
printf("value of x = %d \t value of y = %d \t value of z = %d",x,y,z);
}
หรือ
/* program name 2_1_1.c */
#include
int x = 6,y=7,z;
main()
{
printf("value of x = %d \t value of y = %d \t value of z = %d",x,y,5*x+10*y);
}

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

การแสดงผล (Output)
การแสดงผลลัพธ์ ปกติก็คือแสดงออกทางจอภาพ ในภาษาซีใช้ในรูปของฟังก์ชัน เช่นเดียวกับงานอื่น ๆ โดยฟังก์ชันมาตรฐานที่มีใน library ฟังก์ชันที่ใช้แสดงผลทางจอภาพ เช่น printf() ,puts() , putchar() ฟังก์ชัน เหล่านี้อยู่ใน header file ชื่อ stdio.h
ฟังก์ชัน printf()
เป็นฟังก์ชันที่ใช้แสดงผลลัพธ์ออกทางจอภาพ การแสดงผลทางจอภาพด้วยฟังก์ชันนี้สามารถกำหนดรูปแบบและรหัสควบคุมได้ โดยฟังก์ชัน printf() มีรูปแบบ ดังนี้
printf(control string,argument list);
โดย control string รวมทั้งข้อความ รหัสกำหนดรูปแบบ รหัสควบคุม ทั้งหมดนี้ ต้องล้อมด้วยเครื่องหมาย คำพูด (") ส่วนargument list เป็นรายการของตัวแปร ค่าคงที่ หรือนิพจน์ที่จะแสดงออกทางจอภาพ หากมี ตัวแปร ค่าคงที่ หรือนิพจน์ มากกว่า 1 ค่า แต่ละค่าจะคั่นด้วยเครื่องหมาย คอมม่า(,)
รหัสกำหนดรูปแบบ(format code) เป็นรหัสกำหนดรูปแบบของตัวแปร ค่าคงที่ หรือนิพจน์ที่จะแสดงผล เช่น แสดงค่าเลขจำนวนเต็ม หรือจำนวนจริง อักขระ ข้อความ ฯลฯ ส่วนรหัสควบคุม(control code)เป็นตัวกำหนดว่าเมื่อแสดงผลแล้วลักษณะของการแสดงผลครั้งต่อไปจะเปลี่ยนเป็นอย่างไร หรือใช้แสดงผลอักขระหรือสัญลักษณ์พิเศษบางตัว
รหัสรูปแบบที่ใช้กับฟังก์ชัน printf() จะเริ่มด้วยเครื่องหมาย % ดังตารางแสดงต่อไปนี้
รหัสรูปแบบ ความหมายหรือหน้าที่ของรหัสรูปแบบ
%c ใช้กำหนดตำแหน่งที่จะแสดง อักขระ 1 ตัว (single character)
%d ใช้กำหนดตำแหน่งแสดงเลขจำนวนเต็ม(integerหรือ int ) 1 จำนวนในรูปเลขฐานสิบ
%e ใช้แสดงตัวเลขที่เป็นจุดทศนิยม (floating point ,float)ในรูป e เช่น 2.15e+2 คือแทนค่า215
%f , %lf ใช้กับข้อมูลเป็น float และ double
%g ใช้กับข้อมูล float
%h ใช้กับ short integer
%o(ตัวโอ) ใช้แสดง integer ในรูปเลขฐานแปด
%x ใช้แสดง integer ในรูปเลขฐานสิบหก
%s ใช้แสดงข้อความ
%p ใช้แสดง address ของตัวแปรพอยน์เตอร์

รหัสควบคุมที่ใช้กับ printf() (นำหน้าด้วยเครื่องหมาย \ )
รหัสควบคุม ความหมาย
\a ส่งเสียงบี๊พ
\b ลบตัวอักษรที่อยู่ด้านซ้าย1ตำแหน่ง (backspace)
\t เลื่อนตำแหน่งในการพิมพ์ครั้งต่อไป 1 แท็บ(แนวราบ horizontal)
\n ขึ้นบรรทัดใหม่
\v เลื่อนตำแหน่งไป 1 แท็บแนวดิ่ง
\r เลื่อนไปต้นบรรทัด
\" แสดงเครื่องหมาย "
\' แสดงเครื่องหมาย '
\? แสดงเครื่องหมาย ?
\\ แสดงเครื่องหมาย \

ฟังก์ชัน putchar()
เป็นฟังก์ชันที่ใช้แสดงอักขระครั้งละ 1 ตัว ทางจอภาพ รูปแบบของฟังก์ชัน คือ
Putchar(character);
ฟังก์ชัน puts()
ใช้แสดงข้อความ(ไม่ใช่อักขระ)ออกทางจอภาพ รูปแบบของฟังก์ชัน คือ
puts(string);

ฟังก์ชันรับข้อมูล (Input function)
ฟังก์ชัน getchar()
เป็นฟังก์ชันที่ใช้รับข้อมูลเป็นตัวอักขระจำนวน 1 ตัวจากแป้นพิมพ์และอักขระนั้นจะปรากฏบนจอภาพ ด้วยและต้องเคาะแป้น enter เพื่อแสดงว่าป้อนข้อมูลแล้ว แต่ในการกำหนดตัวแปรมารับค่าถ้าใช้เป็น int
จะไม่มีการฟ้องการผิดพลาด โดยค่าจำนวนเต็มที่รับจากการเคาะแป้นพิมพ์จะเป็นรหัส ASCII ของ ตัวอักษรนั้น เช่น A จะเป็น 65 แต่ถ้าตัวแปรที่มารับค่าเป็น char จะมี warning ในเรื่องการเปลี่ยนประเภทตัวแปร แต่ค่าที่จะแสดงออกมาจะตรงตามที่มีการเคาะแป้น และจะมีปัญหาเมื่อมีการใช้ฟังก์ชันนี้มากกว่า 1 ครั้ง
ฟังก์ชัน getch()
ใช้รับตัวอักขระ 1 ตัวจากแป้นพิมพ์ แต่ขณะรับไม่แสดงทางจอภาพและไม่ต้องเคาะแป้น enter
แล้ว แต่ในการกำหนดตัวแปรมารับค่าถ้าใช้เป็น int จะไม่มีการฟ้องการผิดพลาด โดยค่าจำนวนเต็มที่ตัวแปรได้รับมาเป็นค่ารหัส ASCII ของตัวอักขระ ที่เคาะแป้นพิมพ์ เช่น C เป็น 67 แต่ถ้าตัวแปรที่มารับค่าเป็น char จะมี warning ในเรื่องการเปลี่ยนประเภทตัวแปร แต่ค่าที่ได้จะแสดงออกมาได้ถูกต้อง
ฟังก์ชัน getche()
รับตัวอักขระจากแป้นพิมพ์ 1 ตัว โดยแสดงออกทางจอภาพด้วยและไม่ต้องเคาะแป้น enter ลักษณะการทำงานเป็นไปในลักษณะเดียวกับ getche() ต่างกันที่แสดงออกทางจอภาพหรือไม่เท่านั้น
ฟังก์ชัน gets()
ใช้รับข้อความจากแป้นพิมพ์ มาเก็บไว้ในชื่อตัวแปรที่กำหนด โดยเคาะแป้น enter แสดงการจบการป้อนข้อมูล มีรูปแบบ คือ gets(string_var);
โดย string_var คือ ชื่อตัวแปรที่ใช้เก็บข้อมูลที่รับมาจากการป้อนทางแป้นพิมพ์ เป็นตัวแปรประเภทข้อความ และสามารถแยกเป็นตัวอักขระได้ ทั้งหมดนี้ให้พิจารณาจากใบงาน
ฟังก์ชัน scanf()
เป็นฟังก์ชันที่ใช้รับข้อมูลประเภทต่าง ๆ จากแป้นพิมพ์ได้กว้างขวางกว่าฟังก์ชันอื่น ๆ ที่ผ่านมา ข้อมูลที่รับ เช่น จำ นวนเต็ม จำนวนจริง ข้อความ อักขระ รูปแบบของฟังก์ชัน คือ scanf(control string ,variable list);
control string เป็นรหัสสำหรับรูปแบบของข้อมูลที่จะรับเข้า โดยรหัสรูปแบบนี้เป็นทำนองเดียวกับฟังก์ชัน printf() โดยรหัสนี้ทังหมดจะต้องอยู่ภายในเครื่องหมายพูด รหัสแต่ละตัวจะแทนข้อมูลแต่ละค่า โดยสามารถมีรหัสของข้อมูล หลายค่าได้ในครั้งเดียวกันโดยไม่จำเป็นต้องมีเครื่องหมายอื่นใดมาคั่น
variable list คือรายการของชื่อตัวแปรที่จะมารับค่าของข้อมูลที่ป้อนจากแป้นพิมพ์ โดยตัวแปรต้องประเภทเดียวกับข้อมูลที่ตัวแปรนั้นรับ และจำนวนตัวแปรจะต้องมีจำนวนเท่ากับจำนวนรหัสรูปแบบของข้อมูล โดยชื่อตัวแปรนั้นอยู่หลังจากเครื่องหมายคำพูดที่ล้อมรหัสข้อมูลโดยมีการคั่นด้วยเครื่องหมายคอมม่า(,)และหากมีตัวแปรหลายตัวแต่ละตัวจะคั่นด้วยเครื่องหมายคอมม่าเช่นกัน และหน้าชื่อตัวแปรแต่ละตัวจะต้องนำด้วยเครื่องหมาย & ยกเว้นตัวแปรของข้อมูลประเภทข้อความ(string) เช่น คำสั่ง
scanf("%d %f %s",&i,&f1,word);
เป็นคำสั่งให้รับข้อมูลจากแป้นพิมพ์ 3 ค่า เป็นข้อมูลประเภท จำนวนเต็มแบบเลขฐานสิบ ตามด้วยข้อมูลเลขทศนิยม และข้อมูลประเภทข้อความ โดยมีตัวแปรชื่อ i , f1 และ word ซึ่งเป็นแปรตัวประเภท จำนวนเต็ม จำนวนทศนิยม และตัวแปรข้อความตามลำดับ มารับค่าของข้อมูลเหล่านั้น รหัสข้อมูลที่ใช้ในฟังก์ชัน scanf() เป็นดังรายการ

รหัสรูปแบบ ความหมายในการใช้
%c สำหรับข้อมูลประเภทตัวอักขระ ( character)
%d สำหรับข้อมูลจำนวนเต็มในรูปเลขฐานสิบ
%e สำหรับข้อมูลประเภททศนิยม( floating point) ที่เขียนในรูปเลขยกกำลัง
%f %lf สำหรับจำนวนประเภท float และ double
%g ใช้กับข้อมูลประเภท float
%h สำหรับข้อมูลประเภท short integer
%l สำหรับข้อมูลประเภท integer ทั้งเลขฐาน 8 ฐาน 10 และฐาน 16
%o สำหรับข้อมูลประเภท integer เลขฐาน 8 เท่านั้น
%u สำหรับข้อมูลประเภท unsigned integer เลขฐาน 10 เท่านั้น
%x สำหรับข้อมูลประเภท integer เลขฐาน 16 เท่านั้น
%s สำหรับข้อมูลประเภทข้อความ (string)

คำสั่งควบคุมการทำงานของโปรแกรม

คำสั่งทำซ้ำ(เมื่อทราบจำนวนรอบของการทำงาน) (for statement)
คำสั่ง for เป็นคำสั่ง(statement) ให้ทำซ้ำโดยมีเงื่อนไข ปกติใช้การเพิ่มค่าหรือลดค่าของตัวนับ ทำซ้ำไปเมื่อเงื่อนไขที่กำหนดเป็นจริง จนกระทั่งเมื่อเงื่อนไขเป็นเท็จให้เลิกทำ รูปแบบของคำสั่ง เป็นดังนี้
for (นิพจน์ที่1;นิพจน์ที่2;นิพจน์ที่3) คำสั่ง 1 คำสั่ง
หรือ for (นิพจน์ที่1;นิพจน์ที่2;นิพจน์ที่3)
{
คำสั่งที่1
คำสั่งที่2
...
คำสั่งสุดท้าย
}
เมื่อ นิพจน์ที่1 เป็นนิพจน์ที่ใช้กำหนดค่าเริ่มต้นให้กับตัวแปรที่ใช้ในการทำซ้ำ
นิพจน์ที่2 เป็นนิพจน์ที่ใช้เป็นเงื่อนไขโดยมีค่าได้เพียง 1 ใน 2 ค่าเท่านั้น คือ เป็นจริง หรือ เท็จ
นิพจน์ที่3 เป็นนิพจน์ที่กำหนดการเพิ่มหรือลดค่าของตัวแปรที่ใช้ในการทำซ้ำ
คำสั่ง(statement )หลัง for ถ้ามีมากกว่า 1 คำสั่ง จะต้องอยู่ภายในเครื่องหมาย { กับ } เพื่อให้รวมเป็นคำสั่งชุดเดียว เนื่องจากในภาษาซีคำสั่งที่อยู่ในการทำซ้ำแบบ for จะต้องมีเพียง 1 คำสั่ง (คำสั่งการทำซ้ำหรือเงือนไขอื่นก็เป็นเช่นเดียวกัน)
ตัวอย่าง โปรแกรม for1.c
#include
#include
int counter ;
char word[20] = "Bodindecha";
main()
{
clrscr();
for (counter = 5;counter<=10;counter = counter+1)
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
}
โปรแกรมนี้ จะลบจอภาพ ก่อน แล้วจึงกำหนด เริ่มต้น ให้ counter มีค่าเป็น 5 แล้วทดสอบว่าเงื่อนไข คือ counter <= 10 เป็นจริง หรือไม่ ถ้าเป็นจริง จะทำตามคำสั่ง
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
แล้วจึงทำตามคำสั่ง counter = counter +1 ซึ่งเป็นการเพิ่มค่า ของ counter จากเดิม แล้วตรวจสอบเงื่อนไข ถ้าเป็นจริงก็ทำต่อไปซ้ำกันไปเรื่อยจนกระทั่งนิพจน์เงื่อนไข เป็นเท็จ คือ counter มากกว่า10 จึงออกจากการทำซ้ำ

ตัวอย่าง โปรแกรม for2.c
#include
#include
int row,collumn ;
main()
{
clrscr();
for (row = 1;row<=5;row++) /* บรรทัด 1 */
{ /* บรรทัด 2 */
for(collumn=1;collumn<=4;collumn++) /* บรรทัด 3 */
printf("%d%d \t",row,collumn); /* บรรทัด 4 */
printf("\n"); /* บรรทัด 5 */
} /* บรรทัด 6 */
}
คำอธิบาย
บรรทัด 1 เริ่มต้นกำหนดค่าให้ row เป็น 1 แล้วทดสอบเงื่อนไข row <= 5 เมื่อเป็นจริง จะทำตามบรรทัด 2
ถ้าไม่จริง จะออกจาก for (row = 1;row<=5;row++) นี้และในที่นี้จะจบโปรแกรมไปเลย จากบรรทัด 2 จะไปสู่บรรทัด3 เริ่มต้นจะกำหนดค่า collumn เป็น 1 และทดสอบเงื่อนไข collumn <= 4 ถ้าเป็นจริงจะทำตามคำสั่ง printf("%d%d \t",row,collumn); ถ้าไม่จริงจะออกจาก for(collumn=1;collumn<=4;collumn++) นี้ไปทำตามคำสั่งในบรรทัด 5 คือทำตามคำสั่ง printf("\n"); แล้วกลับเข้าสู่ for (row = 1;row<=5;row++) ซ้ำกันเช่นนี้จนกระทั่งเงื่อนไข row<=5 เป็นเท็จ ก็จะออกจาก for (row = 1;row<=5;row++) และในที่นี้จะจบโปรแกรม

คำสั่งทำซ้ำหรือวนรอบ while statement
while เป็นคำสั่งให้มีการทำซ้ำเป็นรอบ ๆ (loop) ลักษณะการทำงานทำนองเดียวกับคำสั่ง for แต่ต่างกันตรงที่ไม่ทราบจำนวนรอบที่แน่นอน แต่ต้องมีเงื่อนไขที่เป็นเท็จจึงจะออกจากคำสั่ง while ได้มิฉะนั้นจะมีปัญหาที่โปรแกรมทำงานแบบวนซ้ำแบบไม่มีที่สิ้นสุด (endless loop)

คำสั่ง while มีรูปแบบ ดังนี้
while (นิพจน์ทดสอบเงื่อนไข) statement ;
หรือ
while (นิพจน์ทดสอบเงื่อนไข)
{
คำสั่งที่1;
คำสั่งที่2;
...
คำสั่งสุดท้าย;
}
โดย while จะทำการทำซ้ำต่อไปเมื่อนิพจน์ทดสอบเงื่อนไขให้ผลลัพธ์เป็นจริง และทำต่อจนกระทั่งผลลัพธ์ของนิพจน์ทดสอบเงื่อนไขเป็นเท็จ

ตัวอย่าง while statement
/* while1.c */
#include
#include
int counter ;
char word[20] = "Bodindecha";
main()
{
clrscr();
counter = 5;
while (counter < 11 )
{
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
counter++;
}
}
โปรแกรมนี้ จะลบจอภาพ ก่อน แล้วจึงกำหนด เริ่มต้น ให้ counter มีค่าเป็น 5 แล้ว จึงเข้าสู่การทำซ้ำ แบบ while ทดสอบว่าเงื่อนไข คือ counter < 11 เป็นจริง หรือไม่ ถ้าเป็นจริง จะทำตามคำสั่ง
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
แล้วจึงทำตามคำสั่ง counter++ ซึ่งเป็นการเพิ่มค่า ของ counter จากเดิม แล้วตรวจสอบเงื่อนไข ถ้าเป็นจริงก็ทำต่อไปซ้ำกันไปเรื่อยจนกระทั่งนิพจน์เงื่อนไข เป็นเท็จ คือ counter ไม่น้อยกว่า จึงออกจากการทำซ้ำ

ตัวอย่าง while statement
/* while2.c */
#include
#include
main()
{
int character =65;
clrscr();
while (character != '\r') /* line 1 */ /* start while */
{
printf("\n Enter the character that you want :");
character = getche() ;
printf("\n The ASCII Code of your character is\t%d ",character);
} /* end while */
} /* end main() */
คำอธิบาย โปรแกรมนี้นิพจน์เงื่อนไขของคำสั่ง while คือ character != '\r' หมายความว่า ค่าของ character ไม่ใช่การเคาะแป้น enter โดย character นี้เป็นตัวแปรที่รับค่าการเคาะแป้น จาก คำสั่ง character = getche() ; ดังนั้นถ้าการเคาะแป้นไม่ใช่แป้น enter เงื่อนไขก็จะยังเป็นจริง โปรแกรมจะทำซ้ำ แต่ถ้ามีการเคาะแป้น enter เงื่อนไขก็จะเป็นเท็จ ก็จะออกจากคำสั่ง while

คำสั่งทำซ้ำหรือวนรอบ do while statement
do while เป็นคำสั่งให้มีการทำซ้ำเป็นรอบ ๆ (loop) ลักษณะการทำงานทำนองเดียวกับคำสั่ง while แต่ต่างกันตรงที่คำสั่งนี้จะมีการทำงานตามคำสั่งไป 1 รอบ ก่อนที่จะทดสอบเงื่อนไข ถ้าเงื่อนไขที่เป็นจริงจะทำงานต่อไป ถ้าเงื่อนไขเป็นเท็จจึงจะออกจากคำสั่ง do while คำสั่งนี้ก็เช่นเดียวกันจะต้องกำหนดให้มีโอกาสที่เงื่อนไขเป็นเท็จได้ มิฉะนั้นจะมีปัญหาที่โปรแกรมทำงานแบบวนซ้ำแบบไม่มีที่สิ้นสุด (endless loop) กรณีที่เงื่อนไขเป็นเท็จเพียงอย่างเดียวจะมีการทำงาน 1 รอบ ก่อนออกจากการทำซ้ำ

คำสั่ง do while มีรูปแบบ ดังนี้
Do {
คำสั่งที่1;
คำสั่งที่2;
...
คำสั่งสุดท้าย;
} while (นิพจน์ทดสอบเงื่อนไข) ;
โดย do while จะทำการทำซ้ำต่อไปเมื่อนิพจน์ทดสอบเงื่อนไขให้ผลลัพธ์เป็นจริง และทำต่อจนกระทั่งผลลัพธ์ของนิพจน์ทดสอบเงื่อนไขเป็นเท็จ ก็จะออกจากการทำซ้ำ

ตัวอย่าง do while statement
/* dowhile1.c */
#include
#include
int counter ;
char word[20] = "Bodindecha";
main()
{
clrscr();
counter = 11;
do /* start do while */
{
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
counter++;
} while (counter < 11 ); /* end do while */
} /* end main() */
โปรแกรมนี้ จะลบจอภาพ ก่อน แล้วจึงกำหนด เริ่มต้น ให้ counter มีค่าเป็น 11 แล้ว จึงเข้าสู่การทำซ้ำ แบบ do while ทำตามคำสั่ง printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word); ไปก่อนแล้วจึงทดสอบว่าเงื่อนไข คือ counter < 11 เป็นจริง หรือไม่

คำสั่งควบคุมการทำงานของโปรแกรม กลุ่มที่มีการทดสอบเงื่อนไขก่อนการตัดสินใจเพื่อทำงานต่อไปตามคำสั่งที่กำหนดไว้ มีหลายคำสั่ง คือ if , if else , if else if , switch คำสั่งเหล่านี้จะมีลักษณะคล้ายกันที่ต้องมีการทดสอบเงื่อนไขเพื่อเลือกเลือกคำสั่งที่จะทำงานต่อไป
รูปแบบของคำสั่ง if เป็น ดังนี้
if (expression) statement ;
หรือ
If (expression)
{
statement 1;
...
statement n;
}
expression ในคำสั่ง if เป็นเงื่อนไขที่มีค่าได้เพียง จริง หรือ เท็จ เท่านั้น ถ้ามีเป็นจริงจะทำตามคำสั่งใน if จากนั้น ออกไปทำตามคำสั่งนอกคำสั่ง if ถ้าเงื่อนไขมีค่าเป็นเท็จ จะไม่ทำตามคำสั่งใน if ดังตัวอย่าง
ตัวอย่าง การใช้คำสั่ง if
/* if1.c */
#include
#include
int ch;
main()
{
clrscr();
printf("Please press any key.");
ch = getche();
if (ch == '\r') printf("\n Enter key ( ASCII code = 13 ) was pressed .");
printf("\n Out of if statement");
}
คำสั่ง if (ch == '\r') printf("\n Enter key ( ASCII code = 13 ) was pressed ."); กำหนดให้ตรวจสอบเงื่อนในคำสั่ง คือ ถ้าการเคาะแป้นจากคำสั่ง ch = getche(); เป็นแป้น enter จริง แล้วให้ทำตามคำสั่งใน if คือ คำสั่ง ให้แสดงข้อความว่า Enter key ( ASCII code = 13 ) was pressed . ออกทางหน้าจอ แล้วจึงทำตามคำสั่งนอกคำสั่ง if คือ แสดงข้อความว่า Out of if statement

คำสั่ง if else
เป็นคำสั่งที่มีการทดสอบเงื่อนไขแบบ 2 ทางเลือก ถ้าเงื่อนไขเป็นจริง ให้ทำตามคำสั่งชุด(A)ที่อยู่ใน if ถ้าเงื่อนไขเป็นเท็จ ให้ทำตามคำสั่งชุดใน else (ชุดB)การทำงานของคำสั่ง if else

รูปแบบของคำสั่ง if else
คำสั่ง if else มีรูปแบบ ดังนี้
if (expression) {
statement A1;

statement An;
}
else {
statement B1;

statement Bn;
}
โดย expression ใน if มีค่าได้เพียง จริง หรือ เท็จ ถ้ามีค่าเป็นจริง โปรแกรมจะทำงานต่อไปในคำสั่งหลัง if คือ คำสั่งชุด A เสร็จแล้วออกจาก if โดยไม่ทำตามคำสั่งชุด B ถ้า expression มีค่าเป็นเท็จ โปรแกรมจะทำตามคำสั่งหลัง else คือ คำสั่งชุด B แล้วออกไปโดยไม่ทำตามคำสั่งชุด A


ตัวอย่าง if else
/*ifelse1.c */
#include
#include
main()
{
int score1;
clrscr();
printf("\n Please type your score : ");
scanf("%d",&score1);
if (score1 >= 50) printf("You pass the examination.");
else printf("\n You failed the examination.");
}
เป็นโปรแกรมรับการป้อนค่าคะแนนจากแป้นพิมพ์นำไปเก็บในตัวแปร score1 แล้วนำ score1 มาเปรียบเทียบกับ 50 ถ้ามากกว่าหรือเท่ากับ 50 จะได้ผลเป็น จริง โปรแกรมจะทำตามคำสั่งใน if คือ
printf("You pass the examination."); แล้วออกจาก if โดยไม่ทำตามคำสั่งใน else แต่ถ้าเปรียบเทียบ score1 กับ 50 แล้วได้ค่าเป็นเท็จ คือ score1 น้อยกว่า 50 โปรแกรมจะทำตามคำสั่งหลัง else คือ printf("\n You failed the examination."); แล้วออกจากคำสั่งโดยไม่ทำตามคำสั่งหลัง if

คำสั่ง if else if
คำสั่งนี้มีโครงสร้าง else if เพิ่มเข้ามาในคำสั่ง else ทำให้ใช้คำสั่ง else if เพิ่มได้ตามที่ต้องการ ใช้กับการตัดสินใจที่มีทางเลือกมากกว่า2ทาง

รูปแบบของคำสั่ง if else if
if (expression1)
{
statement A;
}
else if (expression2)
{
statement B;
}
...
else if (expression n)
{
statement N;
}
else
{
statement N + 1;
}

ตัวอย่าง if else if
#include
#include
main()
{
int score1;
clrscr();
printf("\n Please type your score : ");
scanf("%d",&score1);
if (score1 >= 80) printf("\n You get A. \n Congratulation");
else if (score1 >= 70) printf("\n You get B.");
else if (score1 >= 60) printf("\n You get C.");
else if (score1 >= 50 ) printf("You get D.");
else printf("\n You get E" );
}

โครงสร้าง nested if
คำสั่งนี้มีโครงสร้าง nested if เพิ่มเข้ามาในคำสั่ง if ทำให้ใช้คำสั่ง if เพิ่มได้ตามที่ต้องการ ใช้กับการตัดสินใจที่มีทางเลือกมากกว่า 2 ทางเลือก

รูปแบบของคำสั่ง nested if
if (expression1)
if (expression 2)
{
statement 1;
}
else
{
statement 2;
}
else
{
statement 3;
}
ตัวอย่าง nested if
/* nestedif1.c */
#include
#include
main()
{
int a,b; clrscr();
printf("\n Please enter first integer : "); scanf("%d",&a);
printf("\n Please enter second integer : "); scanf("%d",&b);
if (a <= b) /* start if */
if (a < b) /* start nested if */
printf("\n\t %d \t<\t %d\n",a,b);
else
printf("\n\t %d \t==\t %d\n",a,b); /* end nested if */
else
printf("\n\t %d \t>\t %d\n",a,b); /* end if */
}

คำสั่ง switch
เ ป็นคำสั่งที่ใช้ทดสอบเงื่อนไขและมีทางเลือกของการตัดสินใจหลายทาง ทำนองเดียวกับคำสั่ง if else if แต่นิยมใช้คำสั่ง switch มากกว่า เพราะมีรูปแบบที่เข้าใจได้ง่าย สะดวกในการแก้ไขในกรณีที่มีการผิดพลาด
รูปแบบ
switch (expression) {
case (constant 1) :
statements;
break;
case (constant 2):
statements;
break;

case (constant n):
statements;
break;
default :
statements
}
expression ของ switch เป็นตัวแปรนิพจน์ที่ใช้เปรียบเทียบค่าว่าตรงกับ constant ของ case ใด โดยโปรแกรมจะปฏิบัติตามคำสั่งต่าง ๆ ใน case นั้น ส่วนคำสั่ง break; จะเป็นคำสั่งให้ออกจากคำสั่ง switch ในกรณีที่ไม่มีคำสั่ง break โปรแกรมจะปฏิบัติเรียงตามลำดับตลอดทุกคำสั่งในทุก case ที่อยู่ต่อกัน ในกรณีที่ค่าของ expression ของ switch ไม่ตรงกับ constant ของ case ใด โปรแกรมจะปฏิบัติตามคำสั่งใน default โดยข้อสังเกตที่ควรจำ ในแต่ละ case อาจมีคำสั่งหลายคำสั่งไม่ต้องใช้เครื่องหมาย { } ล้อม และที่ case ต่าง ๆ และ default จะต้องมี : (colon) ต่อท้ายดังนี้ case (constant) : และ default :
ตัวอย่าง switch
/* switch1.c */
#include
#include
main()
{
float num1 = 1.0 , num2 = 1.0;
int operate;
clrscr();
printf("\n Please enter first floating point number : ");
scanf("%f",&num1);
printf("\n Please enter seconf floating point number : ");
scanf("%f",&num2);
printf(" \n Please enter the operator. : ");
operate = getche();
switch ( operate) /* start switch */
{
case '+' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1+num2);break;
case '-' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1 - num2); break;
case '*' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1+num2);break;
case '/' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1+num2);break;
default :
printf("unknown operator");
} /* end switch */
} /* end main() */

















ไม่มีความคิดเห็น:

แสดงความคิดเห็น

แสดงความคิดเห็น