แนะนำภาษาซี

หน่วยที่ 1 แนะนำภาษา C

1. ความเป็นมาของภาษาซี

ภาษาซีเป็นภาษาที่ถือว่าเป็นทั้งภาษาระดับสูงและระดับต่ำถูกพัฒนาโดยเดนนิส ริดชี (Dennis Ritche) แห่งห้องทดลองเบลล์ (Bell Laboratories) ที่เมอร์รีฮิล มลรัฐนิวเจอร์ซี่โดยเดนนิสได้ใช้หลักการของภาษา บีซีพีแอล (BCPL : Basic Combine Programming Language)  ซึ่งพัฒนาขึ้นโดยเคน ทอมสัน (Ken Tomson) การออกแบบและพัฒนาภาษาซีของเดนนิส ริดชีมีจุดมุ่งหมายให้เป็นภาษาสำหรับใช้เขียนโปรแกรมปฏิบัติการระบบยูนิกซ์และได้ตั้งชื่อว่า ซี (C) เพราะเห็นว่า ซี (C) เป็นตัวอักษรต่อจากบี (B) ของภาษา BCPL ภาษาซีถือว่าเป็นภาษาระดับสูงและภาษาระดับต่ำ ทั้งนี้เพราะภาษาซีมีวิธีใช้ข้อมูลและมีโครงสร้างการควบคุมการทำงานของโปรแกรมเป็นอย่างเดียวกับภาษาของโปรแกรมระดับสูงอื่นๆ จึงถือว่าเป็นภาษาระดับสูง  ในด้านที่ถือว่าภาษาซีเป็นภาษาระดับต่ำเพราะภาษาซีมีวิธีการเข้าถึงในระดับต่ำที่สุดของฮาร์ดแวร์ความสามารถทั้งสองด้านของภาษานี้เป็นสิ่งที่เกื้อหนุนซึ่งกันและกัน  ความสามารถระดับต่ำทำให้ภาษาซีสามารถใช้เฉพาะเครื่องได้และความสามารถระดับสูง ทำให้ภาษาซีเป็นอิสระจากฮาร์ดแวร์ภาษาซีสามารถสร้างรหัสภาษาเครื่องซึ่งตรงกับชนิดของข้อมูลนั้นได้เองทำให้โปรแกรมที่เขียนด้วยภาษาซีที่เขียนบนเครื่องหนึ่งสามารถนำไปใช้กับอีกเครื่องหนึ่งได้ ประกอบกับการใช้พอยน์เตอร์ในภาษาซีนับได้ว่าเป็นตัวอย่างที่ดีของการเป็นอิสระจากฮาร์ดแวร์

2. วิวัฒนาการของภาษาซี

– ค.ศ. 1970 มีการพัฒนาภาษา B โดย Ken Thompson ซึ่งทำงานบนเครื่อง DEC PDP-7 ซึ่ง ทำงานบนเครื่องไมโครคอมพิวเตอร์ไม่ได้และยังมีข้อจำกัดในการใช้งานอยู่ (ภาษา B สืบทอดมาจาก ภาษา BCPL ซึ่งเขียนโดย Marth Richards)

– ค.ศ. 1972 Dennis M. Ritchie และ Ken Thompson ได้สร้างภาษา C เพื่อเพิ่มประสิทธิภาพ ภาษา B ให้ดียิ่งขึ้น ในระยะแรกภาษา C ไม่เป็นที่นิยมแก่นักโปรแกรมเมอร์โดยทั่วไปนัก

– ค.ศ. 1978 Brian W. Kernighan และ Dennis M. Ritchie ได้เขียนหนังสือเล่มหนึ่งชื่อว่า The C Programming Language และหนังสือเล่มนี้ทำให้บุคคลทั่วไปรู้จักและนิยมใช้ภาษา C ในการเขียนโปรแกรมมากขึ้น

– แต่เดิมภาษา C ใช้ Run บนเครื่องคอมพิวเตอร์ 8 bit ภายใต้ระบบปฏิบัติการ CP/M ของ IBM PC ซึ่งในช่วงปี ค. ศ. 1981 เป็นช่วงของการพัฒนาเครื่องไมโครคอมพิวเตอร์ ภาษา C จึงมีบทบาทสำคัญในการนำมาใช้บนเครื่อง PC ตั้งแต่นั้นเป็นต้นมาและมีการพัฒนาต่อมาอีกหลาย ๆ ค่าย ดังนั้นเพื่อกำหนดทิศทางการใช้ภาษา C ให้เป็นไปแนวทางเดียวกัน ANSI (American National Standard Institute) ได้กำหนดข้อตกลงที่เรียกว่า 3J11 เพื่อสร้างภาษา C มาตรฐานขึ้นมา เรียกว่า ANSI C

