tiajposzoszaj: การพิมพ์และการรับข้อมูล ในภาษา C

บทที่ 3
การพิมพ์และการรับข้อมูล
ในภาษา C จะมีฟังก์ชันสำหรับการพิมพ์และการรับข้อมูลไว้ให้ใช้มากมาย การพิมพ์ก็คือ การนำข้อมูลไปแสดงที่หน้าจอ และการรับข้อมูลก็คือ การรับข้อมูลจากคีย์บอร์ดเข้ามา ซึ่งในภาษา C นั้นจะมองอุปกรณ์ในเครื่องคอมพิวเตอร์เป็นไฟล์ทั้งหมด ยกตัวอย่างเช่น จอภาพจะเป็น Standard Output File และคีย์บอร์ดจะเป็น Standard Input File ดังรูปที่ 3-1

รูปที่ 3-1 แสดงการพิมพ์และรับข้อมูล

Standard Input File โดยทั่วไปก็คือ Buffered นั่นเอง ซึ่งจะทำหน้าที่ในการเก็บข้อมูลที่ได้รับจากคีย์บอร์ดไปเก็บไว้ โดยเรียงลำดับกันเข้าไป
Standard Output File คือ จอภาพ ซึ่งก็เหมือนกับคีย์บอร์ด ซึ่งจะเป็นเท็กซ์ไฟล์ เมื่อต้องการจะแสดงข้อมูลนั้น จะทำการแปลงข้อมูลเป็นข้อความก่อนแล้วค่อยพิมพ์แสดงออกมา
การพิมพ์ข้อมูล
ฟังก์ชันมาตรฐานที่ใช้ในการพิมพ์ข้อมูลของภาษา C คือ printf ซึ่งมีรูปแบบดังนี้
รูปแบบ
Printf (“[รูปแบบข้อความ]”,[ตัวแปร])

รูปที่ 3 – 2 แสดงคำสั่งในการ Output ข้อมูลออกทางหน้าจอ

ในส่วนรูปแบบข้อความนั้น อาจจะเป็นตัวอักษร ข้อความ หรือเป็นตัวกำหนดชนิดของข้อมูล ซึ่งใช้กำหนดชนิดข้อมูลที่จะพิมพ์ ซึ่งจะต้องอยู่หลังเครื่องหมาย % เสมอ และสามารถใช้ได้ทั้งการ Input และ Output ดังแสดงในตารางที่ 3 -1

ตารางที่ 3 – 1 แสดงตัวกำหนดชนิดข้อมูล

ชนิดข้อมูล	ขนาด	รหัส	ตัวอย่าง
char	-	c	%c
short int int long int	h - I or L	d d d	%hd %d %Ld
float double long doule	- - L	f f f	%f %f %Lf

และผู้ใช้สามารถกำหนดความยาวของข้อมูลที่จะแสดงออกมาได้ โดยมีรูปแบบคำสั่งดังนี้
%[ความยาว][ตัวกำหนดข้อมูล]
สามารถดูตัวอย่างได้ในตารางที่ 3- 2

ตารางที่ 3 -2 การแสดงข้อมูลแบบกำหนดและไม่กำหนดความยาว

ค่า	%d	%4d
12 123 1234 12345	12 123 1234 12345	12 123 1234 12345

                ถ้าข้อมูลเป็นตัวเลขชนิด float ก็สามารถทำได้เช่นกัน แต่จะต้องกำหนดตัวเป็นดังนี้
% [ความยาว].[จำนวนเลขหลังจุดทศนิยม][ตัวกำหนดข้อมูล]
เช่น
printf(“%7.2f”,23.35000);
ซึ่งมีความหมายว่า ข้อมูลที่จะแสดงยาวทั้งหมด 5 ตัว โดยแบ่งเป็นจำนวนตัวเลขหน้าจุด ทศนิยม 4 ตัว ทศนิยม 1 ตัว และตัวเลขหลังจุดทศนิยมอีก 2 ตัว ผลลัพธ์ของคำสั่งด้านบนจะเป็นดังนี้
                                23.35
