ภาษา C ถูกสร้างขึ้นครั้งแรก โดย Dennis M.Ritchie ซึ่งทำงานอยู่ที่ Bell Telephone Laboratories, Inc. (ปัจจุบันนี้คือ AT&T Bell Laboratories) ประมาณปี ค.ศ.1970 โดย Ritchie พัฒนาภาษา C มาจากภาษา BCPL และภาษา B ซึ่งในระยะแรกนี้ภาษา C ถูกนำมาใช้ภายใน Bell Laboratories เท่านั้น จนกระทั่งปี ค.ศ.1978 Brian W.Kerninghan และ Dennis M. Ritchie ได้กำหนดนิยาม ลักษณะ และรายละเอียดของภาษา C ขึ้น โดยเขียนหนังสือชื่อว่า “The C Programming Language” (สำนักพิมพ์ Prentice Hall) ออกมาเป็นเล่มแรกต่อมาบริษัทคอมพิวเตอร์ต่าง ๆ ได้เริ่มสนใจ และค้นคว้าพัฒนาภาษา C โดยอ้างอิงภาษา C ของ Kernighan และ Ritchie ทำให้มีการพัฒนา C compiler และ C interpreter ขึ้นมาเพื่อให้สามารถใช้กับเครื่องคอมพิวเตอร์ได้หลาย ๆ ชนิด และสามารถใช้กับโปรแกรมต่าง ๆ ที่บริษัทผลิตขึ้นเป็นการค้า จนกระทั่งปี ค.ศ.1985 ภาษา C ก็ได้รับความนิยมแพร่หลายไปทั่วโลก ซึ่งในช่วงนั้นภาษา C ที่ใช้กันอยู่มีมากมายหลายชนิด แล้วแต่บริษัทต่าง ๆ จะสร้างขึ้นซึ่งยังขาดมาตรฐานร่วมกัน ดังนั้นในปี ค.ศ.1988 Kernighan และ Ritchie จึงได้ร่วมกับสถาบัน ANSI (American National Standards Institute) ได้กำหนดนิยาม ลักษณะและกฎเกณฑ์ของภาษา C ที่เป็นมาตรฐานขึ้นเรียกว่า “ANSI C” ซึ่งปัจจุบันนี้บริษัทที่ผลิตภาษา C ไม่ว่าจะเป็นบริษัท Microsoft และบริษัท Borland ต่างก็ใช้มาตรฐานของ ANSI C เพื่อผลิตภาษา C รุ่นต่าง ๆ ต่อไป
2.โครงสร้างอย่างง่ายของโปรแกรมภาษา C
โปรแกรมภาษา C ที่สามารถ execute ได้ ทุกโปรแกรมจะมีโครงสร้างอย่างง่าย ดังนี้
1. มีฟังก์ชันชื่อว่า main( ) อย่างน้อยหนึ่งฟังก์ชัน จึงจะสามารถทำการ execute program ได้ลักษณะของฟังก์ชัน main( ) จะต้องเป็นฟังก์ชันที่ไม่มีการส่งค่าไปยังฟังก์ชันอื่น หรือไม่มี argument นั่นเองและจะต้องไม่มีการส่งค่ากลับมายังชื่อฟังก์ชัน โดยเราสามารถใช้คำว่า void นำหน้าฟังก์ชัน ซึ่ง main( ) สามารถเขียนได้ดังนี้ void main(void)
2. ขอบเขตฟังก์ชัน main (delimiters) ในโปรแกรมภาษา C ใช้เครื่องหมาย { แทนการเริ่มต้นฟังก์ชัน และใช้เครื่องหมาย } แทนการสิ้นสุดฟังก์ชัน ดังนั้นเมื่อเขียนฟังก์ชัน main( ) ทุกครั้งจะต้องมีเครื่องหมาย { และ } อยู่ด้วยเสมอ
3. การปิดท้ายคำสั่งในภาษา C จะต้องใช้เครื่องหมาย ; (semicolon) เป็นการบ่งชี้ให้ C compiler ทราบว่าจบคำสั่ง (statement) แต่ละคำสั่งแล้ว
4. ชื่อฟังก์ชันและคำสั่งในภาษา C จะต้องเขียนด้วยตัวอักษรตัวเล็ก (lowercase letter) ทั้งหมดทั้งนี้เพราะ C compiler จะคิดว่าตัวอักษรตัวใหญ่ (uppercase letter) กับตัวอักษรตัวเล็ก แตกต่างกัน เช่น main( ) ไม่เหมือนกับ Main( ) หรือ MAIN( ) เป็นต้น
5. ชื่อตัวแปร (variable name) สามารถตั้งชื่อโดยใช้ ตัวอักษรตัวเล็กหรือตัวอักษรตัวใหญ่ก็ได้หรือใช้ตัวอักษรตัวเล็กกับตัวอักษร ตัวใหญ่ผสมกันก็ได้ อาทิเช่น ชื่อตัวแปร name ไม่เหมือนกับ Name หรือ NAME เป็นต้น เพราะว่าลักษณะของภาษา C จะสามารถจำแนกความแตกต่างของตัวอักษรตัวเล็กและตัวใหญ่ได้ ดังนั้นเราสามารถใช้ตัวอักษรตัวเล็ก a ถึง z และตัวอักษรตัวใหญ่ A ถึง Z มาตั้งชื่อตัวแปรได้ หรือจะตั้งชื่อตัวแปรเหมือนกัน ทุกประการได้ เช่นชื่อตัวแปร a กับ a ก็ได้ แต่ตัวแปรทั้ง 2 ตัวนี้จะต้องอยู่ต่างฟังก์ชันกันเท่านั้น ถ้าอยู่ในฟังก์ชันเดียวกัน compiler จะบอกข้อผิดพลาดออกมา ซึ่งหลักเกณฑ์การตั้งชื่อตัวแปรจะอธิบายอย่างละเอียดในหัวข้อ 2.5.2
จากลักษณะโครงสร้างอย่างง่ายของภาษา C ดังกล่าวมาข้างต้นนั้น สามารถเขียนรูปแบบโครงสร้างอย่างง่าย ของโปรแกรมได้ดังนี้
รูปแบบโครงสร้างอย่างง่ายของโปรแกรม ภาษา C
# include<stdio.h>
void main(void)
{
คำสั่งประกาศตัวแปร;
คำสั่งหรือฟังก์ชันต่าง ๆ;
}
|
เพื่อให้มีความเข้าใจเกี่ยวกับโครงสร้างอย่างง่ายของโปรแกรมภาษา C มากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่างภาษา C ดังต่อไปนี้
/* simple.c */
#include<stdio.h> /* บรรทัดที่ 1 */
void main(void) /* บรรทัดที่ 2 */
{ /* บรรทัดที่ 3 */
printf(“Hello, C Language \n”); /* บรรทัดที่ 4 */
} /* บรรทัดที่ 5 */
|
โปรแกรมตัวอย่างที่ 2.1 แสดงโปรแกรมภาษา C อย่างง่าย
ผลลัพธ์ ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากตัวอย่างโปรแกรมภาษา C ข้างต้นสามารถอธิบายการทำงานได้ดังนี้
บรรทัดที่ 1 #include<stdio.h> เป็นคำสั่งที่เรียกแฟ้มที่ชื่อว่า stdio.h ซึ่งภายในจะบรรจุคำสั่ง หรือฟังก์ชันที่จำเป็นต้องใช้ในภาษา C เช่น printf( ), scanf( ) เป็นต้น
บรรทัดที่ 2 void main(void) เป็นการบอกให้ C compiler รู้ว่าฟังก์ชัน main( ) เป็นฟังก์ชันที่ไม่มีการส่งค่าข้อมูล และไม่มีการรับค่าข้อมูลกลับ
บรรทัดที่ 3 เครื่องหมาย { เป็นการแสดงจุดเริ่มต้นของฟังก์ชัน main( )
บรรทัดที่ 4 คำ สั่ง printf(“Hello, C Language \n”); เป็นคำสั่งที่ใช้พิมพ์ข้อความที่อยู่ในเครื่องหมาย “….” แสดงออกทางจอภาพแล้วขึ้นบรรทัดใหม่เพราะมีรหัส \n (new line)
บรรทัดที่ 5 เครื่อง หมาย } เป็นการแสดงจุดสิ้นสุดของฟังก์ชัน main( )
สำหรับข้อความที่อยู่ในเครื่องหมาย /*…….*/ เป็นคำอธิบายในโปรแกรมภาษา C เพื่อที่จะอธิบายให้ผู้อ่านได้ทราบว่ากำลังทำอะไรในโปรแกรม ส่วนมากถ้าเขียนโปรแกรมที่มีขนาดใหญ่เราจำเป็นต้องใช้เครื่องหมาย /*…….*/ โดยที่ C compiler จะไม่ทำงานใด ๆ เมื่อเจอเครื่องหมาย /*… */ ซึ่งจะได้อธิบายอย่างละเอียดในหัวข้อถัดไป คือหัวข้อ 2.3 คำอธิบายในโปรแกรมภาษา C
3.คำอธิบายในโปรแกรมภาษา C
คำอธิบายในโปรแกรม (program comment) คือข้อความที่แทรกอยู่ภายในโปรแกรม ซึ่งคอมพิวเตอร์จะไม่แปลข้อความนี้ให้เป็นส่วนหนึ่งของโปรแกรม กล่าวคือจะไม่มีผลต่อการทำงานของโปรแกรม เขียนไว้เพื่ออธิบายโปรแกรม ซึ่งในบางครั้งผู้เขียนโปรแกรม อาจต้องการเขียนคำอธิบาย กำกับขั้นตอนการทำงานของโปรแกรมในแต่ละขั้น ทำให้เกิดประโยชน์กับผู้เขียนและผู้ที่อ่านโปรแกรมได้เข้าใจง่ายขึ้น และช่วยทำให้การแก้ไขและปรับปรุงโปรแกรมเป็นไปได้ง่ายยิ่งขึ้น
โปรแกรมตัวอย่างที่ 2.2 แสดงการใส่คำอธิบายในโปรแกรมบรรทัดเดียว โดยการใช้เครื่องหมาย /* หน้าข้อความที่อธิบาย และใส่เครื่องหมาย */ หลังสิ้นสุดข้อความที่อธิบาย
/* The first program with C */
main()
{
statement(s);
}
|
จากโปรแกรมตัวอย่างข้างต้นมีคำอธิบายโปรแกรมดังนี้คือ /* The first program with C */เป็นการอธิบายโปรแกรมบรรทัดเดียว บอกให้ทราบว่าโปรแกรมนี้เป็นโปรแกรมแรกที่เขียนด้วยภาษา C
โปรแกรมตัวอย่างที่ 2.3 แสดงการใส่คำอธิบายในโปรแกรมมากกว่า 1 บรรทัด โดยการใช้เครื่องหมาย /* หน้าบรรทัดแรกของข้อความที่อธิบาย และใส่เครื่องหมาย */ หลังสิ้นสุดข้อความที่อธิบายของบรรทัดสุดท้าย
/* test.c */
/* This program is to show
how to write comments */
main()
{
statement(s);
}
|
จากตัวอย่างข้างต้นมีคำอธิบายโปรแกรมดังนี้ คือ /* test.c */ เป็นการอธิบายโปรแกรม บรรทัดเดียว บอกให้ทราบว่าโปรแกรมชื่อ test.c และ
/* This program is to show
how to write comments */
เป็นการอธิบายโปรแกรม 2 บรรทัด แสดงให้เห็นถึงวิธีการใส่คำอธิบายในโปรแกรม
ข้อสังเกต ในเอกสารเล่มนี้จะปรากฏการใส่เครื่อง หมาย /* … */ เพื่ออธิบายโปรแกรมตลอดทั้งเล่ม ซึ่งส่วนมากจะใช้บอกให้ทราบชื่อโปรแกรม และบอกหมายเลขบรรทัดเพื่อใช้ประกอบการอธิบายโปรแกรม
4.ขั้นตอนการพัฒนาโปรแกรมภาษา C
การพัฒนาโปรแกรมภาษา C มีขั้นตอนดังนี้
1) เขียนโปรแกรมต้นฉบับ (source program) ด้วยภาษา C ใช้โปรแกรม Turbo C/ C++ เพื่อเขียนโปรแกรมต้นฉบับด้วยภาษา C จากนั้นบันทึกโปรแกรมพร้อมกับตั้งชื่อแฟ้มไว้ แฟ้มที่ได้จะมีนามสกุล *.c หรือ *.cpp เช่น simple.c หรือ simple.cpp เป็นต้น นอกจากนี้ยังสามารถใช้โปรแกรม Turbo C/C++ เขียนโปรแกรมภาษา C++ ได้อีกด้วย
2) แปลโปรแกรมภาษา C ไปเป็นโปรแกรมภาษาเครื่อง (object program) ใช้คำสั่ง compile เพื่อแปลโปรแกรมภาษา C ไปเป็นโปรแกรมภาษาเครื่อง แฟ้มที่ได้จะมีนามสกุล *.obj ซึ่งในขั้นตอนนี้โปรแกรมต้นฉบับอาจเกิดความผิดพลาดทางไวยกรณ์ภาษา (syntax error) ขึ้นได้ จึงต้องย้อนกลับไปแก้ไขโปรแกรมต้นฉบับในข้อ 1. ให้ถูกต้องเสียก่อน
3) เชื่อมโยง (link) โปรแกรมภาษาเครื่องเข้ากับ library function ของภาษา C จะได้เป็น execute program โดยใช้คำสั่ง link แฟ้มที่ได้จะมีนามสกุล *.exe
4) สั่งให้ execute program แสดงผลลัพธ์ออกมา โดยใช้คำสั่ง run
ในขั้นตอนนี้ผู้เขียนโปรแกรม ควรตรวจสอบผลลัพธ์ที่ได้จากโปรแกรมว่าตรงกับความต้องการของเราหรือไม่ ถ้าผลลัพธ์ที่ได้ไม่ตรงกับความต้องการให้กลับไปแก้ไขโปรแกรมต้นฉบับในข้อ 1. เสร็จแล้วทำขั้นตอน ข้อ 2. ถึง ข้อ 4. ซ้ำอีก ทำซ้ำเช่นนี้จนกว่าจะได้ผลลัพธ์ที่ต้องการ
หมายเหตุ ในทางปฏิบัติ การ compile/ link/ run ในโปรแกรม Turbo C/C++ สามารถทำให้พร้อมกันทั้ง 3 ขั้นตอน คือใช้คำสั่ง Ctrl + F9 (กดปุ่ม Ctrl และปุ่ม F9 พร้อมกัน)
โดยสรุปเราสามารถเขียนผังงานแสดงขั้นตอนการพัฒนาโปรแกรมภาษา C ได้ดังนี้
รูปที่ 2.1 ผัง งานแสดงขั้นตอนการพัฒนาโปรแกรมภาษา C
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 44.
5.ข้อมูลของภาษา C
สำหรับเรื่องข้อมูลของภาษา C จะกล่าวถึงเรื่องตัวอักขระ ค่าคงที่ และตัวแปร ดังรายละเอียดต่อไปนี้
5.1 ตัวอักขระ (charactors)
ตัวอักขระในภาษา C สามารถจำแนกออกเป็น 3 ประเภท คือ
1) ตัวเลข (digits) คือ ตัวเลข 0, 1, 2, …., 9 และตัวเลขฐานสิบหก A, B, C, D, E และ F
2) ตัวอักษร (letters) สามารถใช้ตัวอักษรพิมพ์ใหญ่ (uppercase letter) คือ A, B, C, …, Z และตัวอักษรพิมพ์เล็ก (lowercase letter) คือ a, b, c, …., z รวมทั้งสิ้น 52 ตัวอักษร
3) ตัวอักขระพิเศษ (special character) ซึ่งได้แก่
! * + “ <
# ( = | >
% ) ~ ; /
^ - [ : ,(comma)
? & _ ] ‘
.(dot) b (blank หรือ space)
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 47.
ยกเว้นเครื่องหมาย _ (underscore) เพียงตัวเดียวที่ภาษา C จัดเป็นตัวอักษรตัวหนึ่ง โดยที่ตัวอักขระชนิดต่าง ๆ นี้จะถูกนำไปใช้เป็นค่าคงที่ ตัวแปร ตัวดำเนินการ หรือนิพจน์ ที่ใช้ในภาษา C ต่อไป
5.2 ค่าคงที่ (constants)
ค่าคงที่ คือ ตัวอักขระที่นำมาประกอบกันตั้งแต่ 1 ตัวอักขระขึ้นไป เพื่อบอกลักษณะอย่างใดอย่างหนึ่งของข้อมูล บางครั้งเราอาจเรียกค่าคงที่ว่า “ข้อมูล” (data) ก็ได้
ค่าคงที่พื้นฐานที่สำคัญในภาษา C มีดังนี้
1) ค่าคงที่ชนิดตัวเลขจำนวนเต็ม (integer constant)
ค่าคงที่ชนิดนี้จะเป็นตัวเลขจำนวนเต็มซึ่งอาจมีเครื่องหมายบวกหรือลบก็ได้ เช่น 0, 9, 85, -698, 1832, -2080 เป็นต้น โดยตัวเลขจำนวนเต็มที่จะสามารถเก็บได้ปรกติจะอยู่ในช่วง -32768 ถึง 32767 เท่านั้น บางครั้งเรานิยมเรียกค่าคงที่ชนิดนี้ว่าค่าคงที่ int (integer)
สำหรับการเก็บค่าคงที่ชนิด int นี้ภายในหน่วยความจำ จะใช้เนื้อที่ 2 bytes นอกจากนี้ยังสามารถเขียนค่าคงที่ชนิดนี้ให้อยู่ในรูปแบบตัวเลขฐานแปดและฐาน สิบหกได้ โดยใช้ตัวเลขศูนย์ (0) นำหน้าแล้วตามด้วยเลขฐานแปดที่ต้องการหรือจะใช้ตัวเลขศูนย์เอ็กซ์ (0x หรือ 0X) นำหน้าแล้วตามด้วยเลขฐานสิบหกที่ต้องการ เช่น 046, 027, 0xBD, 0X1BCF เป็นต้น
2) ค่าคงที่ชนิดตัวเลขทศนิยม (floating point constant)
ค่าคงที่ชนิดนี้จะเป็นตัวเลขจำนวนทศนิยม ซึ่งอาจจะมีเครื่องหมายบวก หรือลบก็ได้ หรือเป็นตัวเลขที่สามารถเขียนอยู่ในรูป E ยกกำลังได้ เช่น 3.0, 0.234, -0.54, 4E-06, 1.675E+10 เป็นต้น โดยตัวเลขทศนิยมนี้จะสามารถเก็บได้ปรกติจะอยู่ในช่วง 1.2E-38 ถึง 3.4E+38 เท่านั้น
สำหรับการเก็บค่าคงที่ชนิด float นี้จะใช้เนื้อที่ภายในหน่วยความจำ 4 bytes โดยที่ 3 bytes แรกจะเก็บค่าตัวเลขทศนิยม ส่วนอีก 1 bytes สุดท้ายจะเก็บค่ายกกำลังเอาไว้
3) ค่าคงที่ตัวเลขทศนิยมที่มีความละเอียดสองเท่า (double floating point)
ค่าคงที่ชนิดนี้นิยมเรียกว่า ค่าคงที่แบบ double ซึ่งจะสามารถเก็บตัวเลขทศนิยมที่มีค่าอยู่ในช่วง 2.2E-308 ถึง 1.8E+308 เท่านั้น
สำหรับการเก็บค่าคงที่ชนิด double นี้ จะใช้เนื้อที่ภายในหน่วยความจำ 8 bytes โดยใช้ 7 bytes แรกเก็บค่าตัวเลขทศนิยม ส่วนอีก 1 bytes สุดท้ายจะเก็บค่ายกกำลังเอาไว้ เช่นเดียวกับค่าคงที่ชนิด float
4) ค่าคงที่ชนิดตัวอักขระตัวเดียว (single character constant)
ค่าคงที่ชนิดนี้จะสามารถเก็บตัวอักขระได้เพียง 1 ตัวอักขระ โดยอยู่ภายในเครื่องหมาย ‘ ’ (single quotation) เช่น ‘5’, ‘X’, ‘c’ เป็นต้น
สำหรับการเก็บค่าคงที่ชนิด single character constant จะใช้เนื้อที่ภายในหน่วยความจำ 1 bytes
5) ค่าคงที่ชนิดข้อความ (strings constant)
ค่าคงที่ชนิดนี้จะเก็บตัวอักขระที่มีความยาวตั้งแต่ 1 ตัวขึ้นไป โดยจะเก็บอยู่ในรูปของข้อมูลอะเรย์ (arrays) ซึ่งในแต่ละตัวอักขระจะใช้เนื้อที่ในการเก็บ 1 bytes เรียงติดต่อกันไปจนกระทั้งจบข้อความ และใน byte สุดท้ายจะเก็บ (null character) เอาไว้เพื่อเป็นการบอกว่า จบข้อความแล้ว การเขียนค่าคงที่ชนิดข้อความจะต้องเขียนอยู่ภายในเครื่องหมาย “……” (double quotation) เช่น “X”, ”computer”, “4567”, “c” เป็นต้น
ตัวอย่างที่ 2.1 แสดงการเก็บข้อมูลชนิดข้อความ คำว่า “COMPUTER” ภายในหน่วยความจำ จะมีลักษณะดังนี้
รูปที่ 2.2 แสดง การเก็บข้อมูลชนิดข้อความคำว่า “COMPUTER” ภายในหน่วยความจำ
ที่มา : สมชาย รัตนเลิศนุสรณ์, 2545 : 49.
5.3 ตัวแปร (variables)
ตัวแปร คือ ชื่อที่ผู้เขียนโปรแกรมตั้งขึ้นเพื่อใช้เป็นข้อมูล หรือใช้เก็บข้อมูล ดังนั้นเราต้องกำหนดตัวแปรให้สอดคล้องกับชนิดข้อมูลเสมอ เพื่อให้ระบบเตรียมเนื้อที่ในหน่วยความจำให้สอดคล้องกับตัวแปรชนิดนั้น ๆ ซึ่งเนื้อหาที่กล่าวถึงเกี่ยวกับตัวแปรประกอบด้วย หลักเกณฑ์การตั้งชื่อตัวแปร การประกาศตัวแปร และการกำหนดค่าเริ่มต้นให้กับตัวแปร
5.3.1 หลักเกณฑ์การตั้งชื่อตัวแปร
ในภาษา C มีหลักเกณฑ์การตั้งชื่อตัวแปรดังนี้
1) ชื่อตัวแปรจะต้องขึ้นต้นด้วยตัวอักษรเท่านั้น ตัวถัดมาเป็นได้ทั้งตัวอักษร ตัวเลข แต่ต้องไม่มีเครื่องหมายคำนวณ บวก (+), ลบ (-), คูณ (*), หาร (/), หารเอาเศษ (%) และเครื่องหมายเว้นวรรค (blank) คั่นระหว่างชื่อตัวแปร แต่ถ้าต้องการตั้งชื่อตัวแปรเว้นวรรคให้ใช้เครื่องหมาย _ (underscore) คั่นแทนการเว้นวรรค เช่น sum_1, sum_2 เป็นต้น
2) ความยาวของชื่อตัวแปร ขึ้นอยู่กับคอมไพเลอร์และระบบเครื่องคอมพิวเตอร์ ซึ่งภาษา C สามารถตั้งชื่อตัวแปรได้ยาวถึง 32 ตัว แต่โดยปกติเราไม่นิยมตั้งชื่อตัวแปรยาว ๆ
3) ชื่อตัวแปรตัวอักษรพิมพ์ใหญ่และตัวอักษรพิมพ์เล็ก แม้จะเขียนคำเดียวกัน หรือตัวอักษรพิมพ์ใหญ่ปนตัวอักษรพิมพ์เล็กที่สลับตำแหน่งกัน ระบบถือว่าเป็นคนละตัวแปรกัน เช่น ตัวแปร MAX, max, Max, mAx, maX จะถือว่าตัวแปรทั้ง 5 ตัวนี้เป็นคนละตัวกัน
4) ห้ามตั้งชื่อตัวแปรซ้ำกับคำสงวน (reserved word) หรือชื่อฟังก์ชัน หรือชื่อคำสั่งในภาษานั้น ๆ
คำสงวนในภาษา C ตามมาตรฐาน ANSI (American National Standards Institute) มี 33 keywords ดังนี้
asm, 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 izeof volatile
do if static while
ที่มา : Aitken, P. and B. Jones, 1994 : 600 – 601.
5) ชื่อตัวแปรควรตั้งให้สัมพันธ์กับข้อมูลที่ต้องการเก็บ เพื่อป้องกันความสับสน เนื่องจากโปรแกรมที่มีขนาดใหญ่จะมีตัวแปรจำนวนมาก ถ้าเราตั้งชื่อตัวแปรโดยไม่มีระบบระเบียบที่ดีพอจะทำให้ผู้อ่านโปรแกรมเกิด ความสับสนและในกรณีที่โปรแกรมเกิดข้อผิดพลาดขึ้นจะเสียเวลาในการแก้ไข โปรแกรมมากขึ้น เช่น
ตัวแปร name ใช้เก็บชื่อ
ตัวแปร age ใช้เก็บอายุ
ตัวแปร salary ใช้เก็บเงินเดือน
ตัวแปร vat ใช้เก็บภาษี
5.3.2 การประกาศตัวแปร (declaration of variables)
ตัวแปรทุกตัวต้องมีการประกาศชื่อตัวแปร (variable name) และชนิดของตัวแปร (variable type) เอาไว้ก่อน จึงจะสามารถนำตัวแปรที่ประกาศไว้มาใช้งานได้
รูปแบบการประกาศตัวแปร
โดยที่
vtype คือ ชนิของตัวแปรพื้นฐานที่นิยมใช้กันมีอยู่ 4 ชนิด คือ char, int, float, และ double ซึ่งในความเป็นจริงแล้ว การประกาศชนิดของตัวแปรจะต้องให้ความสัมพันธ์กับค่าข้อมูลที่ต้องการเก็บ ด้วย ดังแสดงในตารางที่ 2.1 vname คือ ชื่อของตัวแปร ถ้ามีตัวแปรหลายตัวที่ต้องการให้มีชนิดตัวแปรเหมือนกัน สามารถใช้เครื่องหมาย , (omma) คั่นระหว่างชื่อตัวแปรได้
ตัวอย่างที่ 2.2 แสดง การประกาศตัวแปร
1. char d, c[30];
จะได้ตัวแปร d มีชนิดเป็น single character และตัวแปรสตริง c มีขนาด 30 bytes
2. int a, b;
จะได้ตัวแปร a และ b มีชนิดเป็น int คือใช้เนื้อที่ในหน่วยความจำ 2 bytes สามารถเก็บ ตัวเลขจำนวนเต็มที่มีค่าอยู่ในช่วง -32768 ถึง 32767
3. float k, m, n,
จะได้ตัวแปร k, m และ n มีชนิดเป็น float คือใช้เนื้อที่ในหน่วยความจำ 4 bytes สามารถเก็บ จำนวนทศนิยม และตัวเลขที่อยู่ในรูป E ยกกำลังได้
4. double w, x, y, z
จะได้ตัวแปร w, x, y และ z มีชนิดเป็น double คือใช้เนื้อที่ในหน่วยความจำ 8 bytes สามารถ เก็บจำนวนทศนิยม หรือตัวเลขที่อยู่ในรูป E ยกกำลังที่มีความละเอียดสูงกว่าชนิด float
ตารางที่ 2.1 แสดง ชนิดของตัวแปร จำนวน bytes และพิสัยของค่าข้อมูลในภาษา C
ชนิดของตัวแปร
(variable types)
|
จำนวน bytes ที่ใช้
|
พิสัยในการเก็บข้อมูล
(range)
|
char
|
1
|
-128 to 127
|
int
|
2
|
-32,768 to 32,767
|
short
|
2
|
-32,768 to 32,767
|
long
|
4
|
-2,147,483,648 to 2,147,483,647
|
unsigned char
|
1
|
0 to 255
|
unsigned int
|
2
|
0 to 65,535
|
unsigned short
|
2
|
0 to 65,535
|
unsigned long
|
4
|
0 to 4,294,967,295
|
enum
|
2
|
0 to 65,535
|
float
|
4
|
1.2E-38 to 3.4E+38
|
double
|
8
|
2.2E-308 to 1.8E+308
|
ที่มา : Aitken, P. and B. Jones, 1994 : 40.
กรณีที่ต้องการประกาศตัวแปรและกำหนดค่าเริ่มต้นให้กับตัวแปรด้วยสามารถทำได้ ดังนี้
รูปแบบการประกาศตัวแปรและกำหนดค่าให้กับตัวแปร
กรณีที่มีตัวแปร 1 ตัว vtype vname = value;
กรณีที่มีตัวแปรมากกว่า 1 ตัว vtype vname1 = value1, vname2 = value2 ,…..,
vnameN = valueN;
กรณีที่มีตัวแปรมากกว่า 1 ตัว ให้ใช้เครื่องหมาย , (comma) คั่นระหว่างชื่อตัวแปรแต่ละตัว
|
ตัวอย่างการประกาศตัวแปรและกำหนดค่าให้กับ ตัวแปร
5.3.3 การกำหนดค่าเริ่มต้นให้กับตัวแปร (initializing variables)
ตัวอย่างที่ 2.3 แสดง การประกาศตัวแปรและกำหนดค่าให้ตัวแปร
1. char d=’D’,e=’E’;
2. char c[6]=”Hello”;
3. int a=9, b=25;
4. float k=5.9;
5. double y=3.543006089;
5.3.4 การกำหนดค่าเริ่มต้นให้กับตัวแปร (initializing variables)
หลังจากที่เราได้ประกาศตัวแปรไว้ ถ้าเราต้องการกำหนดค่าเริ่มต้นให้กับตัวแปรใดเราสามารถทำได้ดังนี้
รูป แบบกำหนดค่าเริ่มต้นให้กับตัวแปร
โดยที่
vname คือ ชื่อตัวแปรที่ได้ประกาศแล้ว
value คือ ค่าข้อมูลที่จะนำไปเก็บไว้ในตัวแปร ซึ่งอาจเป็นค่าตัวเลขหรือข้อความก็ได้ ถ้าเป็นข้อความจะต้อง เขียนอยู่ในเครื่องหมาย “……”
ตัวอย่างที่ 2.4 แสดงการ ประกาศค่าตัวแปรและกำหนดค่าเริ่มต้นให้กับตัวแปร
int a, b, c=7; /* เป็นการประกาศตัวแปร a, b, และ c, เป็น int และกำหนด ค่าตัวแปร c มีค่า 7 */
a=b=c; /* เป็นการกำหนดค่าตัวแปร a และ b ให้มีค่าเท่ากับตัวแปร c (คือมีค่าเท่ากับ 7) */
6.ตัวดำเนินการ (operators)
ตัวดำเนินการบางครั้งเรียกว่า “เครื่องหมาย” จะเข้าใจง่ายกว่า ในภาษา C สามารถแบ่งตัวดำเนินการได้หลายประเภทดังนี้
6.1 ตัวดำเนินการคณิตศาสตร์ (mathematical operators)
ตารางที่ 2.2 แสดง ตัวดำเนินการคณิตศาสตร์
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
+
|
บวก (addition)
|
a+b
|
-
|
ลบ (subtraction)
|
a-b
|
*
|
คูณ (multiplication)
|
a*b
|
/
|
หาร (division)
|
a/b
|
%
|
หารเอาเศษ (remainder)
|
a%b
|
ที่มา : Aitken, P. and B. Jones, 1994 : 61.
ผลลัพธ์ที่ได้จากการคำนวณทางคณิตศาสตร์จะอยู่ในรูปของตัวเลข
6.2 ตัวดำเนินการความสัมพันธ์ (relational operators)
ตารางที่ 2.3 แสดงตัว ดำเนินการความสัมพันธ์
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
<
|
น้อยกว่า (less than)
|
A<b
|
>
|
มากกว่า (greater than)
|
a>b
|
<=
|
น้อยกว่าหรือเท่ากับ
(less than or equal)
|
A<=b
|
>=
|
มากกว่าหรือเท่ากับ
(greater than or equal)
|
a>=b
|
==
|
เท่ากับ (equal)
|
A==b
|
!=
|
ไม่เท่ากับ (not equal)
|
a!=b
|
ที่มา : Aitken, P. and B. Jones, 1994 : 66.
ผลลัพธ์ที่ได้จากตัวดำเนินการความสัมพันธ์ จะได้ค่าจริง (1) หรือค่าเท็จ (0) เท่านั้น
6.3 ตัวดำเนินการเชิงตรรกะ (logical operators)
ตารางที่ 2.4 แสดงตัว ดำเนินการเชิงตรรกะ
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
&&
|
และ (AND)
|
A<b && c>d
|
||
|
หรือ (OR)
|
a<b || c>d
|
!
|
ไม่ (NOT)
|
!(a<b)
|
ที่มา : Aitken, P. and B. Jones, 1994 : 75.
ผลลัพธ์ที่ได้จากตัวดำเนินการเชิงตรรกะ จะได้ค่าจริง (1) หรือค่าเท็จ (0) เท่านั้น
6.4 ตัวดำเนินการเพิ่มค่าและลดค่า (increment and decrement operators)
ตารางที่ 2.5 แสดงตัว ดำเนินการเพิ่มค่าและลดค่า
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
++
|
เพิ่มค่า (increment)
|
a++ หรือ ++a
|
–
|
ลดค่า (decrement)
|
a– หรือ –a
|
ที่มา : Aitken, P. and B. Jones, 1994 : 58.
ผลลัพธ์ที่ได้จากการเพิ่มค่าและลดค่าจะอยู่ในรูปของค่าตัวเลข
6.5 ตัวดำเนินการบิตไวส์ (bitwise operators)
ตารางที่ 2.6 แสดง ตัวดำเนินการบิตไวส์
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
&
|
AND
|
a&b
|
|
|
inclusive OR
|
a|b
|
^
|
exclusive OR
|
a^b
|
~
|
Complement
|
~a
|
>>
|
right shift
|
a>>2
|
<<
|
left shift
|
a<<3
|
ที่มา : Gottfried, S. Byron, 1990 : 475.
6.6 ตัวดำเนินการกำหนดค่า (compound assignment operators)
ตารางที่ 2.7 แสดง ตัวดำเนินการกำหนดค่า
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
=
|
Assignment
|
a=b
|
+=
|
Addition
|
a+=b หมายถึง (a=a+b)
|
-=
|
Subtraction
|
a-=b หมายถึง (a=a-b)
|
*=
|
Multiplication
|
a*=b หมายถึง (a=a*b)
|
/=
|
Division
|
a/=b หมายถึง (a=a/b)
|
%=
|
Remainder
|
a%=b หมายถึง (a=a%b)
|
&=
|
bitwise AND
|
a&=b หมายถึง (a=a&b)
|
|=
|
bitwise Inclusive OR
|
a|=b หมายถึง (a=a|b)
|
^=
|
bitwise exclusive OR
|
a^=b หมายถึง (a=a^b)
|
<<=
|
right shift
|
a<<2 หมายถึง (a=a<<2)
|
>>=
|
left shift
|
a>>3 หมายถึง (a=a>>3)
|
ที่มา : Aitken, P. and B. Jones, 1994 : 79.
6.7 ตัวดำเนินการแบบเงื่อนไข (conditional operators)
ตารางที่ 2.8 แสดงตัว ดำเนินการแบบเงื่อนไข
สัญลักษณ์ (symbol)
|
ตัวดำเนินการ (operators)
|
ตัวอย่าง
|
Result = (expression) ?
Value1 : vaule2 ;
|
Conditional Operators
|
Max = (a>b) ? a: b;
|
ที่มา : Aitken, P. and B. Jones, 1994 : 80.
ผลลัพธ์ที่ได้จากตัวดำเนินการแบบเงื่อนไขจะให้ค่าใดค่าหนึ่งขึ้นอยู่กับ เงื่อนไขที่กำหนดจากตัวอย่างหมายความว่า ถ้าเงื่อนไข a>b เป็นจริงได้ค่า max=a; ถ้าเงื่อนไข a>b เป็นเท็จได้ค่า max=b;
7.ลำดับการทำงานของตัวดำเนินการ (precedence and associativity of operators)
ตารางที่ 2.9 แสดง ลำดับการทำงานของตัวดำเนินการในภาษา C มีดังนี้
ลำดับที่
|
ตัวดำเนินการ
(Operator)
|
ลักษณะการทำงาน(Associativity)
|
1
|
( ) [ ] . ->
|
Left to right
|
2
|
- ~ ! * &
|
Light to left
|
3
|
++ – –
|
Right to left
|
4
|
* / %
|
Left to right
|
5
|
+ -
|
Left to right
|
6
|
<< >>
|
Left to right
|
7
|
< > < = >=
|
Left to right
|
8
|
= = !=
|
Left to right
|
9
|
& (bitwise AND)
|
Left to right
|
10
|
^ (bitwise exclu OR)
|
Left to right
|
11
|
| (bitwise inclu OR)
|
Left to right
|
12
|
&&
|
Left to right
|
13
|
||
|
Left to right
|
14
|
?:
|
Left to right
|
15
|
= += -= /= %=
|
Right to left
|
16
|
<<= >>=
|
Right to left
|
ที่มา : Gottfried, S. Byron, 1990 : 475.
ตัวดำเนินการที่มีลำดับการทำงานอันดับที่ 1 จะทำงานก่อนอันดับที่ 2 โดยทำงานไปเรื่อย ๆ จนกระทั่งหมดตัวดำเนินการ ส่วนลักษณะการทำงานของตัวดำเนินการแต่ละอันดับนั้นแตกต่างกันไป ซึ่งจะเป็นการทำงานจากซ้ายไปขวา (left to rigth) หรือขวาไปซ้าย (rigth to left) ก็ได้
ตัวอย่างที่ 2.5 แสดงขั้นตอนการทำงานของ ตัวดำเนินการ
8 + 5 * 3
4 +15
19
|
ตัวดำเนินการ * อยู่ลำดับสูงกว่าตัวดำเนินการ + จึงต้องคูณเลขก่อนแล้วทำการบวกเลขทีหลัง
|
10 / 2 + 5 – 3
5 + 5 – 3
10 – 3
7
|
ตัวดำเนินการ / อยู่ลำดับสูงกว่าตัวดำเนินการ + และ - ส่วนตัวดำเนินการ + และ - อยู่ลำดับเดียวกัน แต่ให้ทำจากซ้ายไปขวา จึงทำบวกก่อนแล้วจึงทำลบ
|
9 * 3 – 20 / 5 + 6
27 - 4 + 6
23 + 6
29
|
ตัวดำเนินการ * และ / อยู่ลำดับเดียวกันให้ทำจากซ้ายไปขวา คือ คูณเลขก่อน แล้วหารเลข ส่วนตัวดำเนินการ - และ + อยู่ลำดับเดียวกันให้ทำจากซ้ายไปขวา คือ ลบเลขก่อนแล้วจึงบวกทีหลัง
|
8.นิพจน์ (expression)
นิพจน์ คือ การนำค่าคงที่ ตัวแปร และตัวดำเนินการมาเขียนประกอบกัน เพื่อให้ตัวแปรภาษาสามารถเข้าใจและคำนวณหาผลลัพธ์ได้ตามที่เราต้องการ
ตัวอย่างที่ 2.6 ถ้าต้องการหาค่าจากสูตร a2+2ab+b2 เมื่อ a=2, b=3 เราจะต้องเขียนสูตรดังกล่าวให้เป็นนิพจน์ดังนี้
a*a+2 *a *b+b*b ……………………..…………………………… แบบที่ 1
หรือ pow(a,2) + 2 *a *b + pow(b,2) ……………………………… แบบที่ 2
สำหรับฟังก์ชัน pow(x,y) เป็นฟังก์ชันที่ใช้หาค่าตัวเลขที่อยู่ในรูปเลขยกกำลัง
โดยที่ x เป็นเลขฐานซึ่งจะต้องมีค่าเป็นเลขจำนวนเต็มบวกหรือศูนย์ก็ได้
y เป็นเลขยกกำลังซึ่งอาจจะเป็นเลขจำนวนเต็มบวกหรือลบก็ได้
ดังนั้น pow(x,y) หมายถึง xy ส่วน pow(a,2) หมายถึง a2 และ pow(b,2) หมายถึง b2
ข้อควรระวัง ก่อนที่เราจะใช้ฟังก์ชัน pow(x,y) นี้จะต้องใช้คำสั่ง #include<math.h> อยู่บนส่วนต้นของโปรแกรม เพื่อนำแฟ้ม math.h เข้ามาไว้ในโปรแกรมภาษา C ก่อน มิฉะนั้นอาจเกิดข้อผิดพลาดในการแปลโปรแกรมได้เพราะไม่สามารถหาฟังก์ชัน pow(x,y) ได้
ตัวอย่างที่ 2.7 แสดง นิพจน์ตัวอย่าง ซึ่งมีอยู่หลายชนิดตังต่อไปนี้
1) a+b*10+(3*c)*8 /* นิพจน์ทางคณิตศาสตร์*/
2) (m>=n)&&(x<y) /* นิพจน์เชิงตรรกะและนิพจน์เชิงเปรียบเทียบความสัมพันธ์*/
3) !(k==25) /* นิพจน์เชิงตรรกะและนิพจน์เชิงเปรียบเทียบความสัมพันธ์*/
4) !(p) /* นิพจน์เชิงตรรกะ*/
5) (i>10)||(j<5) /* นิพจน์เชิงตรรกะและนิพจน์เชิงเปรียบเทียบ*/
6) if (y==z) /* นิพจน์เงื่อนไข*/
ตัวอย่างที่ 2.8 แสดง การหาค่าผลลัพธ์จากนิพจน์ในภาษา C
กำหนดให้ int x=5, y=8, z=9;
1) x+(y*z) ผลลัพธ์คือ 77
2) x+y*z+x*3 ผลลัพธ์คือ 92
9.การแปลงชนิดข้อมูลของภาษา C (C type conversion)
เมื่อเราเขียนโปรแกรมมักจะพบว่า ใช้ตัวดำเนินการกับตัวแปรของชนิดข้อมูลแตกต่างกัน เพื่ออำนวยความสะดวกในการเขียนโปรแกรมภาษา C จึงได้กำหนดกฎเกณฑ์ดังนี้ ถ้าค่าตัวแปร หรือค่าคงที่ต่างชนิดกัน ให้ทำการเปลี่ยนชนิดของข้อมูลที่มีขนาดเล็กให้เป็นชนิดของข้อมูลที่ใหญ่ขึ้น โดยให้ศึกษารายละเอียดในตารางที่ 2.9 ต่อไปนี้พอสังเขป
ตารางที่ 2.10 แสดง การเปลี่ยนแปลงชนิดของข้อมูล
ชนิดของข้อมูล x
|
ชนิดของข้อมูล y
|
x ชนิดของข้อมูล y
|
int
|
long
|
long
|
char
|
int
|
int
|
int
|
float
|
float
|
int
|
double
|
double
|
float
|
double
|
double
|
long
|
double
|
double
|
ชนิดข้อมูลต่าง ๆ
|
long double
|
long double
|
- – -
|
- – -
|
- – -
|
ที่มา : เจนวิทย์ เหลืองอร่าม และปิยวิทย์ เหลืองอร่าม, 2543 : 72.
ในตารางที่ 2.9 แถวที่ 1 จะเห็นว่า x เป็นตัวแปรชนิดข้อมูลแบบ int และ y เป็นตัวแปรข้อมูลแบบ long เมื่อนำ x และ y มา บวก ลบ คูณ และหารกัน ผลลัพธ์ที่ได้จะเป็นชนิดข้อมูลแบบ long (เพราะ long มีพิสัยในการเก็บข้อมูลกว้างกว่า int) เช่น
int x = 7;
float y = 2;
- ถ้า x/2 จะได้ผลลัพธ์เป็น 3 (ชนิดข้อมูลแบบ int)
- ถ้า x/y จะได้ผลลัพธ์เป็น 3.500000 (ชนิดข้อมูลแบบ float)
ข้อสังเกต ภาษา C เป็นภาษาที่ดีมาก ที่อำนวยความสะดวกในการแปลงชนิดข้อมูลของตัวแปรให้ใหญ่ขึ้น ทำให้ไม่มีปัญหาในการเก็บข้อมูลและเราไม่ต้องกังวลผลที่ได้จากการดำเนินการ ของตัวแปรในนิพจน์ต่าง ๆ นอกจากนี้ภาษา C ยังอนุญาตให้เราแปลงชนิดข้อมูลได้ชั่วคราวด้วยตัวผู้เขียนโปรแกรมเอง โดยให้ศึกษาโปรแกรมตัวอย่างที่ 2.4 และโปรแกรมตัวอย่างที่ 2.5 โดยโปรแกรมตัวอย่างที่ 2.4 แสดงการคำนวณค่าจ้างที่ผิด ส่วนโปรแกรมตัวอย่างที่ 2.5 แสดงการคำนวณค่าจ้างที่ถูกโดยการเปลี่ยนแปลงชนิดข้อมูลชั่วคราว
/* errcal.c */
/* This program calculate emloyees share */
#include<stdio.h>
#include<conio.h>
void main(void)
{
int profits, employees; /* บรรทัดที่ 1 */
clrscr(); /* บรรทัดที่ 2 */
profits = 9; /* บรรทัดที่ 3 */
employees = 2; /* บรรทัดที่ 4 */
printf("Each employee gets %d\n",profits/employees); /* บรรทัดที่ 5 */
getch();
}
|
โปรแกรมตัวอย่างที่ 2.4 แสดงโปรแกรมการคำนวณค่าจ้างที่ผิด
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 2.4 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
บรรทัดที่ 1 เป็น การประกาศตัวแปร profits และ employees ให้เป็นชนิด int
บรรทัดที่ 2 เป็น คำสั่งให้ลบจอภาพ
บรรทัดที่ 3 และ 4 กำหนด ค่าให้กับตัวแปร โดย profits มีค่า 9 และ employees มีค่า 2
บรรทัดที่ 5 ให้ พิมพ์ข้อความ Each employee gets 4 ออกแสดงที่จอภาพ โดยตัวเลข 4 ได้จากการ คำนวณ 9/2 คือค่าของตัวแปร porfits/ employees
จากโปรแกรมตัวอย่างที่ 2.4 เราคงเห็นแล้วว่าผลหารที่ได้จะเป็นจำนวนเต็ม ส่วนที่เป็นเลขทศนิยมจะตัดทิ้งไป เมื่อภาษา C ทำงานกับข้อมูลชนิดจำนวนเต็ม เพื่อแก้ปัญหาที่เกิดการผิดพลาด ในกรณีนี้เราสามารถเปลี่ยนชนิดข้อมูลได้ชั่วคราว คือ เปลี่ยนตัว แปร profits จากชนิดข้อมูลแบบ int ไปเป็น float ชั่วคราว ดังตัวอย่างโปรแกรมที่ 2.5 ต่อไปนี้
โปรแกรมตัวอย่างที่ 2.5 แสดงโปรแกรมการเปลี่ยนแปลงชนิดข้อมูลชั่วคราว
/* change.c */
/* This program calculates employee share. */
#include<stdio.h>
#include<conio.h>
void main(void)
{
int profits, employees;
clrscr();
profits = 9;
employees = 2 ;
printf("Each employee gets %f", (float) profits/employees); /* บรรทัดที่ 1 */
getch();
}
|
ผลลัพธ์ที่ได้จากโปรแกรม
คำอธิบายโปรแกรม
โปรแกรมข้างต้นจะเหมือนกับโปรแกรมที่ 2.4 ทุกประการยกเว้น บรรทัดที่ 1 ในการคำนวณ (float) profits / employees เป็นการเปลี่ยนตัวแปร profits จากชนิดข้อมูล int ให้เป็น float ชั่วคราว ดังนั้นผลลัพธ์ที่ได้จากโปรแกรมจึงเป็น 4.500000 และใช้ %f ในการควบคุมการแสดงผล
จากโปรแกรมตัวอย่างที่ 2.5 ข้างต้นได้ใช้ฟังก์ชัน printf( ) เพื่อแสดงให้อยู่ในรูปแบบที่ต้องการ โดยใช้รหัสรูปแบบ %f (format code) %f เป็นรหัสรูปแบบการพิมพ์ข้อมูลชนิด float (ซึ่งรายละเอียดกล่าวไว้ในบทที่ 3 ตารางที่ 3.2) ได้สรุปรหัสรูปแบบการพิมพ์ข้อมูลทั้งหมดที่ใช้กับฟังก์ชัน printf( ) ผู้เขียนโปรแกรมควรจำให้ได้ทั้งหมด เพื่อความสะดวกและรวดเร็วในการใช้เขียนโปรแกรมในโอกาสต่อไป
10.สรุปท้ายบท
ภาษา C เป็นภาษาที่มีมาตรฐานในการเขียนโปรแกรมที่ชื่อว่า ANSI (American National Standards Institute) และภาษา C เป็นภาษาที่มีใช้มาเป็นเวลานาน โดยมีโครงสร้างอย่างง่ายพอสรุปได้ดังนี้
1. มีฟังก์ชันชื่อว่า main( ) อย่างน้อยหนึ่งฟังก์ชัน จึงจะสามารถทำการ execute program ได้
2. ขอบเขตฟังก์ชัน main (delimiters) ในโปรแกรมภาษา C ใช้เครื่องหมาย { แทนการเริ่มต้นฟังก์ชัน และใช้เครื่องหมาย } แทนการสิ้นสุดฟังก์ชัน ดังนั้นเมื่อเขียนฟังก์ชัน main( ) ทุกครั้งจะต้องมีเครื่องหมาย { และ } อยู่ด้วยเสมอ
3. การปิดท้ายคำสั่งในภาษา C จะต้องใช้เครื่องหมาย ; (semicolon) เป็นการบ่งชี้ให้ C compiler ทราบว่าจบคำสั่ง (statement) แต่ละคำสั่งแล้ว
4. ชื่อฟังก์ชันและคำสั่งในภาษา C จะต้องเขียนด้วยตัวอักษรตัวเล็ก (lowercase letter) ทั้งหมดทั้งนี้เพราะ C compiler จะคิดว่าตัวอักษรตัวใหญ่ (uppercase letter) กับตัวอักษรตัวเล็ก แตกต่างกัน เช่น main( ) ไม่เหมือนกับ Main( ) หรือ MAIN( ) เป็นต้น
5. ชื่อตัวแปร (variable name) สามารถตั้งชื่อโดยใช้ ตัวอักษรตัวเล็กหรือตัวอักษรตัวใหญ่ก็ได ้หรือใช้ตัวอักษรตัวเล็ก กับตัวอักษรตัวใหญ่ผสมกันก็ได้
สำหรับขั้นตอนการพัฒนาโปรแกรมภาษา C มีขั้นตอนสรุปได้ดังนี้คือ
1. ขั้นตอนเขียนโปรแกรมต้นฉบับ (source program) แล้วบันทึกโปรแกรมพร้อมกับตั้งชื่อแฟ้มไว้ แฟ้มที่ได้จะมีนามสกุล *.c หรือ *.cpp
2. ขั้นตอนแปลโปรแกรมภาษา C ไปเป็นโปรแกรมภาษาเครื่อง (object program) ใช้คำสั่ง compile เพื่อแปลโปรแกรมภาษา C ไปเป็นโปรแกรมภาษาเครื่อง แฟ้มที่ได้จะมีนามสกุล *.obj ซึ่งในขั้นตอนนี้โปรแกรมต้นฉบับอาจเกิดความผิดพลาดทางไวยกรณ์ภาษา (syntax error) ขึ้นได้ จึงต้องย้อนกลับไปแก้ไขโปรแกรมต้นฉบับในข้อ 1. ให้ถูกต้องเสียก่อน
3. ขั้นตอนเชื่อมโยง (link) โปรแกรมภาษาเครื่องเข้ากับ library function ของภาษา C จะได้เป็น execute program โดยใช้คำสั่ง link แฟ้มที่ได้จะมีนามสกุล *.exe
4. ขั้นตอนสั่งให้ execute program แสดงผลลัพธ์ออกมา โดยใช้คำสั่ง run
สำหรับข้อมูลของภาษา C มีดังนี้คือ
ตัวอักขระ ค่าคงที่ และตัวแปร ซึ่งในภาษา C ยังมีตัวดำเนินการหรือเครื่องหมาย เพื่อไว้ใช้ในการเขียนโปรกรม ดังนี้ ตัวดำเนินการคณิตศาสตร์ ตัวดำเนินการความสัมพันธ์ ตัวดำเนินการเชิงตรรกะ ตัวดำเนินการเพิ่มค่าและลดค่า ตัวดำเนินการบิตไวส์ ตัวดำเนินการกำหนดค่า และตัวดำเนินการแบบเงื่อนไข ซึ่งลำดับการทำงานของตัวดำเนินการ มีความสำคัญในการเขียนโปรแกรม
เนื้อหาสุดท้ายในบทนี้จะกล่าวถึงการแปลงชนิดข้อมูลภาษา C ซึ่งเป็นกฏเกณฑ์ในการแปลงชนิดข้อมูล ในกรณีข้อมูลต่างชนิดกันคือ ถ้าค่าตัวแปร หรือค่าคงที่ต่างชนิดกัน ให้ทำการเปลี่ยนชนิดของข้อมูลที่มีขนาดเล็กให้เป็นชนิดของข้อมูลที่ใหญ่