– ค.ศ. 1983 BjarneStroustrupแห่งห้องปฏิบัติการเบล (Bell Laboratories) ได้พัฒนาภาษา C++ ขึ้นรายละเอียดและความสามารถของ C++ มีส่วนขยายเพิ่มจาก C ที่สำคัญ ๆ ได้แก่แนวความคิดของการเขียนโปรแกรมแบบกำหนดวัตถุเป้าหมายหรือแบบ OOP (Object Oriented Programming) ซึ่งเป็นแนวการเขียนโปรแกรมที่เหมาะกับการพัฒนาโปรแกรมขนาดใหญ่ที่มีความสลับซับซ้อนมาก มีข้อมูลที่ใช้ในโปรแกรมจำนวนมากจึงนิยมใช้เทคนิคของการเขียนโปรแกรมแบบ OOP ในการพัฒนาโปรแกรมขนาดใหญ่ในปัจจุบันนี้

3. Editor สำหรับเขียนโปรแกรม

Code Blocks เป็น Editor ที่ใช้ในการเขียนโปรแกรมด้วยภาษา C สามารถใช้แทน Microsoft Visual C++

ได้ ตัวโปรแกรมมีขนาดเล็กใช้ง่ายและไม่เปลืองแรม นักเรียนสามารถโหลดโปรแกรม Code::Blocks ได้ที่ http://www.codeblocks.org/downloads/26 โดยให้เลือกดาวน์โหลดโปรแกรมสำหรับ Windows แล้วก็เลือกดาวน์โหลดตัวที่มีชื่อว่า codeblocks-10.05mingw-setup.exe ไฟล์มีขนาดใหญ่พอสมควร

                   3.1 การติดตั้ง Code Blocks

– ดับเบิลคลิกที่ไฟล์ codeblocks-10.05mingw-setup.exe

– รอสักครู่ จะปรากฏหน้าจอ Welcome ให้กด Next >

รูปที่ 1-1 หน้าจอ Welcome

                   – หน้าจอ License Agreement แสดงเงื่อนไขการใช้โปรแกรม ให้กด I Agree เพื่อยอมรับ

รูปที่ 1-2 หน้าจอ License Agreement

                   – หน้าจอ Choose Componentsสอบถามว่าจะลงอะไรบ้างไม่ต้องเลือกอะไร กด Next >ได้เลย

รูปที่ 1-3 หน้าจอ Choose Components

                   – เลือกตำแหน่งที่จะติดตั้ง แล้วกด Install

รูปที่ 1-4 หน้าจอ Choose Install Location

                   – รอติดตั้งสักครู่ ไม่นานเท่าไหร่

รูปที่ 1-5 หน้าจอ Installing

                   – เมื่อลงเรียบร้อยแล้ว มันจะถามว่าจะเปิดโปรแกรม Code::Blocks มั้ย กด Yes

รูปที่ 1-6 หน้าจอแสดงคำถามเพื่อเปิดใช้งานโปรแกรม

                   – ขึ้นคำถามว่าจะให้โปรแกรมมันเป็น default มั้ยเลือกอันที่สามตามที่มันให้มาเลย

รูปที่ 1-7 หน้าจอ File associations

                   – จะได้ออกมาเป็นโปรแกรมหน้าตาตามภาพ

รูปที่ 1-8 หน้าจอโปรแกรม Code Blocks

หลักการเขียนโปรแกรม

หน่วยที่ 2 หลักการเขียนโปรแกรมด้วยภาษาคอมพิวเตอร์

ในการเขียนโปรแกรมคอมพิวเตอร์นักเขียนโปรแกรมจะต้องเข้าใจหลักเกณฑ์ของภาษาโปรแกรมและระบบการทำงานของคอมพิวเตอร์ ว่ามีโครงสร้างและวิธีการใช้คำสั่งอย่างไรซึ่งในการเขียนโปรแกรมคอมพิวเตอร์ มีหลักเกณฑ์การเขียนโปรแกรม ประกอบด้วย 5 ขั้นตอนดังนี้คือ

1. ทำความเข้าใจและวิเคราะห์ปัญหา

2. กำหนดแผนในการแก้ปัญหา

3. เขียนโปรแกรมตามแผนที่กำหนด

4. ทดสอบและตรวจสอบความถูกต้องของโปรแกรม

5. จัดทำคู่มือและเอกสารการใช้โปรแกรม

1. ทำความเข้าใจและวิเคราะห์ปัญหา

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

2. กำหนดแผนในการแก้ปัญหา 

หลังจากทำความเข้าใจและวิเคราะห์ปัญหาโจทย์จนได้ข้อสรปุว่าโจทย์ต้องการอะไรแล้ว ผู้เขียนโปรแกรมก็จะทำการกำหนดแผนในการแก้ไขปัญหาโดยการเขียนผังงาน (Flowchart) ซึ่งการเขียนผังงานคือการเขียนแผนภาพที่เป็นลำดับเพื่อแสดงขั้นตอนการทำงานของโปรแกรมเพื่อให้ง่ายต่อการทำความเข้าใจการเขียนผังงานมี 3 แบบคือ แบบเรียงลำดับ(Sequential) แบบมีการกำหนดเงื่อนไข(Condition) และแบบมีการทำงานวนรอบ(Looping) ซึ่งสัญลักษณ์ของผังงาน(Flowchart Symbol) มีดังนี้คือ

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

