ส่งงาน อ.นจิรัต

1. ภาษา
โปรแกรม
(ภาษาซี)

2. 2
ภาษา
BCPL
ภาษา
B
ภาษา
C
1. ประวัติความ
เป็นมา
1. ประวัติความ
เป็นมา
บนเครื่อง
PDP-7
(UNIX)
พ.ศ. 2513
พ.ศ. 2515
โดย เดนนิช ริทชี่
Basic Combined
Programming
Language

3. 3
# header
ส่วนที่ 1
main( )
{ /* เริ่มโปรแกรม */
declaration ส่วนที่ 2
………
คำาสั่งต่าง ๆ
ส่วนที่ 3
}
2. โครงสร้างพื้นฐาน
ของภาษาซี
2. โครงสร้างพื้นฐาน
ของภาษาซี

4. 4
ป็นส่วนที่ระบุให้ซีคอมไพเลอร์เตรียมการทำางานที่ก
นส่วนนี้ไว้ โดยหน้าคำาสั่งจะมีเครื่องหมาย # เช่น
# include <stdio.h>
ป็นการระบุให้นำาไฟล์ stdio.h มารวมกับไฟล์นี้ เพ
สามารถใช้คำาสั่งที่อยู่ในไฟล์นี้มาใช้งานได้
# define START 0
ป็นการกำาหนดค่าคงที่ให้กับตัวแปร START
โดยให้มีค่าเป็น 0
# define temp 37
ป็นการกำาหนดให้ตัวแปร temp มีค่าเท่ากับ 37

5. 5
ส่วนที่ 2 declaration เป็นการกำาหนดชนิด
ข้อมูลที่จะใช้ใน
โปรแกรมซึ่งตัวแปรหรือข้อมูลต่าง ๆ
นั้นจะต้องถูก
ประกาศ(declare) ในส่วนนี้ก่อน จึง
จะสามารถนำาไปใช้
ในโปรแกรมได้ เช่น
int stdno;
เป็นการกำาหนดว่าตัวแปร stdno เป็น
ข้อมูลชนิดจำานวนเต็ม
หรือ interger ซึ่งอาจได้แก่ค่า 0,4,-
1,-3,…. เป็นต้น

6. 6
ody คือส่วนของตัวโปรแกรม โดยจะต้องเริ่มต้นด้ว
main ( ) แล้วใส่เครื่องหมายกำาหนดขอบเขตเริ่มต้นข
ปรแกรมคือ { หลังจากนั้นใส่คำาสั่งหรือฟังก์ชันต่าง
ะคำาสั่งหรือฟังก์ชันนั้น ๆ จะต้องปิดด้วยเครื่องหมาย
มื่อต้องการจบโปรแกรมให้ใส่เครื่องหมาย } ปิดท้าย
main ( )
{ /* เริ่มต้นโปรแกรม */
คำาสั่งต่าง ๆ ;
ฟังก์ชัน;
……………
…………...
} /* จบโปรแกรม */

7. 7
เครื่องหมายต่าง ๆ
{ } - เป็นตัวกำาหนดขอบเขตหรือบล็อก
ของฟังก์ชัน
( ) - เป็นการระบุตัวผ่านค่าหรือ
อาร์กิวเมนต์ให้กับฟังก์ชัน
ถ้าภายในวงเล็บไม่มีข้อความใด
ๆ แสดงว่าไม่มีตัวผ่าน
ค่าที่ต้องการระบุสำาหรับฟังก์ชัน
นั้น ๆ
/* */ - เป็นการกำาหนด comment หรือ

8. 8
# include <stdio.h>
int main (void )
{
printf(“Hello, Good morning. n”);
}
ตัวอย่างโปรแกรม
โปรแกรมที่ 1
เป็นโปรแกรมสั่งพิมพ์ข้อความ Hello, Good morning