ตัวอย่างการพิมพ์ข้อมูล
1. printf(“%d%c%f”,23, ‘z’,4.1);
ผลลัพธ์ที่ได้เป็นดังนี้
                                23z4.100000
ผลลัพธ์ที่ออกมาติดกัน เพราะในรูปข้อความระหว่างตัวกำหนดชนิดข้อมูลแต่ละตัวนั้นไม่ได้เว้นวรรคไว้ จึงแสดงผลออกมาติดกัน
2. printf(“%d %c %f”, 23. ‘z’, 4.1);
ผลลัพธ์ที่ได้เป็นดังนี้
                23 z 4.100000
เป็นการพิมพ์ตามตัวอย่างที่ 1 แต่แก้ไขให้มีการเว้นวรรคระหว่างค่าด้วย
3.            int num1 = 23;
char zee = ‘z’;
float num2 = 4.1;
printf(“%d %c %f”, num1, zee, num2);
ผลลัพธ์ที่ได้เป็นดังนี้
                23 z 4.100000
4.            printf(“%d\t%c\t%5.1f”, 23, ‘z’, 14.2);
printf(“%d\t%c\t%5.1f”, 107, ‘A’, 53.6);
printf(“%d\t%c\t%5.1f”, 1754, ‘F’, 122.0);
printf(“%d\t%c\t%5.1f”, 3, ‘P’, 0.1);
                ผลลัพธ์ที่ได้เป็นดังนี้
                                23                           z              14.2
                                107                         A             53.6
                                1754                       F             122.0
                                3                              P             0.1
5. printf(“The number is %6d”, 23);
ผลลัพธ์ที่ได้เป็นดังนี้
                                The number is     23
ในภาษา C นั้นจะมีค่าคงที่ที่เป็นตัวอักษรอยู่ชุดหนึ่ง ที่จะใช้ในการควบคุมการพิมพ์และแสดงเครื่องหมายบางอย่างที่ไม่สามารถพิพม์เครื่องหมายนั้นตรงๆ ลงไปในรูปแบบของข้อความได้ ซึ่งชุดค่าคงที่ของตัวอักษรเหล่านี้ เรียกว่า Back-slash character ดังแสดงในตารางที่ 3-3
ตารางที่ 3-3 แสดง Back-slash character

สัญลักษณ์	ความหมาย
‘\0’	Null Character
‘\a’	Alert
‘\b’	Backspace
‘\t’	Horizontal
‘\n’	Newline
‘\v’	Vertical tab
‘\f’	Form feed
‘\r’	Carriage return
‘\’	Single quote
‘\”’	Double quote
‘\\’	Backslash

ตัวอย่างการพิมพ์ข้อมูลแบบที่ผิด
1. printf(“%d %d %d\n”, 44, 55);
44 55 0
ในรูปแบบข้อความมีตัวกำหนดชนิดข้อมูล 3 ตัว แต่มีค่าที่ส่งให้เพียง 2 ค่า
2. printf(“%d %d\n”, 44, 55, 66);
44 55
ในรูปแบบข้อความมีตัวกำหนดชนิดข้อมูลเพียง 2 ตัว แต่มีค่าที่ส่งไปให้ 3 ตัว ทำให้พิมพ์ค่าที่ 3 อกมาได้
3. long int x = 444446766;
printf(“%d\n”, x);
-18386
พิมพ์ค่าออกมาไม่ตรงตามค่าที่แท้จริง เนื่องจากใช้ตัวกำหนดชนิดข้อมูลไม่ตรงกับชนิดข้อมูลที่ต้องการจะพิมพ์ จะต้องใช้ตัวกำหนดข้อมูลเป็น %Ld
รูปแบบการรับข้อมูล
ฟังก์ชันมาตรฐานที่ใช้ในการรับข้อมูลของภาษา C คือ scanf ซึ่งมีรูปแบบดังนี้
รูปแบบ
Scanf(“[รูปแบบข้อความ]”,[ที่อยู่ของตัวแปร])