รูป 2-1 แสดงสัญลักษณ์ที่ใช้ในการเขียนผังงาน

                   2.1    การเขียนผังงานแบบเรียงลำดับ

อธิบายผังงาน1. Start เริ่มต้นการทำงาน 2. รับค่า x และ y ทางแป้นพิมพ์ 3. z=x+yเมื่อ x+yได้ค่าเท่าไรให้นำไปเก็บไว้ยังตัวแปร z 4. แสดงค่าที่เก็บไว้ในตัวแปร z 5. Stop จบการทำงาน

รูป 2-2  แสดงผังงานการบวกเลข 2 จำนวน

                   2.2 การเขียนผังงานแบบมีการกำหนดเงื่อนไข

อธิบายผังงาน1. Start เริ่มต้นการทำงาน 2. รับค่า x และ y ทางแป้นพิมพ์ 3. z=x+yเมื่อ x+yได้ค่าเท่าไรให้นำไปเก็บไว้ยังตัวแปร z 4. ตรวจสอบเงื่อนไขว่า ถ้าผลลัพธ์มากกว่า 20 ให้ไปทำข้อ 5 แต่ถ้าน้อยกว่าหรือเท่ากับ 20 ให้ไปทำข้อ 6 5. แสดงค่าที่เก็บไว้ในตัวแปร y 6. แสดงค่าที่เก็บไว้ในตัวแปร x 7. Stop จบการทำงาน

รูป 2-3 แสดงผังงานการบวกเลข 2 จำนวน แบบมีเงื่อนไข

3. เขียนโปรแกรมตามแผนที่กำหนด

เมื่อผู้เขียนโปรแกรมเขียนผังงานเสร็จเรียบร้อยแล้วขั้นตอนต่อไปคือการเขียนโปรแกรมตามผังงาน ที่ได้กำหนดเอาไว้ ในกรณีที่เขียนด้วยภาษาซีการเขียนโปรแกรมก็ต้องเป็นไปตามกฎเกณฑ์และโครงสร้างของภาษาซีเท่านั้น

4. ทดสอบและตรวจสอบความถูกต้อง 

หลังจากขียนโปรแกรมเสร็จแล้วให้ทดลองคอมไพล์โปรแกรมว่ามีจุดผิดพลาดที่ใดบ้าง ในภาษาซีการคอมไพล์ โปรแกรมจะใช้วิธีการกดปุ่ม Alt + F9 ในกรณีที่มีข้อผิดพลาดจะแสดงในช่องด้านล่างของหน้าจอเอดิเตอร์ ในส่วนของกรอบ message ให้อ่านทำความเข้าใจ และแก้ไขตามที่โปรแกรมแจ้งข้อมูลผิดพลาดเมื่อเสร็จแล้วให้ทดลองรันโปรแกรม

5. จัดทำคู่มือและเอกสารการใช้โปรแกรม

ถ้าหากรันโปรแกรมแล้วใช้งานได้แสดงว่าจะได้ไฟล์ที่มีส่วนขยายเป็น EXE เพื่อนำไปทดสอบ้งานในที่ต่างๆและถ้านำไปใช้งานแล้วมีปัญหาก็ให้ทำการแก้ไขโปรแกรมอีกครั้งแต่ถ้ารันโปรแกรมแล้วไม่มีปัญหาใดๆ แสดงว่าโปรแกรมนี้ใช้งานได้อย่างสมบูรณ์จากนั้นผู้เขียนโปรแกรมก็ต้องจัดทำคู่มือประกอบการใช้งานและนำไปเผยแพร่ต่อไป

เริ่มต้นกับภาษาซี

เริ่มต้นกับภาษาซี

ภาษา ซีเป็นภาษาคอมพิวเตอร์ระดับสูง ที่ใช้สำหรับเขียนโปรแกรมประยุกต์ต่างๆ เช่นเดียวกับ ภาษาปาสคาล ภาษาเบสิก และภาษาฟอร์แทรน เป็นต้น นอกจากนี้ภาษาซียังใช้สำหรับเขียนดปรแกรมระบบ และโปรแกรมสำหรับควบคุมฮาร์ดแวร์บางส่วนที่ภาษาโปรแกรมระดับสูงหลายภาษาไม่ สามารถทำได้ ภาษาซีจึงจัดเป็นภาษาระดับกลางด้วย

ก่อนที่โปรแกรมภาษาซีจะถูกรัน(run) จะต้องถูกแปลงให้อยู่ในรูปของอ็อบเจกต์โค้ด(object code) โดยการคอมไพล์ (compile) โปรแกรมภาษาซีที่เขียนโดยใช้คำสั่งตามมาตรฐานของ ANSI C สามารถนำไปคอมไพล์ และรันที่เครื่องคอมพิวเตอร์ต่างระบบกันได้