9. 9
โปรแกรมที่ 2
# include <stdio.h>
main ( )
{
float point;
printf("nnPut your score
inn");
scanf("%f", &point);
printf("Your score is %f
pointnn", point);
}
เป็นโปรแกรมรับคะแนนและเก็บค่าที่ตัวแปร poi
หลังจากนั้นสั่งให้มีการพิมพ์คะแนนออกมา

10. 10
นิดของข้อมูลและตัวแปรในภาษาซีนิดของข้อมูลและตัวแปรในภาษาซี
การกำาหนดชื่อตัวแปร หลักการมีดังนี้
1. ต้องขึ้นต้นด้วยตัวอักษร
2. ห้ามใช้เครื่องหมายทาง
คณิตศาสตร์ในชื่อตัวแปร
3. สามารถใช้เครื่องหมาย underline
‘_’ ได้
4. ห้ามใช้ reserved words เช่น int,
float, etc.
Note: คอมไพเลอร์ในภาษาซีสามารถเห็น
ความแตกต่างของชื่อตัวแปรได้ยาวไม่เกิน 8

11. 11
แบบข้อมูลหรือชนิดของตัวแปรต่าง ๆ ที่
กำาหนดไว้ในภาษาซี
char ชนิดของตัวอักษรหรือ
อักขระ
int ชนิดจำานวนเต็มปกติ
short ชนิดจำานวนเต็มปกติ
long ชนิดจำานวนเต็มที่มีความ
ยาวเป็น 2 เท่า
unsigned ชนิดของเลขที่ไม่คิด
เครื่องหมาย
float ชนิดเลขมีจุดทศนิยม
แบบข้อมูลและขนาด

12. 12
ชนิดข้อมูล ( )เนื้อที่สำาหรับเก็บไบต์ ค่าตัวเลขที่เก็บ
Char 1 เก็บตัวอักษรASCII 1 0 255ได้ ตัวหรือจำานวนเต็มระหว่าง ถึง
Int 2 –32768 32767ค่าตัวเลขระหว่าง ถึง
Short 2 –32768 32767ค่าตัวเลขระหว่าง ถึง
Long 4 ค่าตัวเลขประมาณ±2000ล้าน
Unsigned Unsignedshort=2
Unsignedlong=4
0 65535ค่าตัวเลขระหว่าง ถึง
0 4000ค่าตัวเลขระหว่าง ถึง ล้าน
Float 4 10ได้ค่าตัวเลขยกกำาลัง x
โดยx –37 +38มีค่าระหว่าง ถึง
Double 8 ความถูกต้องของตัวเลขจะมีค่าสูงขึ้น
เนื้อที่ในหน่วยความจำาและค่าตัวเลขที่เก็บของข้อม

13. 13
ยนโปรแกรม แบบข้อมูลที่ใช้จะแบ่งออกเป็น 4
ข้อมูลและตัวแปรชนิดอักขระ
ข้อมูลและตัวแปรชนิดจำานวนเต็ม
ข้อมูลและตัวแปรชนิดเลขมีจุดทศนิยม
ข้อมูลและตัวแปรแบบสตริง

14. 14
ข้อมูลและตัวแปรชนิดอักขระ
ขระแทนด้วย char ‘ ’โดยอยู่ภายในเครื่องหมาย เ
# include <stdio.h>
main ( )
{
char reply;
reply = ‘y’;
…………………
}

15. 15
การให้ค่าอักขระที่เป็นรหัสพิเศษหรือ
รหัสควบคุม
อักขระเหล่านี้ไม่สามารถให้ค่าโดยตรง
แต่จะทำาได้โดยการให้ค่าเป็นรหัส ASCII ซึ่ง
จะเขียนในรูปของเลขฐานแปด โดยใช้
‘เครื่องหมาย ’ นำาหน้า หรือใช้ตัวอักขระที่
กำาหนดให้กับรหัสนั้น ๆ เขียนตาม
‘เครื่องหมาย ’ สำาหรับรหัสบางตัว เช่น
รหัส BELL แทนด้วย ASCII 007 ซึ่ง
กำาหนดได้ดังนี้
beep = ‘007’;

16. 16
ตัวอย่างโปรแกรม
# include <stdio.h>
main ( )
{
char newline;
newline = ‘n’;
printf(“Hello, Good morning.
%c”,newline);
printf(“Hello, Good morning.n”);
}

17. 17
อมูลและตัวแปรชนิดจำานวนเต็ม
จำานวนเต็มในภาษาซีสามารถใช้แทนได้ 4
รูปแบบคือ int, short, long และ unsigned
สำาหรับการกำาหนดตัวแปรแบบ unsigned
คือจำานวนเต็มที่ไม่คิดเครื่องหมายนั้นจะต้อง
ใช้ควบคู่กับรูปแบบข้อมูลจำานวนเต็มชนิดอื่น
ๆ คือ int หรือ short หรือ long ตัวอย่าง
เช่น
unsigned int plusnum;
unsigned long width;
unsigned short absno; /*

18. 18
อมูลและตัวแปรชนิดเลขมีจุดทศนิยม
รับเลขมีจุดทศนิยมนั้นแทนได้ 2 แบบคือ float และ
ดย double เก็บค่าได้เป็น 2 เท่าของ float
นทางวิทยาศาสตร์ที่ต้องการความละเอียดในการเก
เก็บในรูปแบบนี้ คือเก็บแบบเอ็กโพเนนซ์ ดังตัวอย
ข แสดงแบบวิทยาศาสตร์ แบบเอ็ก
0,000 9.0*109
9.0e9
0 3.45*105
3.45e5
3 6.3*10-4
6.3e-4
924 9.24*10-6
9.24e-6

19. 19
ข้อมูลและตัวแปรแบบสตริง
งหมายถึงตัวอักขระหลาย ๆ ตัวมาประกอบกันเป็นข
ำาตัวแปรหลาย ๆ ตัวมาเก็บรวมกันในภาษาซีนี้เรียก
ดังนั้นข้อมูลแบบสตริงคือ อะเรย์ของตัวอักขระ นั่นเอ
งหมายของอะเรย์คือ [ ] รูปแบบการกำาหนดสตริง
งนี้
char name[30];
ตัวแปร name เป็นชนิด char ที่มีความยาว 30 ตัวอ
ป็น อะเรย์ การเก็บนั้นจะเก็บเรียงกันทีละไบต์ และไ
null คือ 0 ดังนั้นจะเก็บได้จริงเพียง 29 ตัวอักษร

20. 20
าหนดค่าให้ตัวแปรและการส่งผลลัพธ์
ารกำาหนดค่าให้ตัวแปรอาจทำาได้โดยกำาหนดในโป
าหนดในขณะที่มีการกำาหนดชนิดก็ได้ เช่น
( )
age = 18;
at height;
ight = 172.5;
ntf(“Mr. Surasak is %d years old”,age);
ntf(“ and tall %f cms.n”,height);

21. 21
ตัวอย่างของโปรแกรมในการกำาหนดค่า
และส่งค่าผลลัพธ์
# include <stdio.h>
main ( )
{
int sum,valuea;
int count = 1;
valuea = 4;
sum = count + valuea;
printf(“Total value is %d.n”,sum);
}
ผลลัพธ์จะปรากฏข้อความ : Total

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

23. 23
แบบที่ใช้สำาหรับกำาหนดการพิมพ์ในฟังก์ชัน printf
%d พิมพ์ด้วยเลขฐานสิบ
%o ” ” เลขฐานแปด
%x ” ” เลขฐานสิบหก
%u ” ” เลขฐานสิบแบบไม่คิดเครื่องหมาย
%e ” ” ตัวเลขแบบวิทยาศาสตร์ เช่น 2.13e4
%f ” ” ตัวเลขมีจุดทศนิยม
%g ” ” รูปแบบ %e หรือ %f โดยเลือกแบบ
ที่สั้นที่สุด
หรับสตริงมีรูปแบบการพิมพ์ดังนี้
%c พิมพ์ด้วยตัวอักษรตัวเดียว
%s ” ”ข้อความ

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

25. 25
รูปแบบของ scanf ( )
scanf( ส่วนควบคุมข้อมูล, อาร์กิวเมนต์,
อาร์กิวเมนต์,...)
ส่วนควบคุมข้อมูล เป็นการกำาหนดรูปแบบข้อมูลใน
“ ”เครื่องหมาย
อาร์กิวเมนต์ เป็นส่วนที่จะนำาข้อมูลมาเก็บ(ใน
ตัวแปร) ซึ่งชนิดของข้อมูลต้องตรงตามรูปแบบที่
กำาหนดในส่วนควบคุมข้อมูล
การกำาหนดลักษณะอาร์กิวเมนต์มีได้ 2 แบบดังนี้
ถ้าข้อมูลนั้นอาจจะนำาไปใช้ในการคำานวณ
- จะใส่เครื่องหมาย & หน้าตัวแปร
ถ้าข้อมูลนั้นเป็นข้อความที่จะนำาไปเก็บไว้ใน

26. 26
โอเปอเรเตอร์และ
นิพจน์
โอเปอเรเตอร์และ
นิพจน์
การแทนโอเปอเรเตอร์ทางคณิตศาสตร์สำาหรับภาษา
+ การบวก
- การลบ
* การคูณ
/ การหาร
% การหารเอาเศษ (โมดูลัส)

27. 27
การเปลี่ยนชนิดของข้อมูล
ทำาได้โดยระบุชนิดที่ต้องการเปลี่ยน
ภายในเครื่องหมาย ( )
แล้ววางหน้าตัวแปรหรือข้อมูลที่ต้องการ
เปลี่ยนแปลงชนิด
float money;
ต้องการเปลี่ยนตัวแปร float ไปเป็น
integer ทำาได้ดังนี้
(int) money;
int cost;

28. 28
การเพิ่มค่าและลดค่าตัวแปร
++n เพิ่มค่า n อีก 1
- -n ลดค่า n ลง 1
ความแตกต่างระหว่าง count++ และ +
+count
เช่น
count = 5;
x = count++; จะได้ค่า x เท่ากับ 5
แล้วค่า count
เท่ากับ 6

29. 29
นิพจน์กำาหนดค่า (Assignment
expression)
เครื่องหมายที่ใช้กำาหนดค่าคือ =
โดยเป็นการกำาหนดค่าทางขวาของ
เครื่องหมาย ให้กับตัวแปรที่อยู่
ทางซ้าย เช่น j = 7+2
หรือ k = k+4
3.4.6 เครื่องหมายและนิพจน์เปรียบเทียบ
> หรือ >= มากกว่า หรือ
มากกว่าเท่ากับ
< หรือ <= น้อยกว่า หรือ

30. 30
กต่างของเครื่องหมาย = และ ==
ครื่องหมาย = เป็นตัวกำาหนดค่า
เครื่องหมาย == เป็นเครื่องหมายเปรียบเทียบ ตัวอย
44;
ง เป็นการกำาหนดค่าให้กับตัวแปร point ให้มีค่าเท
= 44;
ง เป็นการตรวจสอบว่าค่า point มีค่าเท่ากับ 44 หรือ

31. 31
หมายและนิพจน์เปรียบเทียบแบบตรรกศ
&& และ (and)
| | หรือ (or)
! ไม่ (not)
นิพจน์เปรียบเทียบเชิงตรรก
ที่ 1 && นิพจน์ที่ 2 เป็นจริง เมื่อนิพจน์ทั้งสองเป็น
ที่ 1 | | นิพจน์ที่ 2 เป็นจริง เมื่อนิพจน์ใดนิพจน์ห
เป็นจริงหรือ ทั้งสองนิพจน์นั้นเป็นจริง
น์เปรียบเทียบ เป็นจริง เมื่อนิพจน์เปรียบเทียบ

32. 32
คำาสั่ง if
รูปแบบของคำาสั่ง
if (เงื่อนไข)
คำาสั่งที่ต้องทำา ถ้า
เงื่อนไขนั้นเป็นจริง;
ตัวอย่างเช่น
if (score >= 80)
grade = ‘A’; /* simple
statement */
หรือ
if (math >= 60 && eng >= 55)
{ grade = ‘S’; /* compound
statement */

33. 33
สั่ง if ….. else …..
รูปแบบของคำาสั่ง
if (คำาสั่งหรือนิพจน์เงื่อนไข)
คำาสั่งที่ต้องทำาเมื่อเงื่อนไขนั้นเป็นจ
else คำาสั่งที่ต้องทำาเมื่อเงื่อนไขนั้นไม่เป็น
งเช่น
if (value1 > value2)
min = value2;
else
min = value1;

34. 34
หมายพิเศษที่ใช้ในการเปรียบเทียบเงื่อน
รูปแบบทั่วไปของคำาสั่งเปรียบเทียบเงื่อนไข ? : มีด
นิพจน์ที่ 1 ? นิพจน์ที่ 2 : นิพจน์ที่ 3
มหมายคือ
if นิพจน์ที่ 1 เป็นจริง
ทำาตามคำาสั่งในนิพจน์ที่ 2
else
ทำาตามคำาสั่งในนิพจน์ที่ 3
x = (y< 0) ? -y : y;

35. 35
คำาสั่งตรวจสอบเงื่อนไขหลาย ๆ ทาง :
switch และ break
รูปแบบคำาสั่ง
switch (นิพจน์)
{
case label1 :
statement1;
case label2 :
statement2;
……………..
……………..

36. 36
ตัวอย่าง
switch (ch)
{
case ‘1’ :
printf(“Redn”);
case ‘2’ :
printf(“Bluen”);
case ‘3’ :
printf(“Yellown”);
default :
printf(“Whiten”);
}

37. 37
ตัวอย่าง
switch (ch)
{
case ‘1’ : printf(“Redn”);
break;
case ‘2’ : printf(“Bluen”);
break;
case ‘3’ : printf(“Yellown”);
break;
default : printf(“Whiten”);
}

38. 38
คำาสั่ง loop หรือคำาสั่ง
วนซำ้า
คำาสั่ง loop หรือคำาสั่ง
วนซำ้า
while
แบบ
while (นิพจน์เงื่อนไข)
{
คำาสั่งที่วนลูป;
………… compound sta
………….
}

39. 39
คำาสั่งลูป for
รูปแบบ
for ( นิพจน์ที่ 1 ; นิพจน์ที่ 2 ;
นิพจน์ที่ 3 )
{
คำาสั่งวนรอบ;
…….
}
เป็นคำาสั่งที่ใช้ในการควบคุมให้มีการวน
รอบคำาสั่งหลาย ๆ รอบ
โดยนิพจน์ที่ 1 คือการกำาหนดค่าเริ่มต้นให้กับ
ตัวแปรที่ใช้ในการวนรอบ
นิพจน์ที่ 2 เป็นการเปรียบเทียบ ก่อนที่จะวน

40. 40
วนรอบแบบที่ตรวจสอบเงื่อนไขทีหลัง : do wh
แบบ
do
statement;
while (นิพจน์เงื่อนไข);
num = 2;
do
{
num++;
printf(“Now no is %dn”,num);
} while (num == 10)

41. 41
คำาสั่งควบคุมอื่น ๆ break, continue, goto และ labelsคำาสั่งควบคุมอื่น ๆ break, continue, goto และ labels
reak
อต้องการให้การทำางานสามารถหลุดออกจากลูปแล
งที่อยู่นอกลูปทันที โดยไม่ต้องตรวจสอบเงื่อนไขใ
ontinue
มื่อต้องการให้การทำางานนั้น ย้อนกลับไปวนรอบให
ณะที่ตรงข้ามกับคำาสั่ง break

42. 42
oto และ labels
o ประกอบด้วย 2 ส่วน คือ
goto เป็นคำาสั่งให้กระโดดไปยังตำาแหน่งที่กำาหนด
าหนดเป็นชื่อ เรียกว่า label name
el name) เป็นตัวกำาหนดตำาแหน่งที่คำาสั่งจะกระโดด
น
ง ! คำาสั่งนี้ถือเป็นคำาสั่งที่ควรหลีกเลี่ยงในการเขียน
นหรือหลีกเลี่ยงไม่ได้เท่านั้น จึงจะใช้คำาสั่งนี้

43. 43
างโปรแกรมที่ใช้คำาสั่ง goto
#include<stdio.h>
main()
int sum,n;
for(n=1;n<10;n++)
if (n==5)
goto part1;
else printf(“%dn”,n);
part1 : printf(“Interrupt with no. 5n”);

44. 44
ฟังก์ชันฟังก์ชัน (Function)(Function)

45. 45
ฟังก์ชันฟังก์ชัน
(Functions)(Functions)
การออกแบบโปรแกรมในภาษาซี
จะอยู่บนพื้นฐานของการออกแบบ
โมดูล (Module Design) โดยการแบ่ง
โปรแกรมออกเป็นงานย่อย ๆ (หรือ
โมดูล) แต่ละงานย่อยจะทำางานอย่าง
ใดอย่างหนึ่งเท่านั้น และไม่ควรจะมี
ขนาดใหญ่จนเกินไป งานย่อยเหล่านี้
เมื่อนำาไปเขียนโปรแกรมในภาษาซีจะ
เป็นการเขียนในลักษณะของฟังก์ชัน

46. 46
รับข้อมูล 2 จำำนวน
จำกผู้ใช้บวกเลข 2 จำำนวนแล้ว
เก็บผลลัพธ์แสดงผลลัพธ์ของ
กำรทำำงำน
โปรแกรมเพื่อบวกเลขสอง
จำำนวนที่รับจำกผู้ใช้ และแสดง
ผลกำรคำำนวณ
ตัวอ
ย่ำง
สำมำรถแบ่งกำรทำำงำนเป็นงำนย่อยได้ด

47. 47
ฟังก์ชันกำรรับ
ข้อมูลฟังก์ชันในกำรบวกเลข
ฟังก์ชันแสดงผลลัพธ์
จะได้ว่ำโปรแกรมประกอบด้วย
ฟังก์ชัน 4 ฟังก์ชันคือ
ฟังก์ชันหลัก
ตัวอย่ำง
(ต่อ)

48. 48
Source
filefunction
function
function
Source
filefunction
function
function
Obje
ct
file
Obje
ct
file
Librar
y file
Execut
e file
com
pile
com
pile
link
link
lin
k
ขั้นตอนกำรสร้ำง
โปรแกรมด้วยภำษำ C

49. 49
4.1 รูปแบบของ
ฟังก์ชัน
ชนิดข้อมูลที่คืนค่ำ ชื่อฟังก์ชัน
( กำรประกำศตัวแปร )
{
กำรประกำศตัวแปร
ภำยในฟังก์ชัน;
คำำสั่ง;
return (ค่ำข้อมูลที่
int , char , float ,
double ฯลฯ
แบบที่ 1

50. 50
รูปแบบของ
ฟังก์ชัน (ต่อ)
void ชื่อฟังก์ชัน ( กำรประกำศ
ตัวแปร )
{
กำรประกำศตัวแปรภำยใน
ฟังก์ชัน;
คำำสั่ง;
}
แบบที่ 2

51. 51
ตัวอย่ำง
4.1
แสดงกำรทำำงำนของ
โปรแกรมกำรบวก
เลขจำำนวนจริง 2 จำำนวน
ที่รับจำกผู้ใช้#include <stdio.h>
double InputDouble ( )
{
double x;
printf ( “nInput real
value : “ );
scanf ( “%.2f ”, &x );
return ( x );
}

52. 52
ตัวอย่ำง
4.1 (ต่อ)
double SumDouble ( double
x, double y )
{
return ( x + y );
}
void PrintOut ( double x )
{
printf ( “n Result of
sum is : %.2f”, x );

53. 53
ตัวอย่ำง
4.1 (ต่อ)
void main ( )
{
double a1, a2,
sumVal;
a1 = InputDouble( );
a2 = InputDouble( );
sumVal = SumDouble
( a1, a2 );

54. 54
4.2 กำรประกำศโพรโท
ไทป์ของฟังก์ชัน
กำรประกำศโปรโตไทป์เป็น
สิ่งจำำเป็นในภำษำซีเนื่องจำก
ภำษำซีเป็นภำษำในลักษณะที่
ต้องมีกำรประกำศฟังก์ชันก่อนจะ
เรียกใช้ฟังก์ชันนั้น (Predefined
Function)

55. 55
จำกตัวอย่ำงที่ 4.1 จะเห็นว่ำ
ฟังก์ชัน main ( ) จะอยู่ใต้ฟังก์ชัน
อื่น ๆ ที่มีกำรเรียกใช้ เป็นลักษณะ
ที่ต้องประกำศฟังก์ชันที่ต้องกำร
เรียกใช้ก่อนจำกเรียกใช้ฟังก์ชัน
นั้น แต่หำกต้องกำรย้ำยฟังก์ชัน
main ( ) ขึ้นไปไว้ด้ำนบน จะต้องมี
กำรประกำศโปรโตไทป์ของฟังก์ชัน
ที่ต้องกำรเรียกใช้ก่อนเสมอ

56. 56
#include <stdio.h>
double InputDouble ( );
double SumDouble
( double , double );
void PrintOut ( double );
ตัวอย่ำง
4.2
แสดงกำรทำำงำนของ
โปรแกรมกำรบวก
เลขจำำนวนจริง 2 จำำนวน
ที่รับจำกผู้ใช้ ในลักษณะ
ที่มีกำรประกำศโปรโต
ไทป์

57. 57
void main ( )
{
double a1, a2, sumVal;
a1 = InputDouble( );
a2 = InputDouble( );
sumVal = SumDouble (
a1, a2 );
PrintOut ( sumVal );
}
ตัวอย่ำง
4.2 (ต่อ)

58. 58
จะเห็นว่ำในโปรโตไทป์ไม่มี
กำรประกำศชื่อตัวแปร มีแต่กำร
เขียนประเภทของตัวแปรไว้ภำยใน
เป็นกำรช่วยให้คอมไพเลอร์
สำมำรถตรวจสอบจำำนวนของ
ตัวแปร ประเภทของตัวแปร
ประเภทของกำรคืนค่ำ ภำยใน
โปรแกรมว่ำมีกำรเรียกใช้งำนสิ่ง
ต่ำง ๆ เกี่ยวกับฟังก์ชันนั้นถูกต้อง

59. 59
4.3 กำรเรียกใช้
ฟังก์ชัน
กำรเรียกใช้ฟังก์ชันที่มีกำร
คืนค่ำ จะใช้รูปแบบดังต่อไปนี้
ค่ำที่รับ = ฟังก์ชัน
(อำร์กิวเมนต์)

60. 60
a1 =a1 =
InputDouble ( );InputDouble ( );
ใช้คู่กับโปรโต
ไทป์
doubledouble
InputDouble ( );InputDouble ( );
ตัวอ
ย่ำงa1 ต้องมีชนิดเป็น double เนื่องจำกค่ำที่จ
คืนกลับมำจำกฟังก์ชันมีชนิดเป็น doub

61. 61
sumVal =sumVal =
SumDouble (a1,a2 );SumDouble (a1,a2 );
ใช้คู่กับโปรโตไทป์
double InputDoubledouble InputDouble
( );( );
ตัวอ
ย่ำง
a1 และ a2 ต้องมีชนิดเป็น double
เพื่อให้ตรงกับชนิดตัวแปรของอำร์กิวเม
ที่ประกำศในโปรโตไทป์

62. 62
PrintOut( sumVal )PrintOut( sumVal )
;;
ใช้คู่กับโปรโต
ไทป์
void PrintOutvoid PrintOut
( double );( double );
ตัวอ
ย่ำง
ประกำศให้รู้ว่ำฟังก์ชันนี้ไม่มีกำรคืนค่ำ

63. 63
4.4 ขอบเขต
( Scope)
กำรทำำงำนของโปรแกรม
ภำษำซีจะทำำงำนที่ฟังก์ชัน main (
) ก่อนเสมอ เมื่อฟังก์ชัน main ( )
เรียกใช้งำนฟังก์ชันอื่น ก็จะมีกำร
ส่งคอนโทรล (Control) ที่ควบคุม
กำรทำำงำนไปยังฟังก์ชันนั้น ๆ
จนกว่ำจะจบฟังก์ชัน หรือพบคำำสั่ง
return

64. 64
เมื่อมีกำรเรียกใช้งำนฟังก์ชันจะ
มีกำรจองพื้นที่หน่วยควำมจำำ
สำำหรับตัวแปรที่ต้องใช้ภำยใน
ฟังก์ชันนั้น และเมื่อสิ้นสุดกำร
ทำำงำนของฟังก์ชันก็จะมีกำรคืน
พื้นที่หน่วยควำมจำำส่วนนั้นกลับ
สู่ระบบ กำรใช้งำนตัวแปรแต่ละ
ตัวจะมีขอบเขตของกำรใช้งำน
ขึ้นอยู่กับตำำแหน่งที่ประกำศ

65. 65
a1
a2
sum
Val
mai
n ( )
xInputDou
ble ( )
a1 =a1 =
InputDouble( );InputDouble( );
ตัวอ
ย่ำง
step1step1
จำกตัวอย่ำง 4.1 และ 4.2
สำมำรถแสดงขอบเขต
กำรทำำงำนได้ดังนี้

66. 66
a1
a2
sum
Val
mai
n ( )
xInputDou
ble ( )
a2 =a2 =
InputDouble( );InputDouble( );
ตัวอย่ำ
ง (ต่อ)
step2step2

67. 67
a1
a2
sum
Val
mai
n ( )
xsumDou
ble ( )
sumVal=SumDouble(a1,a2)sumVal=SumDouble(a1,a2)
ตัวอย่ำ
ง (ต่อ)
Step3Step3
y

68. 68
a1
a2
sum
Val
mai
n ( )
xPrintSum (
)
PrintSum(sumVal);PrintSum(sumVal);
ตัวอย่ำ
ง (ต่อ)
step4step4

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

70. 70
นอกจำกนี้สำมำรถประกำศตัวแปร
ไว้ที่ภำยนอกฟังก์ชันบริเวณส่วน
เริ่มของโปรแกรมจะเรียกว่ำ
ตัวแปรโกลบอลตัวแปรโกลบอล (Global Variable)(Global Variable)
ซึ่งเป็นตัวแปรที่สำมำรถเรียกใช้ที่
ตำำแหน่งใด ๆ ในโปรแกรมก็ได้
ยกเว้นในกรณีที่มีกำรประกำศ
ตัวแปรที่มีชื่อเดียวกันตัวแปร
โกลบอลภำยในบล็อกหรือฟังก์ชัน

71. 71
#include <stdio.h>
int x;
void func1 ( )
{
x = x + 10;
printf ( “func1 -> x :
%dn”, x );
}
ตัวอย่ำง
4.3
แสดงกำรทำำงำนของ
โปรแกรมในลักษณะที่มี
ตัวแปรโกลบอล แสดง
ขอบเขตกำรใช้งำนของ
ตัวแปรภำยในโปรแกรม

72. 72
void func2 ( int x )
{
x = x + 10;
printf ( “func2 -> x :
%dn”, x );
}
void func3 ( ) {
int x=0;
x = x + 10;
printf ( “func3 -> x :
%dn”, x );
ตัวอย่ำง
4.3 (ต่อ)

73. 73
void main ( )
{
x = 10;
printf ( “main (start) -> x :
%dn”, x );
func1 ( );
printf ( “main (after func1) ->
x : %dn”, x ); func2 ( x );
printf ( “main (after func2) ->
x : %dn”, x); func3 ( );
printf ( “main (after func3) ->
ตัวอย่ำง
4.3 (ต่อ)

74. 74
main (start) -> x : 10
func1 -> x : 20
main (after func1) -> x : 20
func2 -> x : 30
main (after func2) -> x : 20
func3 -> x : 10
main (after func3) -> x : 20
ตัวอย่ำง
4.3 (ต่อ) ผลกำรทำำงำน

75. 75
ข้อมูลแบบโครงสร้ำงและ
ยูเนียน
(Structures and Unions)

76. 76
5.1 ควำมรู้ทั่วไปเกี่ยวกับโครงสร้ำง
(0,0
)
(4,3)
หำกต้องกำรเก็บข้อมูลจุดบนแกนโคออดิเนท
จะประกอบไปข้อมูลแกน x และ y เป็น
ข้อมูลจำำนวนเต็มประเภท int ประเภทข้อมูล
ที่ใช้ได้แก่ประเภทข้อมูลแบบโครงสร้ำง
สำมำรถประกำศประเภท
ข้อมูลที่ใช้ดังนี้

77. 77
struct point {
int
x;
int
y;
};
กำรประกำศ ประเภทข้อมูลประเภทข้อมูล
แบบโครงสร้ำง
Mem
ber
หมำยเหตุ กำรประกำศชื่อสมำชิกภำยใน
struct จะใช้ชื่อใดก็ได้อำจจะซำ้ำกับชื่อ
ตัวแปรที่อยู่ภำยนอก struct แต่ชื่อที่อยู่
ภำยใน struct เดียวกันห้ำมประกำศชื่อซำ้ำ

78. 78
struct point {
int
x;
int
y;
} x, y , z;
กำรประกำศ ตัวแปรข้อมูลตัวแปรข้อมูล
แบบโครงสร้ำง
หมำยเหตุ จะเห็นว่ำชื่อของ struct จะ
ประกำศหรือไม่ก็ได้ หำกไม่มีกำร
ประกำศจะไม่สำมำรถนำำ struct นั้นกลับ
แบบที่ 1

79. 79
struct point {
int x;
int y;
};
struct point
x,y,z
แบบที่ 2 กำร
ประกำ
ศแบบ
ข้อมูล
โครงส
ร้ำงกำร
ประกำ
ศ
ตัวแปร
ข้อมูล

80. 80
struct point pt =
{320,200};
กำรกำำหนดค่ำเริ่มต้นให้กับตัวแปร
ข้อมูลแบบโครงสร้ำง
struct_name.membe
r
กำรอ้ำงถึงสมำชิกภำยในตัวแปร
ข้อมูลแบบโครงสร้ำง

81. 81
เมื่อต้องกำรอ้ำงถึงสมำชิกภำยใน
struct
ว่ำอยู่ตรงกับจุดใดบนแกนโคออดิ
เนทจะใช้
printf ( “%d, %d”, pt.x,
pt.y );
หรือหำกต้องกำรคำำนวณระยะทำง
จะว่ำห่ำงจำกจุดเริ่มต้น (0, 0)
ตัวอย่
ำง

82. 82
หมำยเหตุ สมำชิกของข้อมูล
ประเภท struct อำจจะเป็นตัวแปร
ประเภทใดก็ได้ ทั้งข้อมูลพื้นฐำน
และประเภทข้อมูลอื่น ๆ เช่น อำเรย์
และยังประกำศ ตัวแปรของ
ข้อมูลประเภท struct ได้อีกด้วยตัวอย่
ำง
pt
2pt
1
หำกต้องกำร
เก็บข้อมูลของ
สี่เหลี่ยมดังรูป
สำมำรถทำำกำร
ประกำศ

83. 83
struct
point pt1;
struct
point pt2;
};
struct rect
screen;
int co_x;
co_x =
กำร
ประกำศ
แบบ
ข้อมูล
โครงสร้
ำง
กำร
ประกำศ
ตัวแปร
ข้อมูล
แบบ
โครงสร้ำ
ง
กำรอ้ำง
ถึงสมำชิก

84. 84
5.2 กำรเก็บข้อมูลแบบโครงสร้ำง
กำรเก็บข้อมูลแบบโครงสร้ำง
ภำยในหน่วยควำมจำำจะเก็บตำม
ลำำดับที่มีกำรประกำศสมำชิกของ
ข้อมูลนั้น โดยทั่วไปข้อมูลแบบ
โครงสร้ำงจะประกอบขึ้นจำกข้อมูล
หลำย ๆ ชนิด และข้อมูลแต่ละ
ชนิดมักจะมีกำรจองพื้นที่ใช้งำนแต่
ต่ำงกัน เนื่องจำกกำรจองพื้นที่
หน่วยควำมจำำในระบบส่วนใหญ่จะ

85. 85
struct
alignment
{
int
num1;
char
ch;
int
num2;
ตัวอ
ย่ำง
nu
m1
c
h
nu
m2
mem
ber
0 2 3 4
Byte
Offset
จะเห็นว่ำ num2 จะไม่สำมำรถใช้พื้นที่ที่ติดกับ
ch ได้
เนื่องจำก num2 เป็นข้อมูลประเภทเลขจำำนวนต้อง
ใช้พื้นที่ที่มี
แอดเดรสหำรด้วย 2 หรือ 4 ลงตัว ทำำให้เกิดที่ว่ำงที่
ไม่สำมำรถ

86. 86
5.3 กำรใช้ข้อมูลแบบโครงสร้ำงกับ
ฟังก์ชัน
กำรทำำงำนของตัวแปรที่เป็นประเภท
โครงสร้ำงสำมำรถทำำงำนต่ำง ๆ ได้
เช่นเดียวกับตัวแปรอื่น ๆ ยกเว้นกำร
เปรียบเทียบตัวแปร struct กับตัวแปร
struct เนื่องจำกข้อมูลของตัวแปร
struct จะเก็บอยู่ในตัวแปรที่เป็นสมำชิก
ของ struct กำรเปรียบเทียบจึงต้องทำำ
ผ่ำนตัวแปรที่เป็นสมำชิกของ struct
เท่ำนั้น กำรใช้งำนตัวแปร struct กับ

87. 87
ตัวอย่ำ
ง 5.1
ฟังก์ชันใช้ในกำรกำำหนดค่ำให้
กับตัวแปร struct
struct point makepoint
( int x, int y )
{
struct point temp;
temp.x = x;
temp.y = y;
return temp;
}
หมำยเหตุ ตัวอย่ำงนี้แสดงฟังก์ชันที่ทำำกำรส่งค่ำ
กลับเป็นรูปแบบโครงสร้ำง

88. 88
กำรเรียกใช้งำนฟังก์ชัน
struct rect screen;
struct point middle;
struct point makepoint ( int, int );
screen.pt1 = makepoint ( 0, 0 );
screen.pt2 = makepoint ( XMAX,
YMAX );
middle = makepoint ((screen.pt1.x
+ screen.pt2.x) / 2,
(screen.pt1.y +
screen.pt2.y) / 2 );

89. 89
ตัวอย่ำ
ง 5.2
ฟังก์ชันกำรบวก x และ y ของ
จุด 2 จุด และคืนค่ำผลของกำร
บวกเป็น struct
struct point addpoint(struct point
p1, struct point p2)
{
p1.x += p2.x;
p1.y += p2.y;
return p1;
}
หมำยเหตุ ตัวอย่ำงนี้แสดงกำรส่งอำร์กิวเมนท์
แบบ struct ให้กับฟังก์ชัน

90. 90
ตัวอย่ำ
ง 5.3
ฟังก์ชันกำรหำว่ำจุดอยู่ในพื้นที่
สี่เหลี่ยมหรือไม่
int pinrect ( struct point p,
struct rect r )
{
return p.x >= r.pt1.x && p.x <
r.pt2.x &&
p.y >= r.pt1.y && p.y <
r.pt2.y;
}
หมำยเหตุ ตัวอย่ำงนี้เป็นกำรหำว่ำจุดที่ระบุ
อยู่ในพื้นที่สี่เหลี่ยมหรือไม่ โดยส่งค่ำจุด
และพื้นที่สี่เหลี่ยมเป็นอำกิวเมนท์ให้กับ
ฟังก์ชัน หำกจุดอยู่ในพื้นที่สี่เหลี่ยมจะคืน
ค่ำ1 แต่หำกจุดอยู่นอกพื้นที่สี่เหลี่ยมจะคืน

91. 91
ตัวชี้และอาร์เรย์
(Pointer and Array)

92. 92
รูปที่ 6.1 การแทนข้อมูลในหน่วยความจำา
ของตัวแปรประเภทพื้นฐาน
int
i;
i 40
040
240
4
i =
10;
i 40
040
240
4
1
0
int i;
i = 10;
6.1 ตัวชี้กับแอดเดรส (Pointers
and Address)

93. 93
p
i
3
6
0
4
0
0
4
0
0
1
0
p
i1
0
p
i1
0
รูปที่ 6.2 การแทนข้อมูลในหน่วยความจำา
ของตัวแปรประเภทตัวชี้

94. 94
6.2 การประกาศตัวแปรประเภทตัวชี้
การประกาศตัวแปรประเภทพอยน์เตอร์
จะใช้ Unary Operator ** ซึ่งมีชื่อ
เรียกว่า Indirection หรือ
Dereferencing Operator โดยจะต้อง
ประกาศประเภทของตัวแปรพอยน์เตอร์
ให้สอดคล้องกับประเภทของตัวแปรที่
เราต้องการ (ยกเว้นตัวแปรพอยน์เตอร์
ประเภท void ที่สามารถชี้ไปยังตัวแปร
ประเภทใดก็ได้)

95. 95
int *ip;
เป็นการประกาศตัวแปร ip ให้เป็น
ตัวแปรพอยน์เตอร์ที่ชี้ไปยังตัวแปร
ประเภท int
double *dp,
atof(char *);
เป็นการประกาศตัวแปร dp เป็นตัว
แปรพอยน์เตอร์ที่ชี้ไปยังตัวแปร
ตัวอย่
าง

96. 96
6.3 การกำาหนดค่าและการอ่านค่าตัว
แปรประเภทตัวชี้
การกำาหนดค่าให้กับตัวแปรพอยน์
เตอร์จะเป็นการกำาหนดแอดเดรส
ของตัวแปรที่มีประเภทสอดคล้อง
กับประเภทของตัวแปรพอยน์เตอร์
เท่านั้น โดยการใช้ Unary
Operator && เป็นโอเปอเรเตอร์ที่
อ้างถึงแอดเดรสของออปเจ็ค
(Object) ใด ๆ

97. 97
int x = 1, y = 2;
int *ip, *iq;
ip = &x;
y = *ip;
*ip = 0;
y = 5;
ip = &y;
*ip = 3;
iq = ip;
รูปที่ 6.3 การกำาหนดค่าและการอ่าน
ค่าตัวแปรตัวชี้

98. 98
400
500
402
502
x
ip
y
iq
1
2 int x = 1, y
= 2;
int *ip, *iq;

99. 99
x
ip
400
500
y 402
502iq
1
2
400
ip =
&x;

100. 100
x
ip
400
500
y 402
502iq
1
1
400
y =
*ip;

101. 101
x
ip
40
0
50
0
y 40
2
50
2
iq
0
1
400
*ip =
0;

102. 102
x
ip
400
500
y 402
502iq
0
5
400
y = 5;

103. 103
x
ip
400
500
y 402
502iq
0
5
402
ip =
&y;

104. 104
x
ip
400
500
y 402
502iq
0
3
402
*ip =
3;

105. 105
x
ip
400
500
y 402
402 502iq
0
3
402
iq =
ip;

106. 106
6.4 ตัวชี้และอาร์กิวเมนท์ของ
ฟังก์ชัน
(Pointer and Function
Arguments)
เนื่องจากภาษาซีมีการส่งอากิวเมนต์
ให้กับฟังก์ชันแบบ By Value และ
ฟังก์ชันสามารถคืนค่า (return) ค่า
ได้เพียงหนึ่งค่า หากต้องการให้
ฟังก์ชันมีการเปลี่ยนแปลงค่าและคืน
ค่ากลับมายังฟังก์ชันที่เรียกใช้
มากกว่าหนึ่งค่าจะต้องนำาพอยน์
เตอร์เข้ามาช่วย

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

108. 108
ตัวอย่าง
6.1 โปรแกรมตัวอย่างการสลับ
ค่าตัวแปร 2 ตัว
โดยผ่านฟังก์ชัน จะแสดง
การส่ง
อาร์กิวเมนต์ในเป็นพอยน์
เตอร์
#include
<stdio.h>
void swap (int
*, int *);

109. 109
void main ( )
{
int x = 5, y = 10;
printf(“Before swap : x =
%d”, x, “, y = %dn”, y);
swap ( &x, &y);
printf(“After swap : x = %d”,
x, “, y = %dn”, y);
}
ตัวอย่าง 6.1
(ต่อ)

110. 110
void swap (int *px, int
*py)
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}
ตัวอย่าง 6.1
(ต่อ)

111. 111
อาร์กิวเมนท์ที่เป็นประเภท
พอยน์เตอร์จะช่วยให้ฟังก์ชัน
สามารถเปลี่ยนค่าให้กับตัวแปรที่
ส่งเข้ามาได้ เนื่องจากอาร์กิวเม
นท์นั้นจะเก็บแอดเดรสของ
ตัวแปรที่ส่งเข้ามา เมื่อมีการ
เปลี่ยนแปลงค่าของอาร์กิวเมนท์
ผ่าน Dereferencing Operator (
* ) ค่าของตัวแปรที่ส่งเข้ามาจะ

112. 112
รูปที่ 6.4 แสดงความสัมพันธ์ของการส่งอาร์กิวเมนท์
แบบพอยน์เตอร์กับฟังก์ชัน
x
y
in
main (
)
p
xp
y
in
swap (
)

113. 113
6.5 ตัวชี้กับอาร์เรย์ (Pointer and
Arrays)
อาร์เรย์เป็นประเภทข้อมูลที่เก็บ
ชุดของข้อมูลประเภทเดียวกัน
มักใช้กับการทำางานที่ต้องทำางาน
กับตัวแปรชนิดเดียวกันหลายตัวที่
มีการทำางานเหมือนกัน เช่น
คะแนนของนักศึกษาภายในห้อง
20 คน เป็นต้น อาร์เรย์ในภาษาซี
จะนำาหลักการของพอยน์เตอร์เข้า
มาใช้ การทำางานใด ๆ ของ

114. 114
int table[10];
เป็นการกำาหนดอาร์เรย์ชื่อ table
เป็นอาร์เรย์ประเภท int ที่มีสมาชิก
ทั้งหมด 10 ตัว ตั้งแต่ table[0],
table[1], table[2], ... , table[9]
สมาชิกภายในอาร์เรย์จะเริ่มที่ 0
เสมอ และสมาชิกตัวสุดท้ายจะอยู่ที่
ตำาแหน่งของขนาดที่ประกาศไว้ลบ
การประกาศการประกาศ
อาร์เรย์อาร์เรย์

115. 115
รูปที่ 6.5 แสดงภาพจำาลองของ
อาร์เรย์ขนาดสมาชิก 10 ตัว
tabl
e[0]
tabl
e[1]
tabl
e[2]
tabl
e[9]
tab
le

116. 116
จะใช้ระบบดัชนีโดยผ่าน
เครื่องหมาย [ ] เช่น
อ้างถึงสมาชิกตัวที่ 3 ของอาร์เรย์
ด้วย table[2] เป็นต้น การใช้งาน
สมาชิกของอาร์เรย์สามารถใช้งาน
ได้เหมือนตัวแปรพื้นฐานทั่วไป
การอ้างถึงสมาชิกในการอ้างถึงสมาชิกใน
อาร์เรย์อาร์เรย์

117. 117
sumThird = table[0] +
table[1] + table[2];
table[0] = 5;
if ( a[0] > a[9] )
printf (“First is greater
than lastn” );
ตัวอ
ย่าง

118. 118
เราสามารถอ้างถึงสมาชิก
ทุกตัวภายในอาร์เรย์อย่าง
อิสระ ภายในขอบเขตของ
ขนาดที่ได้ประกาศอาร์เรย์ไว้
แต่การใช้อาร์เรย์มักจะ
เป็นการเข้าถึงสมาชิกใน
ลักษณะทั่วไปโดยใช้ตัวแปร
ประเภท int มาช่วย

119. 119
สมมติให้ i, j, k เป็นตัวแปรประเภท
int
for (int k = 0; k < 9; k++)
printf (“Value at %d =
%dn”, k+1, table[k]);
table[i + j] = 0;
table[7 – table[j]] = j;
ตัวอ
ย่าง

120. 120
ในภาษาซีจะไม่มีการกำาหนด
ให้ตรวจสอบขอบเขตของอาร์เรย์
โปรแกรมเมอร์จะต้องพยายาม
เขียนโปรแกรมที่เกี่ยวข้องกับ
สมาชิกของอาร์เรย์ภายในขอบเขต
ที่ประกาศอาร์เรย์ไว้ หากมีการ
อ้างอิงถึงสมาชิกอาร์เรย์นอก
ขอบเขตที่ได้ระบุไว้ เช่น table[12]
สิ่งที่ต้องระวัง

121. 121
ตัวอย่าง
6.2
ให้อ่านค่าของจำานวนเต็ม
5 จำานวนจากคีย์บอร์ด
และแสดงผลในลำาดับที่
กลับกัน
# include <stdio.h>
#define SIZE 5
main ( ) {
int k;
int table[SIZE];
for (k = 0; k < SIZE; k++)
scanf (“%d”, &table[k]);
for (k = SIZE-1; k >= 0; k--)
printf (“%dn”, table[k]);
}

122. 122
สมาชิกของอาร์เรย์อาจเป็น
ประเภทข้อมูลพื้นฐานใด ๆ ก็ได้
หรืออาจเป็นข้อมูลประเภท
Enumeration เช่น
#define TSIZE 10
#define NAMESIZE 20
#define ADDRSIZE 30
enum month { JAN, FEB,
MAR, APR, MAY,
JUN, JUL, AUG,

123. 123
typedef enum month
Month;
int age[TSIZE];
float size[TSIZE+1];
Month date[8];
char name[NAMESIZE],
address[ADDRSIZE];

124. 124
6.6 การใช้ตัวชี้กับอาร์เรย์
การทำางานใด ๆ ของอาร์เรย์สามารถ
ใช้พอยน์เตอร์เข้ามาช่วย ซึ่งจะ
ทำาให้มีความเร็วในการทำางานสูงขึ้น
สมมติว่ามีอาร์เรย์ a และพอยน์เตอร์
pa ดังนี้
int a[10];
int *pa;
กำาหนดให้พอยน์เตอร์ pa ชี้ไปยัง
อาร์เรย์ a ด้วยคำาสั่ง
pa = &a[0]; /* หรือใช้คำา

125. 125
รูปที่ 6.6 แสดงตัวชี้ชี้ไปยัง
แอดเดรสเริ่มต้นของอาร์เรย์
a[0] a[1] a[2] a[9]
a
p
a

126. 126
การนำาไปใช้งานจะสามารถ
อ่านค่าอาร์เรย์ผ่านพอยน์เตอร์ได้
ดังนี้
x = *pa;
จะเป็นการกำาหนดค่าให้ x มีค่า
เท่ากับ a[0] การเลื่อนไปอ่านค่า
สมาชิกตำาแหน่งต่าง ๆ ของ
อาร์เรย์ผ่านทางพอยน์เตอร์
สามารถทำาได้โดยการเพิ่มค่า
พอยน์เตอร์ขึ้น 1 เพื่อเลื่อนไปยัง

127. 127
กรณีที่ pa ชี้อยู่ที่ a[0] คำา
สั่ง
pa+1;
จะเป็นการอ้างถึงแอดเดรส
ของ a[1] หากเป็น pa+i
เป็นการอ้างถึงแอดเดรส a[i]
หากต้องการอ้างถึงข้อมูล
ภายในของสมาชิกของ

128. 128
รูปที่ 6.7 แสดงการอ้างถึงตำาแหน่ง
ในอาร์เรย์ผ่านตัวชี้
a[0
]
a[1
]
a[2
]
a[9
]
a
p
a
pa
+1
pa
+2

129. 129
การสั่งให้บวก 1 หรือบวก i หรือ
ลบ i เป็นเหมือนการเลื่อนไปยังสมาชิก
ของอาร์เรย์ตำาแหน่งที่ต้องการ
เนื่องจากประเภทของข้อมูลแต่ละ
ประเภทของอาร์เรย์ เช่น int, float,
double และอื่น ๆ มีขนาดของข้อมูลที่
ต่างกัน ทำาให้ขนาดของสมาชิก
ภายในอาร์เรย์แต่ละประเภทมีขนาด
แตกต่างกันด้วย การสั่งให้บวกหรือลบ
ด้วยจำานวนที่ต้องการนั้นจะมีกลไกที่ทำา

130. 130
นอกจากนี้ยังสามารถใช้พอยน์
เตอร์แทนอาร์เรย์ การอ้างโดยใช้
a[i] สามารถใช้ *(a+i) เนื่องจาก
ทุกครั้งที่อ้างถึง a[i] ภาษาซีจะทำา
หน้าที่แปลงเป็น *(a+i) เพราะ
ฉะนั้นการเขียนในรูปแบบใดก็ให้
ผลลัพธ์ในการทำางานเช่นเดียวกัน
และการอ้างถึงแอดเดรส เช่น
&a[i] จะมีผลเท่ากับการใช้ a+i

131. 131
ในลักษณะเดียวกันการใช้งา
นพอยน์เตอร์ก็สามารถใช้คำาสั่งใน
ลักษณะอาร์เรย์ก็ได้ เช่น การอ้างถึง
*(pa+i) สามารถเขียนด้วย pa[i] ก็ได้
ผลเช่นเดียวกัน
สิ่งที่แตกต่างกันของอาร์เรย์และ
พอยน์เตอร์ คือ พอยน์เตอร์เป็นตัวแปร
แต่อาร์เรย์ไม่ใช่ตัวแปร สมมติให้ a
เป็นอาร์เรย์และ pa เป็นพอยน์เตอร์
การอ้างถึง pa = a หรือ pa++ จะ

132. 132
เมื่อมีการส่งชื่อของอาร์เรย์
ให้แก่ฟังก์ชัน จะเป็นการส่ง
ตำาแหน่งแอดเดรสของสมาชิกตัว
แรกของอาร์เรย์ให้แก่ฟังก์ชัน
ดังนั้นพารามิเตอร์ในฟังก์ชันนั้น
จะเป็นตัวแปรประเภทพอยน์เตอร์

133. 133
ตัวอย่าง
6.3
ฟังก์ชันที่รับพารามิเตอร์
เป็นพอยน์เตอร์ โด
ยอาร์กิวเมนท์ที่ส่งมาเป็น
อาร์เรย์
int strlen (char *s)
{
int n;
for ( n = 0; *s != ‘0’;
s++ )
n++;
return n;
}

134. 134
จะเห็นว่า s เป็นพอยน์เตอร์ ใน
ฟังก์ชันจะมีการตรวจสอบข้อมูลว่ามี
‘ค่าเท่ากับ 0’ หรือไม่ และมีการเลื่อน
ตำาแหน่งทีละ 1 ค่า (นับว่าข้อมูลมี
ความยาวเพิ่มขึ้นทีละ1) โดยใช้ s++
การเรียกใช้ฟังก์ชัน strlen สามารถ
ทำาได้หลายลักษณะ
strlen (“hello world”); /*
string constant */
strlen (array); /*

135. 135
นอกจากนี้ยังอาจจะประกาศ
พารามิเตอร์ภายในฟังก์ชัน strlen
ได้ใน 2 ลักษณะ คือ char *schar *s แบบ
ในตัวอย่าง หรืออาจจะใช้ charchar
s[ ]s[ ] ก็ได้ โดยทั่วไปจะใช้ใน
ลักษณะแรก เพราะช่วยในรู้ได้
ทันทีว่า s เป็นตัวแปรพอยน์เตอร์
และยังสามารถส่งส่วนใดส่วนของ
อาร์เรย์ให้แก่ฟังก์ชันก็ได้ โดยไม่

136. 136
f (&a[2])
หรือ f (a+2)
เป็นการส่งแอดเดรสของ
สมาชิก a[2] ให้กับฟังก์ชัน f
การประกาศฟังก์ชัน f สามารถ
ทำาได้โดยการประกาศ
f (int arr[ ])
{ ......... }
ตัวอ
ย่าง

137. 137
6.7 การคำานวณกับแอดเดรส
ให้ p เป็นพอยน์เตอร์ชี้ไปยัง
อาร์เรย์ใด ๆ คำาสั่ง p++ เป็นการ
เลื่อน p ไปยังสมาชิกถัดไป และคำา
สั่ง p += i เป็นการเลื่อนพอยน์
เตอร์ไป i ตำาแหน่งจากตำาแหน่ง
ปัจจุบัน นอกจากนี้ยังสามารถใช้
เครื่องหมายความสัมพันธ์
(Relational Operator) เช่น ==, !

138. 138
p < q
จะเป็นจริงเมื่อ p ชี้ไปที่สมาชิกที่
อยู่ก่อนหน้าสมาชิกที่ q ชี้อยู่ การ
เปรียบเทียบในลักษณะจะใช้ได้
ต่อเมื่อ p และ q ชี้ไปที่อาร์เรย์
เดียวกันเท่านั้น
นอกจากนี้ยังสามารถใช้การ
ลบหรือการบวกกับพอยน์เตอร์ได้
เช่นเดียวกัน แต่สิ่งที่ควรระวังคือ

139. 139
ตัวอย่าง
6.3
ฟังก์ชัน strlen( ) ปรับปรุง
ให้กระชับขึ้น
int strlen (char *s)
{
char *p = s;
while (*p != ‘0’)
p++;
return p-s;
}

140. 140
เนื่องจาก s ชี้อยู่ที่
ตำาแหน่งเริ่มต้น โดยมี p ชี้ไปที่
s เช่นเดียวกัน แต่จะมีการ
เลื่อน p ไปทีละหนึ่งตำาแหน่ง
จนกว่าค่าที่ตำาแหน่งที่ p ชี้อยู่
‘จะเท่ากับ 0’ เมื่อนำา p ค่า
สุดท้ายมาลบกับ s ที่ตำาแหน่ง
เริ่มต้นก็จะได้ความยาวของ

141. 141
6.8 ตัวชี้ตัวอักษรและฟังก์ชัน
(Character Pointer and
Function)
การทำางานกับข้อความหรือ
ที่เรียกว่า สตริง (String)
เป็นการใช้ข้อมูลตัวอักษรหลาย
ๆ ตัว หรืออาร์เรย์ของข้อมูล
ประเภท char หรืออาจจะใช้
พอยน์เตอร์ชี้ไปยังข้อมูล
ประเภท char การทำางานกับค่า

142. 142
“I am a string”
เมื่อมีการใช้ค่าคงที่สตริงจะมีการ
พื้นที่ในหน่วยความจำาเท่ากับความ
ยาวของค่าคงที่สตริงบวกด้วย 1
เนื่องจากลักษณะการเก็บข้อมูล
ประเภทข้อความในหน่วยความจำา
จะมีการปะตัวอักษร null ‘หรือ 0’
ต่อท้ายเสมอเพื่อให้รู้ว่าเป็นจุดสิ้น
สุดของข้อมูล การจองพื้นที่ดังกล่าว
ตัวอย่
าง

143. 143
รูปที่ 6.8 แสดงแบบจำาลองการเก็บ
ข้อมูลประเภท สตริงในหน่วย
ความจำา
I a m a s t r i n g 0

144. 144
ค่าคงที่สตริงที่พบเห็นได้
เสมอได้แก่ข้อความที่ใช้ใน
ฟังก์ชัน printf ( ) เช่น
printf ( “Hello,
worldn” );
ฟังก์ชัน printf ( ) จะรับ
พารามิเตอร์เป็นพอยน์เตอร์ชี้ไป
ยังแอดเดรสของข้อมูลที่ตำาแหน่ง

145. 145
ในการเขียนโปรแกรมจะ
สามารถใช้พอยน์เตอร์ชี้ไปค่า
คงที่สตริงใด ๆ ก็ได้ เช่น
char *pmessage =
“Hello, world”;
pmessage จะเป็นพอยน์
เตอร์ประเภท char ชี้ไปที่
อาร์เรย์ของตัวอักษร จะแตก

146. 146
ลักษณะของอาร์เรย์เช่น
amessage จะมีการจองพื้นที่ใช้
กับอาร์เรย์ขนาด 13 ตัวอักษร
รวมทั้ง null ส่วนลักษณะของ
พอยน์เตอร์ที่ชี้ไปยังค่าคงที่
สตริง จะมีการจองพื้นที่ให้กับ
ค่าคงที่สตริงขนาด 13 ตัวอักษร
เช่นเดียวกัน แต่จะมีการจอง

147. 147
รูปที่ 6.9 การจองพื้นที่ให้กับอาร์เรย์และตัวชี้
ชี้ไปยังค่าคงที่สตริง
H e l l o , w o r l d 0
H e l l o , w o r l d 0amessage
pmessage

148. 148
void strcpy ( char *s,
char *t )
{
int i=0;
while ( ( s[i] = t[i] ) !=
‘0’ )
i++;
ตัวอย่า
ง 6.5
ฟังก์ชัน strcpy ( ) ทำา
หน้าที่สำาเนาข้อความ
จากตัวแปรหนึ่งไปยังอีก
ตัวแปรหนึ่งเขียนใน
ลักษณะอาร์เรย์

149. 149
void strcpy ( char *s,
char *t )
{
while ( ( *s = *t ) !=
‘0’ ) {
s++;
t++;
ตัวอย่า
ง 6.6
ฟังก์ชัน strcpy ( )
เขียนในลักษณะ
พอยน์เตอร์

150. 150
void strcpy ( char *s,
char *t )
{
while ( ( *s++ = *t++
) != ‘0’ ) ;
}
ตัวอย่า
ง 6.7
ฟังก์ชัน strcpy ( )
เขียนในลักษณะ
พอยน์เตอร์แบบสั้น

151. 151
การประกาศตัวแปรชี้ (pointer)
ชี้ไปยัง structกรณีการส่งอากิวเมนท์เป็นตัวแปร struct จะ
ไม่เหมาะกับ struct
ที่มีขนาดใหญ่ เนื่องจากทุกครั้งที่ส่งตัวแปร
struct จะเป็นการสำาเนา
ตัวแปรตัวใหม่ขึ้นมาในฟังก์ชัน ซึ่งจะทำาให้
ช้าและเปลืองพื้นที่หน่วย
ความจำา เราจะใช้พอยน์เตอร์เข้ามาช่วยแก้
ปัญหานี้
โดยส่งแอดเดรสของตัวแปร struct มายัง
ฟังก์ชันซึ่งรับอากิวเมนท์ เป็นพอยน์เตอร์
อากิวเมนท์จะชี้ไปยังแอดเดรสเริ่มต้นของ

152. 152
ตัวอย่
าง struct point origin, *pp;
pp = &original;
printf ( “origin is (%d, %d)n”,
(*pp).x, (*pp).y );
จะได้ตัวแปร pp ชี้ไปยังข้อมูลแบบ
โครงสร้างชื่อ struct point การ
เขียน *pp จะเป็นการอ้างถึง
โครงสร้าง
การอ้างถึงสมาชิกสามารถการอ้างถึงสมาชิกสามารถ

153. 153
หมายเหตุ สิ่งที่ต้องระวังคือ
(*pp).x จะไม่เหมือนกับ
*pp.x เนื่องจากเครื่องหมาย
. จะมีลำาดับความสำาคัญสูง
กว่า * ทำาจะการแปลความ
หมาย *pp.x จะเหมือนกับ
การอ้าง *(pp.x) ซึ่งจะทำาให้
เกิดความผิดพลาดขึ้น

154. 154
การอ้างถึงสมาชิกอาจเขียนอีก
ลักษณะหนึ่งโดยใช้เครื่องหมาย
-> สมมติ p เป็นพอยน์เตอร์ รูป
แบบการใช้เป็นดังนี้
p->member-of-
structure
จะสามารถแปลงประโยคการ
ใช้พอยน์เตอร์อ้างสมาชิกของ
struct จากตัวอย่างข้างบนได้ว่า

155. 155
หากมีพอยน์เตอร์ชี้ไปยัง struct
rect ดังนี้
struct rect r, *rp = r;
การอ้างถึงสมาชิกต่อไปนี้จะมีผล
เท่ากับการอ้างถึงสมาชิกตัว
เดียวกัน
r.pt1.x
rp->pt1.x
(r.pt1).x
ตัวอย่
าง

156. 156
6.9 ตัวชี้ (pointer) ชี้ไปยัง
โครงสร้าง
(pointer to structures)
พอยน์เตอร์เป็นตัวแปรที่เก็บ
แอดเดรสของตัวแปรอื่น
สามารถใช้ชี้ไปยังข้อมูล
ประเภทใด ๆ การใช้พอยน์
เตอร์ชี้ไปยังโครงสร้างสามารถ
ทำาได้ดังนี้

157. 157
int
day;
int
month;
int
year;
} Date;
Date today;
การ
ประกาศ
แบบ
ข้อมูล
โครงสร้
าง
การ
ประกาศ
ตัวแปร
ข้อมูล
แบบ
โครงสร้า
ง
การ
ประกาศ
ตัวแปร
แบบที่ 1

158. 158
struct date {
int
day;
int
month;
int
year;
} *ptrdate;
แบบที่ 2

159. 159
int
day;
int
month;
int
year;
} Date;
typedef Date
*PtrDate;
การ
ประกาศ
แบบ
ข้อมูล
โครงสร้
าง
การประกาศ
ประเภท
ตัวแปร
pointer ชี้ไป
ยัง
โครงสร้าง
การ
ประกาศ
ตัวแปร
แบบที่ 3

160. 160
การประกาศตัวแปร
ptrdate ทั้ง 3 ลักษณะจะ
สามารถใช้งานได้เหมือนกัน
ทั้งหมด
หากต้องการให้ ptrdate ชี้
ไปยังตัวแปรโครงสร้างสามารถ
ทำาได้ดังนี้
ptrdate = &today;

161. 161
การอ้างถึงสมาชิกของโครงสร้างผ่านตัว
แปรพอยน์เตอร์
ptrdate->day = 7;
if ( ptrdate->day == 31 && ptrdate-
>month == 12 ) .....
scanf ( “%d”, &ptrdate->year );
การอ้างถึงสมาชิกโครงสร้างโดยใช้
เครื่องหมาย ->
(*ptrdate).day = 7;

162. 162
#include <stdio.h>
struct date { /*date template */
int day;
int month;
int year;
};
typedef struct date Date;
typedef Date *PtrDate;
ตัวอย่าง
6.8
โปรแกรมตัวอย่างการใช้ตัว
ชี้ (pointer) ชี้ไปยัง
โครงสร้าง

163. 163
main ( ) {
Date today;
PtrDate ptrdate;
ptrdate = &today;
ptrdate->day = 27;
ptrdate->month = 9;
ptrdate->year = 1985;
printf ( “Today’s date is
%2d/%2d/%4dn”,
ptrdate->day, ptrdate-
ตัวอย่าง 6.8
(ต่อ)

164. 164
นอกจากนี้ยังสามารถทำาการ
กำาหนดค่าเริ่มต้นให้กับตัวแปรแบบ
โครงสร้าง เช่น
Date xmas = { 25, 12,
1986 };
และหากมีการกำาหนดค่าเริ่มต้น
ให้กับสมาชิกของโครงสร้างไม่ครบ
ทุกตัว หากตัวแปรนั้นเป็น external
หรือ static ค่าของสมาชิกที่ขาดไป
จะถูกกำาหนดให้เป็น 0 แต่หากเป็น

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

166. 166
การอ้างโดยใช้คำาสั่งต่าง ๆ
staff อ้างถึงอาเรย์ของ
โครงสร้าง
staff[i] อ้างถึงสมาชิกที่ i ในอา
เรย์
staff[i].forename อ้างถึงชื่อหน้า
ของสมาชิกที่ I ของอาเรย์
staff[i].surname[j] อ้างถึงตัว
อักษรตัวที่ j ในนามสกุล
ของสมาชิกที่ i ของอาเรย์

167. 167
การใช้ข้อมูลสมาชิกแต่ละตัวจะ
อ้างถึงโดยการอ้างผ่านระบบดัชนี
เหมือนอาร์เรย์ทั่วไป เช่น
ฟังก์ชันที่ใช้ในการพิมพ์ชื่อ
สมาชิกคนที่ระบุ จะเรียกใช้โดย
print_person
( staff[k] );
การเรียกใช้งานสมาชิกบางตัว
ในอาร์เรย์ของโครงสร้างผ่าน
ฟังก์ชัน

168. 168
หากต้องการเรียกใช้งานฟังก์ชันที่
ทำางานกับทั้งอาร์เรย์ เช่น การ
เรียกใช้งานฟังก์ชันที่ทำาการเรียง
ลำาดับอาร์เรย์ตามชื่อหน้า จะต้อง
ส่งอาร์เรย์และขนาดของอาร์เรย์ไป
ยังฟังก์ชันนั้น เช่น
sort_forename ( staff,
STAFFSIZE );
การเรียกใช้งานสมาชิกทุกตัว
ในอาร์เรย์ของโครงสร้างผ่าน
ฟังก์ชัน

169. 169
การกำาหนดค่าเริ่มต้นให้กับอาร์เรย์ของ
โครงสร้างสามารถทำาได้โดย
Person staff[ ] = { { “Bloggs”,
“Joe”, MALE, 21 },
{ “Smith”, “John”,
MALE, 30 },
{ “Black”, “Mary”,
FEMALE, 25 } };
การกำาหนดค่าเริ่มต้นให้กับ
อาร์เรย์ของโครงสร้าง

170. 170
6.11 อาร์เรย์แบบหลายมิติ
(Multi-dimensional
Arrays)
จากพื้นฐานที่ผ่านมาเรื่อง
อาร์เรย์จะเป็นลักษณะของอาร์เรย์
มิติเดียว แต่อาร์เรย์อาจจะมี
มากกว่า 1 มิติก็ได้ เช่น ข้อมูล
คะแนนสอบของนักศึกษาแต่ละคน
ภายในชั้นซึ่งแบ่งเป็นคะแนนเก็บ
หลายส่วน จะพบว่าหากต้องการ
เก็บข้อมูลคะแนนสอบของนักศึกษา

171. 171
#define
NUMBER_OF_PAPERS 5
int student
[ NUMBER_OF_PAPERS ];
/* int student[5]; */
5.6 8.5 12.6 24.1 16.0
student[0]student[1]student[2]student[3]student[4]

172. 172
แต่หากเพิ่มเติมว่าให้เก็บ
ข้อมูลคะแนนสอบของ
นักศึกษาทุกคน จะต้องใช้
อาร์เรย์หลายมิติเข้ามา
เกี่ยวข้อง ตัวอย่างเช่นการ
เก็บข้อมูลคะแนนสอบของ
นักศึกษา 2 คนโดยมีคะแนน
สอบของการสอบทั้งสิ้น 5 ครั้ง

173. 173
รูปที่ 6.10 แสดงตัวอย่างการเก็บข้อมูล
คะแนนของ นักศึกษา
ครั้งที่ 1 2 3 4 5
นาย ก
นาย ข
5.6 8.512.624.116.0
6.0 7.215.025.018.0

174. 174
อ้างอิงถึงข้อมูลในอาร์เรย์ 2 มิติ
ะมองอาร์เรย์ 2 มิติในลักษณะที่ประกอบด
w) และคอลัมน์(column) โดยข้อมูลที่อ้าง
ยถึง แถว และข้อมูลถัดมาคือ คอลัมน์
marks[row][column]
row
column
marks[0]
[0]
marks[0]
[1]
marks[0]
[2]
marks[0]
[8]
marks[1]
[0]
marks[1]
[8]
marks[2]
[0]
marks[2]
[8]

175. 175
จากลักษณะความต้องการเก็บ
ข้อมูลดังกล่าวจะต้องเตรียมอาร์เรย์
เพื่อเก็บข้อมูลในลักษณะ 2 มิติ
สามารถประกาศอาร์เรย์ดังนี้
#define NUMBER_OF_PAPERS
5
#define
NUMBER_OF_STUDENTS 50
int

176. 176
แกรมการรับค่าอาร์เรย์ 2 มิติ
ude<stdio.h>
()
oat score[10][3];
t i,j;
intf(“Please put scoren”);
r(i=0;i<10;i++)
or(j=0;j<3;j++)
scanf(“%f”,&score[i][j]);
score[0][0]score[0][1]score[0][2]
score[1][0]score[1][1]score[1][2]
score[9][0]score[9][1]score[9][2]

177. 177
score[0][0]score[0][1]score[0][2]
score[1][0]score[1][1]score[1][2]
score[9][0]score[9][1]score[9][2]
score[2][0]score[2][1]score[2][2]
ลักษณะข้อมูล หน่วยความจำา
200 202204 206 208 210
210 212214 216 218 220
220 222224 226 228 230
[0][0][0][1][0][2][1][0][1][1][1][2]
[2][0][2][1][2][2][3][0][3][1][3][2]
[4][0][4][1][4][2][5][0][5][1][5][2]