รูปที่ 3-3 แสดงฟังก์ชันในการรับข้อมูลจากคีย์บอร์ด

                เมื่อโปรแกรมทำงานมาถึงฟังก์ชันนี้ โปรแกรมจะหยุดรอให้ผู้ใช้ป้อนข้อมูล โดยข้อมูลที่ป้อนลงไปจะไปแสดงบนจอภาพด้วย เมื่อป้อนเสร็จให้กดปุ่ม Enter ข้อมูลก็จะถูกเก็บในตัวแปรตามรูปแบบข้อความ โดยในรูปแบบข้อความนั้นจะต้องมีตัวกำหนดชนิดข้อมูลด้วย ซึ่งตัวกำหนดชนิดข้อมูลจะต้องมีจำนวนเท่ากับตัวแปร มิฉะนั้นจะเกิด Error ขึ้นมาทันที
ตัวอย่างการรับข้อมูล
1. 214 156 14z
scanf(“%d%d%d%c”, &a, &b, &c, %d);
สาเหตุที่ไม่ต้องเว้นวรรคระหว่าง 14 กับ z นั้น เพราะ %c จะไม่ตัดช่องว่าง เพราะช่องว่างก็ถือว่าเป็นตัวอักษรเหมือนกัน เพราะฉะนั้นจะต้องแก้เป็นดังนี้
                scanf(“%d%d%d %c”, &a, &b, &c, %d);
2. 2314 15 2.14
scanf(“%d %d %f”, &a, &b, &c);
การรับค่าที่เป็นตัวเลขนั้น เว้นวรรคจะไม่มีผลค่าการรับค่า
3. 14/26 25/66
scanf(“%2d/%2d %2d/%2d”, &num1, &num2, &num3, &num4);
ถ้ามี / ในรูปแบบข้อความ ผู้ใช้ต้องพิมพ์เข้าไปด้วยในระหว่างการรับข้อมูบล
4. 11-25-56
scanf(“%d-%d-%d”,&a, &b, &c);
ตัวอย่างการรับข้อมูลที่ผิด
1. int a = 0;
scanf(“%d”,a);
printf(“%d/n”,a);
234                         (Input)
                                                0                              (Output)
ตัวอย่างนี้ผิดเพราะในตอนรับค่าไม่มีเครื่องหมาย & หน้า a ทำให้เมื่อรับค่าแล้วไม่รู้จะไปเก็บค่าไว้ที่ไหนทำให้ error
2. float a = 2.1;
scanf(“%5.2f”,&a);
printf(“%5.2f”,a);
ตัวอย่างนี้จะคอมไพล์ผ่านแต่จะรันไม่ได้ เพราะในการรับค่าจะไม่สามารถกำหนดความยาวในการรับแบบจุดทศนิยมได้
3. int a;
Int b;
scanf(“%d%d%d”,&a, &b);
Printf(“%d %d/n”, a, b);
5 10                      (Input)
                                5 10                      (Output)
ตัวอย่างนี้ในตอนรับค่ามีตัวกำหนดชนิดข้อมูล 3 ตัว แต่มีที่อยู่ของตัวแปรเพียง 2 ตัว ฟังก์ชั่น scanf จะรับค่าเพียง 2 ค่า และจะออกไปเลย เพราะไม่สามาหาที่อยู่ให้กับค่าที่ 3 ได้
ฟังก์ชันการรับข้อมูลตัวอักษร
การที่จะใช้ฟังก์ชันต่อไปนี้ได้ จะต้องนำเข้าเข้าไลบรารีไฟล์ที่ชื่อ conio.h ด้วย
getch เมื่อทำงานมาถึงฟังก์ชันนี้ โปรแกรมจะหยุดให้ผู้ใช้พิมพ์ข้อมูล 1 ตัวอักษร และเมื่อป้อนเสร็จแล้วไม่ต้องกดปุ่ม Enter และเคอร์เซอร์จะไม่ขึ้นบรรทัดใหม่ และตัวอักษรที่พิมพ์ลงไปจะไม่แสดงออกทางจอภาพด้วย ซึ่งตัวอย่างแสดงได้ดังนี้
                ch = getch();