1.1   การคอมไพล์และรันโปรแกรม

โปรแกรมที่เขียนขึ้นโดยใช้ภาษาโปรแกรมต่างๆ นั้น เราเรียกว่า รหัสต้นฉบับ (source code) ซึ่ง อยู่ในรูปของข้อความตามหลักการเขียนโปรแกรมของภาษาโปรแกรมที่สามารถอ่าน และทำความเข้าใจได้โดยมนุษย์เท่านั้น ดังนั้นเพื่อให้เครื่องคอมพิวเตอร์สามารถเข้าใจโปรแกรมและปฏิบัติได้ จึงต้องนำรหัสต้นฉบับมาผ่านกระบวนการแปลงให้อยู่ในรูปของอ็อบเจกต์โค้ดที่ ประกอบด้วยรหัสตัวเลข 0 และ 1 เราเรียกกระบวนการแปลงดังกล่าวว่า การคอมไพล์โปรแกรม

1.2   โครงสร้างพื้นฐานของโปรแกรมภาษาซี

โครงสร้างพื้นฐานของโปรแกรมภาษาซีจะต้องประกอบด้วยโปรแกรมย่อย หรือเรียกว่า ฟังก์ชัน (function) อย่างน้อย 1 ฟังก์ชัน คือ ฟังก์ชัน main() ซึ่งมีรูปแบบดังนี้

void main() {                                                     // ส่วนหัวของฟังก์ชันการประกาศตัวแปรท้องถิ่น;                             // ส่วนการประกาศตัวแปรคำสั่งต่างๆ;                                                 // ส่วนคำสั่ง }

รูปที่ 1.1 แสดงโครงสร้างพื้นฐานของโปรแกรม

          ฟังก์ชัน main() ประกอบด้วย 3 ส่วนหลัก คือ

1) ส่วนหัวของฟังก์ชัน ประกอบด้วย ชนิดข้อมูล void ชื่อฟังก์ชัน main ตามด้วยเครื่องหมาย ( และ ) ตามลำดับ

2) ส่วนการประกาศตัวแปร ใช้สำหรับประกาศตัวแปรชนิดต่างๆ เพื่อเก็บข้อมูลระหว่างการประมวลผล

3) ส่วนคำสั่ง ประกอบด้วยคำสั่งที่เกี่ยวข้องกับการรับเข้าและการแสดงผลข้อมูล และคำสั่งประมวลผลอื่นๆ

ส่วนประกาศตัวแปรและส่วนคำสั่งจะต้องเขียนอยู่ระหว่างเครื่องหมาย { และ } เสมอ ทั้งสองส่วนนี้ใช้สำหรับนิยามการทำงานของฟังก์ชัน main() หรือในที่นี้เป็นการนิยามการทำงานของโปรแกรมนั่นเอง และคำสั่งทุกคำสั่งในภาษาซีจะต้องเปิดท้ายด้วยเครื่องหมาย ; เสมอ

1.3   โปรแกรมภาษาซีอย่างง่าย

โปรแกรมในตัวอย่างที่ 1.1 เป็นโปรแกรมภาษาซีที่สั้นที่สุด ที่สามารถคอมไพล์ และรับได้โดยคอมไพเลอร์ตามมาตรฐานของ ANSI C

ตัวอย่างที่ 1.1 โปรแกรมภาษาซีที่สั้นที่สุด

// Program: First.c// แสดงการใช้ฟังก์ชัน main() ในโปรแกรมvoid main() { }

ในตัวอย่างนี้จะเห็นได้ว่า โปรแกรมภาษาซีมีชื่อว่า First และมีส่วนขยายเป็น .c นอกจากนี้ภายในฟังก์ชัน main() ได้ละทั้งส่วนการประกาศตัวแปรและส่วนคำสั่ง หรือกล่าวได้ว่าฟังก์ชัน main() ของโปรแกรม First.c เป็นฟังก์ชันว่าง เมื่อรันโปรแกรมจึงไม่ปรากฏผลใดๆ

อย่างไรก็ตามแม้ว่าภายในฟังก์ชันได้ละส่วนการประกาศตัวแปร และส่วนคำสั่ง แต่ยังต้องมีเครื่องหมาย { และ } เพื่อบอกขอบเขตของฟังก์ชัน main()

1.4   การแสดงผลลัพธ์เบื้องต้น

ตัวอย่างที่ 1.2 โปรแกรมพิมพ์ข้อความออกทางจอภาพ

/* 1 */ // Program: Output1.c/* 2 *//* 3 */  #include <stdio.h> /* 4 */ /* 5 */ void main() { /* 6 */   printf(“The first output form C.\n”); /* 7 */}

ผลลัพธ์ คือ

The first output form C.

ชุด อักขระ /* ซึ่งใช้คู่กับ */ ที่ปรากฏในโปรแกรม ใช้บอกจุดเริ่มต้น และจุดสิ้นสุดของการเขียนคำอธิบายกำกับส่วนต่างๆ ของโปรแกรม ข้อความที่เขียนอยู่ระหว่างชุดอักขระดังกล่าวสามารถมีความยาวต่อเนื่องกัน ได้หลายบรรทัด และเป็นส่วนที่ไม่ถูกประมวลผล

บรรทัด ที่ 1 และ 2 ใช้ชุดอักขระ // ด้านหน้าคำอธิบายกำกับส่วนต่างๆ ของโปรแกรมที่สิ้นสุดภายในบรรทัด ในที่นี้ใช้แสดงชื่อโปรแกรม และคำอธิบายการทำงานของโปรแกรม

บรรทัดที่ 3 และ 5 เป็นบรรทัดว่าง นักเขียนโปรแกรมสามารถใช้บรรทัดว่าง เพื่อเว้นช่วงระหว่างบรรทัด หรือใช้อักขระต่างๆ เช่น ช่องว่าง(blank) หรือแท็บ(tab) เพื่อสร้างระยะเยื้องในการจัดรูปแบบของโปรแกรมให้ง่ายต่อการอ่าน และมีรูปแบบเป็นของตนเอง

บรรทัดที่ 4 เป็นการใช้คำสั่งของตัวประมวลผลก่อนซีที่มีชื่อว่า include ซึ่งขึ้นต้นด้วยอักขระ # ในที่นี้คำสั่ง #include จะมีผลทำให้แฟ้มชื่อ stdio.h ถูกอ่านเข้ามาเพื่อประมวลผลร่วมกับโปรแกรม Outpuc1.c

บรรทัดที่ 7 เรียกใช้คำสั่ง printf() ซึ่งเป็นเพียงคำสั่งเดียวของโปรแกรม Output1.c การทำงานของคำสั่ง printf() อาร์กิวเมนต์ของคำสั่ง printf() ซึ่งเขียนอยู่ระหว่างเครื่องหมาย ( และ ) ได้แก่ข้อความที่เขียนอยู่ระหว่างเครื่องหมาย “ และ ” ซึ่งเรียกว่าสายอักขระ(string) ในที่นี้สายอักขระ “The first output from C.\n” เป็นอาร์กิวเมนต์ค่าเดียวของคำสั่ง printf() จะมีผลทำให้คำสั่ง printf() แสดงข้อความของสายอักขระออกทางจอภาพ

จะเห็นได้ว่าชุดอักขระ \n ที่ปรากฏเป็นส่วนหนึ่งของสายอักขระในบรรทัดที่ 7 ไม่ได้ถูกแสดงผลออกทางจอภาพ เหตุที่เป็นเช่นนั้นเนื่องจากว่าอักขระ \ ซึ่งเรียกว่า อักขระหลีก (escape character) มีผลทำให้อักขระ 1 ตัวที่ตามมา ในที่นี้คืออักขระ n มีความหมายเปลี่ยนไปจากความหมายปกติ สำหรับชุดอักขระ \n คอมไพลเลอร์ภาษาซีได้กำหนดให้มีความหมายเป็น ขึ้นบรรทัดใหม่ และนอกจาก \n แล้วยังมีชุดอักขระของอักขระหลีกอื่นที่มีความหมายที่แตกต่างกันออกไป เช่น

          \t       หมายถึง   อักขระ แท็บ

หมายถึง   อักขระ NULL

\’       หมายถึง   อักขระ ‘

\”       หมายถึง   อักขระ ”

\\       หมายถึง   อักขระ \

ตัวอย่างที่ 1.3 โปรแกรมพิมพ์หัวรายงาน

/* 1 */ // Program: Output2.c/* 2 */ // พิมพ์หัวรายงาน/* 3 */ /* 4 */ #include <stdio.h> /* 5 */ /* 6 */ void main() { /* 7 */      printf(“\n—< Paroll Report >—”); /* 8 */      printf(“\n               24/05/2555\n”); /* 9 */}

ผลลัพธ์ คือ

—< Paroll Report >—24/05/2555

ตัวอย่างที่ 1.4 โปรแกรมพิมพ์จำนวนเต็ม

/* 1 */ // Program: Output3.c/* 2 */ // พิมพ์จำนวนเต็ม/* 3 */ /* 4 */ #include <stdio.h> /* 5 */ /* 6 */ void main() { /* 7 */     printf(“\nFirst value is %d. ”,5); /* 8 */     printf(“\nSecond value is %d. ”,7); /* 9 */ }

ผลลัพธ์ คือ

First value is 5.Second value is 7.

ตัวอย่างที่ 1.5 โปรแกรมพิมพ์จำนวนเต็มหลายค่าในบรรทัดเดียว

/* 1 */ //Program: Output4.c/* 2 */ // พิมพ์จำนวนเต็มหลายค่าในบรรทัดเดียว/* 3 */ /* 4 */ #include <stdio.h> /* 5 */ /* 6 */ void main() { /* 7 */       printf(“\nSum of %d and %d is %d. ”, 9, 4, 9+4); /* 8 */       printf(“\nDifference of %d and %d is %d. ”, 9, 4, 9-4); /* 9 */       printf(“\Multiplication of  %d and %d is %d. ”, 9, 4, 9*4); /* 10 */     printf(“\nDivision of %d and %d is %d. \n”, 9, 4, 9/4); /* 11 */}