getche ฟังก์ชันนี้จะทำงานเหมือนกับฟังก์ชัน getch แต่จะแสดงตัวอักษรที่พิมพ์เข้าไปออกทางจอภาพด้วย ซึ่งตัวอย่างแสดงดังนี้
ch = getch();
getchar เมื่อทำงานมาถึงฟังก์ชันนี้ โปรแกรมจะหยุดให้ผู้ใช้พิมพ์ข้อมูล 1 ตัวอักษร และเมื่อป้อนเสร็จแล้ว จะต้องกดปุ่ม Enter ด้วย และเคอร์เซอร์ก็จะขึ้นบรรทัดใหม่ ส่วนตัวอักษรที่พิมพ์ลงไปก็จะแสดงออกทางจอภาพด้วย ซึ่งตัวอย่างแสดงดังนี้
ch = getchar(0;
ตัวอย่างโปรแกรม
ในโปรแกรม 3-1 เป็นโปรแกรมง่ายๆ จะแสดง “Nothing”
                โปรแกรมที่ 3-1 โปรแกรมที่แสดงคำว่า “Nothing”

ผลลัพธ์ที่ได้

โปรแกรมที่ 3-2 เป็นโปรแกรมที่จะแสดงค่าของตัวอักษรออกมาเป็นตัวเลข โดยจะประกาศตัวแปรตัวอักษรตัวอักษรแล้วกำหนดค่าเริ่มต้นให้กับตัวแปรเหล่านั้น และพิมพ์ค่าเหล่านั้นออกมาเป็นตัวเลข
โปรแกรมที่ 3-2 โปรแกรมค่าของตัวอักษรออกมาเป็นตัวเลข

ผลลัพธ์ที่ได้

โปรแกรมที่ 3-3 เป็นโปรแกรมที่จะแสดงผลลัพธ์ออกมาเหมือนกับรายงาน

ผลลัพธ์ที่ได้

โปรแกรมที่ 3-4 โปรแกรมแสดงการใช้ฟังก์ชันรับข้อมูลตัวอักษร

ผลลัพธ์ที่ได้

โครงสร้างของภาษา C

ภาษา C เป็นภาษาคอมพิวเตอร์ที่ถูกค้นคิดขึ้นโดย Denis Ritchie ในปี ค.ศ. 1970
โดยใช้ระบบปฏิบัติการของยูนิกซ์ (UNIX) นับจากนั้นมาก็ได้รับความนิยมเพิ่มขั้นจนถึงปัจจุบัน ภาษา C สามารถติดต่อในระดับฮาร์ดแวร์ได้ดีกว่าภาษาระดับสูงอื่น ๆ ไม่ว่าจะเป็นภาษาเบสิกฟอร์แทน ขณะเดียวกันก็มีคุณสมบัติของภาษาระดับสูงอยู่ด้วย ด้วยเหตุผลดังกล่าวจึงจัดได้ว่าภาษา C เป็นภาษาระดับกลาง (Middle –lever language)
ภาษา C เป็นภาษาคอมพิวเตอร์ชนิดคอมไพล์ (compiled Language) ซึ่งมีคอมไพลเลอร์ (Compiler) ทำหน้าที่ในการคอมไพล์ (Compile) หรือแปลงคำสั่งทั้งหมดในโปรแกรมให้เป็นภาษาเครื่อง (Machine Language) เพื่อให้เครื่องคอมพิวเตอร์นำคำสั่งเหล่านั้นไปทำงานต่อไป

โครงสร้างของภาษา C
ทุกโปรแกรมของภาษา C มีโครงสร้างเป็นลักษณะดังรูป

Int main (void)
{

เฮดเดอร์ไฟล์ (Header Files)
เป็นส่วนที่เก็บไลบรารี่มาตรฐานของภาษา C ซึ่งจะถูกดึงเข้ามารวมกับโปรแกรมในขณะที่กำลังทำการคอมไพล์ โดยใช้คำสั่ง
#include<ชื่อเฮดเดอร์ไฟล์> หรือ
#include “ชื่อเฮดเดอร์ไฟล์”
ตัวอย่าง
#include<stdio.h>

เฮดเดอร์ไฟล์นี้จะมีส่วนขยายเป็น .h เสมอ และเฮดเดอร์ไฟล์เป็นส่วนที่จำเป็นต้องมีอย่างน้อย 1 เฮดเดอร์ไฟล์ ก็คือ เฮดเดอร์ไฟล์ stdio.h ซึ่งจะเป็นที่เก็บไลบรารี่มาตรฐานที่จัดการเกี่ยวกับอินพุตและเอาท์พุต

ส่วนตัวแปรแบบ Global (Global Variables)
เป็นส่วนที่ใช้ประกาศตัวแปรหรือค่าต่าง ๆ ที่ให้ใช้ได้ทั้งโปรแกรม ซึ่งใช้ได้ทั้งโปรแกรม ซึ่งในส่วนไม่จำเป็นต้องมีก็ได้
ฟังก์ชัน (Functions)
เป็นส่วนที่เก็บคำสั่งต่าง ๆ ไว้ ซึ่งในภาษา C จะบังคับให้มีฟังก์ชันอย่างน้อย 1 ฟังก์ชั่นนั่นคือ ฟังก์ชั่น Main() และในโปรแกรม 1 โปรแกรมสามารถมีฟังก์ชันได้มากกว่า 1 ฟังก์ชั่น

ส่วนตัวแปรแบบ Local (Local Variables)
เป็นส่วนที่ใช้สำหรับประกาศตัวแปรที่จะใช้ในเฉพาะฟังก์ชันของตนเอง ฟังก์ชั่นอื่นไม่สามารถเข้าถึงหรือใช้ได้ ซึ่งจะต้องทำการประกาศตัวแปรก่อนการใช้งานเสมอ และจะต้องประกาศไว้ในส่วนนี้เท่านั้น
ตัวแปรโปรแกรม (Statements)
เป็นส่วนที่อยู่ถัดลงมาจากส่วนตัวแปรภายใน ซึ่งประกอบไปด้วยคำสั่งต่าง ๆ ของภาษา C และคำสั่งต่าง ๆ จะใช้เครื่องหมาย ; เพื่อเป็นการบอกให้รู้ว่าจบคำสั่งหนึ่ง ๆ แล้ว ส่วนใหญ่ คำสั่งต่าง ๆ ของภาษา C เขียนด้วยตัวพิมพ์เล็ก เนื่องจากภาษา C จะแยกความแตกต่างชองตัวพิมพ์เล็กและพิมพ์ใหญ่หรือ Case Sensitive นั่นเอง ยกตัวอย่างใช้ Test, test หรือจะถือว่าเป็นตัวแปรคนละตัวกัน นอกจากนี้ภาษา C ยังไม่สนใจกับการขึ้นบรรทัดใหม่ เพราะฉะนั้นผู้ใช้สามารถพิมพ์คำสั่งหลายคำสั่งในบรรทัดเดียวกันได้ โดยไม่เครื่องหมาย ; เป็นตัวจบคำสั่ง

ค่าส่งกลับ (Return Value)
เป็นส่วนที่บอกให้รู้ว่า ฟังก์ชันนี้จะส่งค่าอะไรกลับไปให้กับฟังก์ชั่นที่เรียกฟังก์ชั่น ซึ่งเรื่องนี้ผู้เขียนจะยกไปกล่าวในเรื่องฟังก์ชั่นอย่างละเอียดอีกทีหนึ่ง

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

รูปที่ 2-2 แสดงการเขียนหมายเหตุหรือ Comment ในลักษณะต่าง ๆ

โปรแกรมที่ 2 – 1 โปรแกรมแรกสำหรับคุณ

การตั้งชื่อ
การตั้งชื่อ (Identifier) ให้กับตัวแปร ฟังก์ชันหรืออื่น ๆ มีกฎเกณฑ์ในการตั้งชื่อ ดังนี้
1. ตัวแรกของชื่อจะต้องขึ้นต้องด้วยตัวอักษรหรือเครื่องหมาย _ เท่านั้น
2. ตัวอักษรตั้งแต่ตัวที่ 2 สามารถเป็นตัวเลข หรือเครื่องหมาย_ก็ได้
3. จะต้องไม่มีการเว้นวรรคภายในชื่อ แต่สามารถใช้เครื่อง_คั่นได้
4. สามารถตั้งชื่อได้ยาไม่จำกัด แต่จะใช้ตัวอักษรแค่ 31 ตัวแรกในการอ้างอิง
5. ชื่อที่ตั้งด้วยตัวอักษรพิมพ์ใหญ่และพิมพ์เล็ก จะถือว่าเป็นคนละตัวกัน
6. ห้ามตั้งชื่อซ้ำกับคำสงวนของภาษา C

ตัวอย่างการตั้งที่ถูกและผิด

แบบที่ถูก	แบบที่ผิด
A	$sum
Student_name	Student Name
_SystemName	2names
A1	int

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

ชนิดข้อมูลแบบไม่มีค่า หรือ Void Type (Void)
ข้อมูลชนิดนี้ จะไม่มีค่าและจะไม่ใช้ในการกำหนดชนิดตัวแปร แต่ส่วนใหญ่จะใช้เกี่ยวกับฟังก์ชั่น ซึ่งจะขอยกไปอธิบายในเรื่องฟังก์ชั่น

ชนิดข้อมูลมูลแบบจำนวนเต็ม หรือ Integer Type (int)
เป็นชนิดข้อมูลที่เป็นตัวเลขจำนวนเต็ม ไม่มีทศนิยม ซึ่งภาษา C จะแบ่งข้อมูลชนิดนี้ออกได้เป็น 3 ระดับ คือ short int,int และ long int ซึ่งแต่ละระดับนั้นจะมีขอบเขตการใช้งานที่แตกต่างกัน ดังแสดงในตารางที่ 2-1

ชนิดข้อมูล	คิดเครื่อง หมาย	ขนาด(ไบต์)	จำนวนบิต	ค่าน้อยที่สุด	ค่ามากที่สุด
Short int	คิด ไม่คิด	2	16	-32,768 0	32,768 65,535
Int (16 บิต)	คิด ไม่คิด	2	16	-32,768 0	32,768 65,535
Int (32 บิต)	คิด ไม่คิด	4	32	-2,147,486,643 0	2,147,486,643 4,294,967,295
Long int	คิด ไม่คิด	4	32	-2,147,486,643 0	2,147,486,643 4,294,967,295

ชนิดข้อมูลแบบอักษร หรือ Character Type (char)
ข้อมูลชนิดนี้ก็คือ ตัวอักษรตั้งแต่ A-Z เลข 0-9 และสัญลักษณ์ต่าง ๆ ตามมาตรฐาน ACSII (American Standard Code Information Interchange) ซึ่งเมื่อกำหนดให้กับตัวแปรแล้วตัวแปรนั้นจะรับค่าได้เพียง 1 ตัวอักษรเท่านั้น และสามารถรับข้อมูลจำนวนเต็มตั้งแต่ถึง 127 จะใช้ขนาดหน่วยความจำ 1ไบต์หรือ 8 บิต

ชนิดข้อมูลแบบทศนิยม หรือ Floating Point Type (flat)
เป็นข้อมูลชนิดตัวเลขที่มีจุดทศนิยม ซึ่งสามารถแบ่งออกเป็น 3 ระดับ คือ float, double และ long double แต่ละระดับนั้นจะมีขอบเขตที่แตกต่างกันในการใช้งาน ดังแสดงในตารางที่ 2-2

ตารางที่ 2-2 แสดงรายละเอียดของชนิดข้อมูลแบบทศนิยม

ชนิดข้อมูล	ขนาด(ไบต์)	จำนวนบิต	ค่าที่น้อยที่สุด
float	4	32	-38 38 3.4-10 ถึง 3.4-10
double	8	64	-308 308 1.710 ถึง 1.710
long double	10	80	-4932 4932 3.410 ถึง 1.110

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

การประกาศตัวแปร
การประกาศตัวแปรในภาษา C นั้นสามรถทำได้ 2 ลักษณะ คือ การประกาศตัวแปรแบบเอกภาพ หรือการประกาศตัวแปรแบบ Global คือ ตัวแปรที่จะสามารถเรียกใช้ได้ทั้งโปรแกรม และแบบที่สองการประกาศตัวแปรแบบภายใน หรือการประกาศตัวแปรแบบ Local ซึ่งตัวแปรแระเภทนี้จะใช้ได้ในเฉพาะฟังก์ชั่นของตัวเองเท่านั้น

#include<stdio.h>
int total; /*การประกาศตัวแปรแบบ Global */
main()
{
int price,money; /*การประกาศตัวแปรแบบ Local*/
…
}

รูปที่ 2-3 แสดงการประกาศตัวแปรแบบต่าง ๆ

การกำหนดค่าให้กับตัวแปร
การกำหนดค่าให้กับตัวแปรนั้น จะสามารถกำหนดได้ตั้งแต่ตอนที่ประกาศตัวแปรเลยหรือจะกำหนดให้ภายในโปรแกรมก็ได้ ซึ่งการกำหนดค่าจะใช้เครื่องหมาย = กั้นตรงกลาง
int total = 0;
ถ้ามีตัวแปรข้อมูลชนิดเดียวกัน ก็สามารถทำแบบนี้ได้
int total =0,sum
หรือ
int total =0,sum=0;
ถ้าเป็นการกำหนดภายในโปรแกรม ซึ่งตัวแปรนั้นได้ประกาศไว้แล้วสามารถทำแบบนี้
total = 50;
หรือ
total = total+sum
หรือกำหนดค่าจาการพิมพ์ข้อมูลเข้าทางคีย์บอร์ด
scanf(“%d”,&total);

โปรแกรมที่ 2-2 การประกาศและใช้ตัวแปร
#include<stdio.h>
/*การประกาศตัวแปร Global*/
int sum = 0;
int main(void)
{
/*การประกาศตัวแปรแบบ Local */
int a;
int b;
int c;

/*คำสั่ง */
printf(“\nWelcome. This Program adds\n”);
printf(“threenumbers.Enter three numbers\n”);
printf(“in the form: nnn nnn nnn <retur>\n”);
scanf(“%d %d %d”,&a,&b,&c);
/* ทำการบวกค่าระหว่าง a,b และ c เข้าด้วยกันแล้วกำหนดค่าให้ sum*/
sum=a+b+c;
printf(“The total is: %d\n”,sum);
printf(“Thant you. Have a good day.\n”);
return 0;
}
ผลการทำงาน:
Welcome. This Program adds
Three numbers. Enter three number
In the form: nnn nnn nnn <return>
11 22 23
The total is: 56
Thank you. Have a good day.

การกำหนดชนิดข้อมูลแบบชั่วคราว
เมื่อผู้ใช้ได้กำหนดชนิดข้อมูลให้กับตัวแปรใด ๆ ไปแล้ว ตัวแปรตัวนั้นจะมีชนิดข้อมูลเป็นแบบที่กำหนดให้ตลอดไป บางครั้งการเขียนโปรแกรมอาจจะต้องมีความจำเป็นต้องเปลี่ยนชนิดข้อมูลของตัวแปรตัวนั้น ซึ่งภาษาซี ก็มีความสามารถที่จะทำเช่นนั้นได้
รูปแบบ
([ชนิดข้อมูล])[ตัวแปร]
ตัวอย่าง
(float)a
(int)a
โปรแกรมที่ 2-3 แสดงการใช้ตัวแปรแบบชั่วคราว
#include<stdio.h>
int main(void)
{
float a= 25.3658;
printf(“Value of a : %\n”,a);
printf(“Value of a when set is integer : %d\n”,(int)a);
return 0;
}
ผลการทำงาน :
Value of a : 25.365801
Value of a when change is integer : 25

ชนิดข้อมูลแบบค่าคงที่ (Constants)
ชนิดข้อมูลประเภทนี้ ชื่อก็บอกอยู่ว่าเป็นชนิดข้อมูลแบบค่าคงที่ ซึ่งก็คือข้อมูลตัวแปรประเภทที่เป็น Constants ผู้ใช้จะไม่สามารถเปลี่ยนแปลงค่าของตัวแปรตัวนั้น ในขณะที่โปรแกรมทำงานอยู่
รูปแบบ
Const[ชนิดข้อมูล][ตัวแปร]=[ค่าหรือ นิพจน์]
ตัวอย่าง
const folat a = 5.23;
const int b = a%2;

โปรแกรมที่ 2-4 การใช้ตัวแปรชนิดข้อแบบค่าคงที่
#include<stdio.h>
imt main(void)
{
const float pi = 3.14159;
float radius;
radius = 3;
printf(“Value of pi : %f\n”,pi);
printf(“Value of area : %f\n”,pi*(radius*radius));
return 0;
}
ผลการทำงาน:
Value of pi : 3.141590
Value of area : 28.274311

constant นั้นสามารถแบ่งออกได้ ดังนี้
Integer Constants เป็นค่าคงที่ชนิดข้อมูลแบบตัวเลขจำนวนเต็มไม่มีจุดทศนิยม
const int a = 5;

Floating-Point Constants เป็นค่าคงที่ชนิดข้อมูลแบบตัวเลขที่มีจุดทศนิยม
const float b = 5.6394;

Character Constants เป็นค่าคงที่ชนิดตัวอักษร ซึ่งจะต้องอยู่ภายในเครื่องหมาย ‘’เท่านั้น
const char b = ‘t’;

String Constants เป็นค่าคงที่เป็นข้อความ ซึ่งจะต้องอยู่ภายใต้เครื่องหมาย “”เท่านั้น
“”
“h”
“Hello world\n”
“HOW ARE YOU”
“Good Morning!”
โปรแกรมที่ 2-5 การใช้ตัวแปรชนิดข้อมูลแบบค่าคงที่แบบต่าง ๆ
#includ<stdio.h>
int main(void)
{
const int a = 3; /*Integer Constats*/
const flat b = 3.14159; /*Floating – Point Constants*/
const cahr c = ‘P’; /*Character Constants*/
printf(“Value of a: %d\n”,a);
printf(“Value of b: %d\n”,b);
printf(“Value of c: %d\n”,c);
printf(“Good Bye”); /*String Constants*/
return 0;
}
ผลการทำงาน
Value of a : 3
Value of b : 3.141590
Value of c : P
Good Bye

Statements
statements ในภาษา c คือ คำสั่งต่าง ไ ที่ประกอบขึ้นจนเป็นตัวโปรแกรม ซึ่งในภาษา c นั้นได้แบ่งออกเป็น 6 แบบ คือ Expression Statement และ Compound Statement ณ.ที่นี้จะมีด้วยกัน 2 แบบ

Expression Statement หรือเรียกอีกอย่างหนึ่งว่า Single Statement ซึ่ง Statement แบบนั้นจะต้องมีเครื่องหมาย; หลังจาก statement เมื่อภาษา C พบเครื่องหมาย ; จะทำให้มันรู้ว่าจบชุดคำสั่งแล้ว แล้วจึงข้ามไปทำ Statement ชุดต่อไป

a = 2;
หรือ
printf(“x contains %d, y contains %d\n”,x,y);

Compound Statement คือ ชุดคำสั่งที่มีคำสั่งต่าง ๆ รวมอยู่ด้านใน Block ซึ่งจะใช้เครื่องหมาย {เป็นการเปิดชุดคำสั่ง และใช้} เป็นตัวปิดชุดคำสั่ง ตัวอย่างที่เห็นได้ชัดเจนสำหรับ Statement แบบนี้ คือ ตัวฟังก์ชั่น Main โดยทั่ว ๆ ไปในภาษา C Compound Statement จะเป็นตัวฟังชั่น

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