ผลลัพธ์ คือ

Sum of 9 and 4 is 13.Difference of 9 and 4 is 5.Multiplication of 9 and 4 is 36. Division of 9 and 4 is 2.

ข้อมูลพื้นฐานและตัวดำเนินการ

2. ข้อมูลพื้นฐานและตัวดำเนินการ

องค์ประกอบพื้นฐานในการเขียนโปรแกรมภาษาซี ได้แก่ คำสงวน การตั้งชื่อ ตัวแปร ชนิดของข้อมูล ค่าคงตัว ค่าคงที่

1. คำสงวน

คำสงวน หมายถึง คำที่สงวนไว้สำหรับเรียกใช้ตามวัตถุประสงค์ที่กำหนดดดยเฉพาะ เช่น คำที่ใช้ในคำสั่งควบคุม และชนิดของข้อมูล เป็นต้น คำสงวนของภาษาซีมีดังนี้

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

2. การตั้งชื่อ

นักเขียนโปรแกรมจะต้องตั้งชื่อให้กับตัวแปร ค่าคงที่ โปรแกรมย่อย พารามิเตอร์ และส่วนต่างๆ ของโปรแกรม กฎเกณฑ์ที่ใช้ในการตั้งชื่อของภาษาซีมีดังนี้

1. ชื่อจะประกอบขึ้นจากตัวอักษร ตัวเลข และเครื่องหมายขีดเส้นใต้(underscore) เท่านั้น
2. อักขระแรกของชื่อจะต้องเป็นตัวอักษร หรือเครื่องหมายขีดเส้นใต้เท่านั้น
3. ตัวพิมพ์ใหญ่ และตัวพิมพ์เล็กถือเป็นตัวอักษรคนละตัวกัน เช่น Salary และ SALARY เป็นชื่อที่แตกต่างกัน เป็นต้น
4. ชื่อมาตรฐาน ANSI C จะมีความยาวไม่จำกัด แต่คอมไพเลอร์ตามมาตรฐาน ANSI C จะต้องสามารถจำแนกชื่อที่แตกต่างกันได้อย่างมาก 31 อักขระแรก
5. ชื่อจะต้องไม่ซ้ำกับคำสงวน

3. ตัวแปร

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

การตั้งชื่อให้กับตัวแปรจะเป็นไปตามหลักการตั้งชื่อของภาษาซี และชื่อที่เหมาะสมควรจะเป็นชื่อที่สื่อความหมาย

การประกาศตัวแปรมีรูปแบบ ดังนี้

ชนิดข้อมูล ตัวแปร1, ตัวแปร2, …,ตัวแปรn;

เช่น int age; float salary, overtime; เป็นต้น

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

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

1) ข้อมูลชนิดตัวเลข (arithmetic data type) ซึ่งประกอบด้วย ข้อมูลชนิดจำนวนเต็ม และข้อมูลชนิดจำนวนจริง
2) ข้อมูลชนิดตัวชี้ (pointer data type)
3) ข้อมูลชนิดแจงนับ (enumerated data type)

ในเอกสารนี้จะกล่าวถึงเฉพาะการใช้งานข้อมูลชนิดจำนวนเต็มและข้อมูลชนิดจำนวนจริงเท่านั้น

4.1 ข้อมูลชนิดจำนวนเต็ม

การประกาศข้อมูลชนิดจำนวนเต็มสามารถทำได้ ดังนี้

int age;

ซึ่งเป็นการกำหนดให้ตัวแปร age เป็นชนิด int หรือชนิดจำนวนเต็ม

เมื่อประกาศตัวแปรแล้วจะมีค่าอย่างใดอย่างหนึ่งได้ด้วยการใช้คำสั่งกำหนดค่าให้กับตัวแปร ซึ่งมีรูปแบบ ดังนี้

ตัวแปร = ค่าข้อมูล;

เช่น age = 15;

เครื่องหมาย = เป็นตัวดำเนินการกำหนดค่า และมีผลให้ตัวแปร age มีค่าข้อมูลเท่ากับ 15

ตัวอย่างที่ 4.1 โปรแกรมพิมพ์อายุ

/* 1 */ //Program: PrintArea.c/* 2 */ #include <stdio.h>/* 3 */ void main() { /* 4 */ int age; /* 5 */ age = 15; /* 6 */ printf(“The child age is %d.\n”, age); /* 7 */ }

ผลลัพธ์ คือ

The child age is 15.

บรรทัดที่ 4 ตัวแปร age ถูกประกาศให้มีชนิดจำนวนเต็ม และถูกกำหนดให้มีค่าเป็น 15 ในบรรทัดที่ 5
บรรทัดที่ 6 ค่าตัวแปร age ซึ่งเป็นอาร์กิวเมนต์ที่สองของคำสั่ง printf() จะถูกจัดรูปแบบให้อยู่ในรูปของจำนวนเต็มฐานสิบก่อนแสดงผล

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

ตัวอย่างที่ 4.2 โปรแกรมพิมพ์พิกัดของจุด

/* 1 */ //Program: Coord.c/* 2 */ #include <stdio.h>/* 3 */ void main() { /* 4 */ int x1, y1; /* 5 */ int x2 = 5, y2 = 0; /* 6 */ x1 = 2; /* 7 */ y1 = 3; /* 8 */ printf(“The first coordinate is (%d, %d).\n”,x1, y1); /* 9 */ printf(“The second coordinate is (%d, %d).\n”,x2, y2); /* 10 */ }

ผลลัพธ์ คือ

The first coordinate is (2, 3). The second coordinate is (5, 0).

บรรทัดที่ 4 เป็นการประกาศให้ x1 และ y1 เป็นตัวแปรชนิดจำนวนเต็มทั้งสองตัว และบรรทัดที่ 5 เป็นการประกาศให้ x2 และ y2 เป็นตัวแปรชนิดจำนวนเต็ม พร้อมกับกำหนดให่มีค่าเริ่มต้นเป็น 5 และ 0 ตามลำดับ

อาร์กิวเมนต์แรกของคำสั่ง printf() ในบรรทัดที่ 8 เป็นสายอักขระที่ประกอบด้วยชุดอักขระจัดรูปแบบ %d จำนวน 2 ชุด โดย %d แรกใช้จัดรูปแบบการแสดงผลค่าของตัวแปร x1 และ %d ที่สองใช้จัดรูปแบบการแสดงผลค่าของตัวแปร y1

นอกจากชุดอักขระจัดรูปแบบ %d แล้วยังมีชุดอักขระจัดรูปแบบสำหรับจำนวนเต็มในฐานอื่นอีก คือ %o และ %x ซึ่งเป็นชุดอักขระที่ใช้จัดรูปแบบข้อมูลให้อยู่ในรูปจำนวนเต็มฐานแปด (octal) และจำนวนเต็มฐานสิบหก (hexadecimal) ตามลำดับ ดังแสดงในตัวอย่างที่ 4.3

ตัวอย่างที่ 4.3 โปรแกรมพิมพ์ตัวเลขฐานต่างๆ

/* 1 */ //Program: PrnD-O-X.c/* 2 */ #include <stdio.h>/* 3 */ void main() { /* 4 */ int a = 78; /* 5 */ printf(“Value %d in decimal is %d.\n”,a, a); /* 6 */ printf(“Value %d in octal is %o.\n”,a, a); /* 7 */ printf(“Value %d in hexadecimal is ”,a); /* 8 */ printf(“%x or %X.\n”,a ,a); /* 9 */ }

ผลลัพธ์ คือ

Value 78 in decimal is 78.Value 78 in octal is 116. Value 78 in hexadecimal is 4e or 4E.

4.2 ข้อมูลชนิดจำนวนจริง

ชนิดข้อมูลจำนวนจริงในภาษาซีประกอบด้วย float double และ long double โดยชนิด float จะมีจำนวนตำแหน่งทศนิยมน้อยกว่าชนิด double และชนิด long double ตามลำดับ

ชุดอักขระจัดรูปแบบที่ใช้สำหรับข้อมูลชนิดจำนวนจริงในคำสั่ง printf() ประกอบด้วย %f ใช้เพื่อจัดรูปแบบข้อมูลชนิด float ให้อยู่ในรูปแบบจำนวนจริงฐานสิบ %e และ %E ใช้เพื่อจัดรูปแบบข้อมูลให้อยู่ในรูปของสัญลักษณ์เชิงวิทยาศาสตรสำหรับข้อมูลชนิด double และ long double จะใช้อักขระ lf และ Lf เป็นอักขระที่เพิ่มเข้าไปใช้ชุดอักขระจัดรูปแบบ ตามลำดับ

ตัวอย่างที่ 4.4 โปรแกรมพิมพ์คะแนน

/* 1 */ //Program: PrnScore.c/* 2 */ #include/* 3 */ void main() { /* 4 */ float score; /* 5 */ score = 300.545; /* 6 */ printf(“Score are %f, %e ”,score, score); /* 7 */ printf(“and %E. ”,score); /* 8 */}

ผลลัพธ์ คือ

Score are 300.545013, 3.005450e+02 and 3.005450E+02.

การแสดงผลข้อมูลชนิดจำนวนจริงในคำสั่ง printf() โดยใช้ %f %e หรือ %E จะแสดงค่าทศนิยม 6 ตำแหน่ง อย่างไรก็ตามในชุดอักขระจัดรูปแบบจำนวนจริง ยังสามารถกำหนดจำนวนตำแหน่งในการแสดงผลข้อมูลให้กับข้อมูลแต่ละจำนวน เพื่อจัดรูปแบบผลลัพธ์ให้สวยงาม ดังแสดงในตัวอย่างที่ 4.5

ตัวอย่างที่ 4.5 โปรแกรมพิมพ์อุณหภุมิรูปแบบต่างๆ

/* 1 */ //Program: PrnTemps.c /* 2 */ // พิมพ์อุณหภูมิรูปแบบต่างๆ/* 3 */ #include <stdio.h> /* 4 */ void main() { /* 5 */ float tempFri; /* 6 */ double tempSat; /* 7 */ tempFri = 12.345; /* 8 */ printf(“Friday temperature: %7.2f, ”, tempFri); /* 9 */ printf(%10.3e, %10.3E. \n”, tempFri, tempFri); /* 10 */ tempSat = 1.2465e-5; /* 11 */ printf(“Saturday temperature: %7.2lf, ”,tempSat); /* 12 */ printf(“%7.5le, %7.5lE.\n”, tempSat, tempSat); /* 13 */}

ผลลัพธ์ คือ

Friday temperature: 12.35, 1.235e+01, 1.235E+01. Saturday temperature: 0.000, 1.24650e-05, 1.25650E-05.

จากตัวอย่างที่ 5 ในบรรทัดที่ 8 %7.2f มีความหมายว่าจำนวนตำแหน่งที่ใช้แสดงข้อมูลชนิดจำนวนจริงจะมีค่าอย่างน้อยเท่ากับ 7 โดย 1 ตำแหน่งเป็นทศนิยม 2 ตำแหน่งเป็นค่าทศนิยม และ 4 ตำแหน่งที่เหลือเป็นจำนวนเต็มด้านหน้าจุดทศนิยม ดังรูป 4.1

1

2

.

3

5

รูป 4.1 แสดงผลการกำหนดจำนวนตำแหน่งข้อมูลด้วย %7.2f

5. ค่าคงตัวและค่าคงที่

ค่าคงตัว (literal constant) หมายถึง ข้อมูลที่ระบุเป็นค่าอย่างใดอย่างหนึ่งในโปรแกรม และมีชนิดของข้อมูลตามค่าของข้อมูลนั้น เช่น

8,236 เป็นค่าคงตัวชนิดจำนวนเต็ม
5.85 และ 100.00 เป็นค่าคงตัวชนิดจำนวนจริง
‘A’ และ ‘O.K.” เป็นค่าคงตัวชนิดอักขระและสายอักขระตามลำดับ

นอกจากการใช้ค่าคงตัวแล้ว นักเขียนโปรแกรมยังสามารถกำหนดชื่อเพื่อใช้แทนค่าคงตัวในโปรแกรม ซึ่งต่อไปนี้จะเรียกชื่อนี้ว่า ค่าคงที่ (constants) โดยการใช้คำสั่งของตัวประมวลผลก่อนซี #define ตามตัวอย่างที่ 4.6

ตัวอย่างที่ 4.6 โปรแกรมแปลงอุณหภูมิ

/* 1 */ //Program: Degree.c/* 2 */ #define FACTOR 5 / 9/* 3 */ #define FBASE 32 /* 4 */ #include <stdio.h> /* 5 */ void main() { /* 6 */ float degF, degC; /* 7 */ degF = 78.5; /* 8 */ degC = (degF – FBASE) * FACTOR; /* 9 */ printf(“%f in Fahrenheit ”, degF); /* 10 */ printf(“is %f in Celsius. \n”, degC); /* 11 */ degF = 100.00; /* 12 */ degC = (degF – FBASE) * FACTOR; /* 13 */ printf(“%f in Fahrenheit ”, degF); /* 14 */ printf(“is %f in Celsius. \n”, degC); /* 15 */}

ผลลัพธ์ คือ

78.500000 in Fahrenheit is 25.833334 in Celsius.

บรรทัดที่ 2 และ 3 เป็นการเรียกใช้คำสั่งของตัวประมวลผลก่อนซี #define ซึ่งใช้สำหรับกำหนดให้ FACTOR และ FBASE มีค่าคงที่ที่มีค่าเป็น 5/9 และ 32 ตามลำดับ ในขั้นตอนการประมวลผลก่อน (preprocessing) ค่าคงที่ทั้งหมดจะถูกแทนที่ด้วยค่าที่กำหนดให้
บรรทัดที่ 11 ค่า 78.5 เป็นค่าคงตัวชนิดจำนวนจริงที่กำหนดให้เป็นค่าของตัวแปร degF
บรรทัดที่ 16 เราสามารถกำหนดให้ตัวแปร degF มีค่าเป็น 100.00 และเรียกใช้ค่าคงที่ FACTOR และ FBASE คำนวณอีกครั้งในบรรทัดที่ 17

การใช้ค่าคงที่ในโปรแกรมอย่างเหมาะสม จะช่วยให้สามารถเข้าใจความหมายของโปรแกรมได้ดียิ่งขึ้น และยังช่วยให้การปรับปรุงโปรแกรมทำได้โดยง่าย