177

ดังนนั้ สตู รท่ีใช้ก็คือ
Ad A [ i , j ] = B + ( i - 1 )cs + ( j - 1 )s
ในกรณที ั่วไป อารเ์ รย์ 2 มิติจะมรี ปู รา่ งเป็น A [ l1 : u1 , l2 : u2 ]
โดยท่ี l1 เป็น ขอบเขตล่างของมิตทิ 1่ี
u1 เป็น ขอบเขตบนของมติ ิท่1ี
l2 เป็น ขอบเขตล่างของมิตทิ ่ี2
u2 เปน็ ขอบเขตบนของมติ ิท2่ี

ดงั น้ันถา้ ต้องการหา Ad A [ i , j ] ของอาร์เรย์ 2 มิติ A [ I1 : u1, I2 : u2 ] ก็
ตอ้ งใช้สตู ร

Ad A [ i , j ] = B + ( i - l1 )cs + ( j - I2 )s
ตวั อย่างเชน่ Array XY [ 1 : 5 , 3 : 7 ] แตล่ ะชอ่ งมีขนาด 10 Bytes ซ่ึงนาไปเก็บใน
หนว่ ยความจาแบบ Row Major Order โดยเรม่ิ ต้นเก็บที่ Address 10000 จงหา Address
เริม่ ต้นของ XY [4 , 3]

c = u2 - I2 + 1
c = 7–3+1=5
Ad A [ i , j ] = Ad ตัวแรก + ( i - 1 )cs + ( j - I2 )s

= 10000 + ( 4 - 1 )x5x10 + ( 3 - 3 )x10
= 10000 + 150 +0

= 10150

3. การจดั เรียงแบบคอลัมน์ (Column Major Order) เป็นการจัดเรียงสมาชิกใน
หน่วยความจาหลักโดยเรียงกันไปทลี ะคอลัมน์ เริ่มตั้งแต่คอลัมน์แรกจะจดั เรยี งสมาชกิ ในแถวแรก
ตามด้วยสมาชกิ ในแถวท่ี 2 ไปจนถึงสมาชิกในแถวสุดทา้ ยของคอลมั น์แรก จากน้ันจดั เรียงสมาชิกใน
คอลมั นท์ ี่ 2 เรมิ่ ทแี่ ถวแรกไปจนถงึ แถวสุดทา้ ยของคอลมั น์ที่ 2 และจดั เรียงสมาชิกในคอลมั น์ตอ่ ไปใน
ลกั ษณะเดยี วกนั จนกระทั่งถงึ คอมัลมน์สุดทา้ ยแถวสดุ ทา้ ย การเกบ็ อาร์เรย์ 2 มติ ใิ นลักษณะน้ีมใี ช้ใน
ภาษาฟอรแ์ ทรน (FORTRAN)

กาหนดอารเ์ รย์ 2 มิติ ช่อื A [ 1 : 4 , 1 : 5 ] ซึง่ จัดเก็บแบบ Column Major Order

178

XY 1 2 3 4 5
1
2
3
4

การจดั เกบ็ จะเกบ็ ค่าแต่ละคอลมั น์แถวต่อๆ กันไป ดงั น้ี

B A [1 , 1] คอลมั น์ที่ 1
B + s A [2 , 1] คอลมั น์ท่ี 2
B + 2s A [3 , 1]
B + 3s A [4 , 1]

A [1 , 2]
A [2 , 2]
A [3 , 2]
A [4 , 2]

A [4 , 5]

การคานวณหาตาแหนง่ ของสมาชิกใดๆ ในหน่วยความจาของอารเ์ รย์ 2 มติ ิ ทจ่ี ัดเกบ็ แบบคอลมั น์

ในการการคานวณหาตาแหน่งของสมาชิกใดๆ ในหนว่ ยความจาของอาร์เรย์ 2 มิติ ท่ี
จัดเกบ็ แบบคอลมั น์ จะคลา้ ยๆ กับการคานวณหาตาแหนง่ ของแถวลาดบั ที่มีการจัดเก็บแบบแถว
การคานวณหาตาแหนง่ ของ Array A [ i , j ] ซ่งึ เปน็ อารเ์ รยท์ ี่มี I1 และ I2 เปน็ 1 จะเร่มิ
จาก เราต้องขา้ มไป j - 1 คอลัมน์ แต่ละคอลมั น์มีค่า r ค่า แตล่ ะคา่ ใชเ้ น้ือท่ีขนาด s นั่นคอื
จะต้องข้ามไป (j - 1) rs จาก A [ 1,1 ] ตอนนีเ้ ทา่ กับเราข้ามมาอยู่ท่ี A [ i , j ] ตอ่ ไปจะต้อง
ข้ามไปอีก i - 1 ค่าในคอลมั น์ท่ี j แต่ละคา่ ใช้เนอ้ื ที่ s กค็ ือ (i - 1)s กจ็ ะถงึ ตวั ที่ j ในแถวท่ี
i ซง่ึ ก็คอื ตัวที่ A [ i , j ] ซ่ึงสูตรท่ใี ช้กค็ ือ

Ad A [ i , j ] = B + (j - 1)rs + (i - 1)s

179

ดังนัน้ ถ้าต้องการหา Ad A [ i , j ] ของอารเ์ รย์ 2 มติ ิ A [ I1 : u1 , I2 : u2 ] ก็ตอ้ งใช้สตู ร
Ad A [ i , j ] = B + ( j - l2 )rs + ( i - I1 )s

ตวั อยา่ งเช่น Array XY [ 1 : 5 , 3 : 7 ] แต่ละช่องมีขนาด 10 Bytes ซึง่ นาไปเกบ็ ใน
หนว่ ยความจาแบบ Column Major Order โดยเร่ิมตน้ เก็บท่ี Address 1001 จงหา Address
เร่มิ ต้นของ XY [4 , 5]

r = u1 - I1 + 1
r = 5-1+1=5
Ad A [ i , j ] = B + ( j - l2 )rs + ( i - I1)s

= 1001 + (5 - 3)x5x10 + (4 - 1)x10
= 1001 + 100 + 30
= 1131
ตัวอย่างที่ 7.3 กาหนดให้มแี ถวลาดบั a และแถวลาดบั b จากนนั้ ใหค้ านวณแถวลาดับ c ที่เกดิ จาก
แถวลาดับ a และ b บวกกนั

#include<stdio.h>
#define R 4
#define C 5
int i,j,sum,a[R][C],b[4][5],c[4][5];
main()
{

sum =0;
for(i=0;i<4;i++)
for(j=0;j<5;j++){printf("A[%d][%d]",i,j);
scanf("%d",&a[i]);}

for(i=0;i<R;i++)
for(j=0; j<C; j++){printf("B[%d][%d]",i,j);
scanf("%d",&b[i][j]);}
for(i=0;i<4;i++)
for(j=0;j<5;j++)
{

c[i][j]=a[i][j];
sum=sum+c[i][j];
printf("%d",c[i][j]);
}
printf("Sum = %d",sum);
}

180

ตัวอยา่ งท่ี 7.4 กาหนดแถวลาดบั ขนาด 5x2

#include<stdio.h>
#define R 5
#define C 2
int i,j,sum,sum2,a[R][C],c[5][2];
main()
{

sum =0;
sum2=0;
for (i=0;i<5;i++)
for (j=0;j<2;j++)

{
printf("No.%d",i+1);
printf("score[%d][%d]=",i,j);
scanf("%d",&a[i][j]);

}
for(i=0;i<5;i++)

for(j=0;j<1;j++)
{

sum+=a[i][j];
}

printf("Sum=%d\n",sum);
for(i=0;i<5;i++)

for(j=1;j<2;j++)
{
sum2 +=a[i][j];
}
printf("%d",sum2);
}

7.4 แถวลาดับ 3 มติ ิ (three – dimensional array)

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

181

ชอื่ ของอาร์เรย์ [ I1 : u1 , I2 : u2 , I3 : u3 ]

I1 คอื ขอบเขตล่างของมิตทิ ่ี 1 u1 คอื ขอบเขตบนของมติ ิของท่ี 1
I2 คือ ขอบเขตล่างของมิตทิ ี่ 2 u2 คือ ขอบเขตบนของมติ ิของที่ 2
I3 คือ ขอบเขตล่างของมติ ิท่ี 3 u3 คอื ขอบเขตบนของมิติของท่ี 3

เช่น A [1 : 2 , 1 : 4 , 1 : 3 ] คอื การกาหนดให้ อารเ์ รย์ 3 มติ ิ ชอ่ื A มีจานวน 2 แถว เริ่มที่
1 ถึง 2 และ 4 คอลมั น์ เรมิ่ ที่ 1 ถึง 4 และ 3 ช้นั เรม่ิ ท่ี 1 ถึง 3

แถว 1 A[1, 1, A[1, 2, A[1, 3, A[1, 4, ชนั้ ที่ 3
แถว 2 A[2, 1, A[2, 2, A[2, 3, A[2, 4, ชนั้ ที่ 2
ชนั้ ท่ี 1
คอลมั น์ 1 คอลมั น์ 2 คอลมั น์ 3 คอลมั น์ 4

การคานวณหาจานวนสมาชิกของแถวลาดับ 3 มติ ิ
การคานวณหาจานวนสมาชกิ ของแถวลาดบั 3 มติ ิ สามารถคานวณได้จาก
จานวนสมาชกิ ของ A [ l1 : u1, l2 : u2, l3 : u3 ] = r x c x p
โดยที่ r หมายถึงจานวนแถว (row) ซ่ึงคานวณไดจ้ าก

r = u1 - I1 + 1

c หมายถงึ จานวนคอลมั น์ (column) ซง่ึ คานวณไดจ้ าก
c = u2 - I2 + 1

p หมายถึงจานวนชน้ั ซ่ึงคานวณไดจ้ าก
p = u3 - I3 + 1

7.4.1 การจดั เก็บแถวลาดับ 3 มติ ิ
การจัดเกบ็ แถวลาดบั 3 มิติในหนว่ ยความจาของเครื่องคอมพิวเตอร์ ตาแหนง่ ของหน่วยความจาจะ
ต่อเนื่องกนั ไปเชน่ เดียวกัน ซง่ึ การจดั เรียงในแถวลาดบั 3 มิติ แบง่ ออกเป็น 2 แบบเหมือนแถวลาดบั 2
มติ ิ คือ

1. การจัดเรียงแบบแถว (Row Major Order) เป็นการจัดเรียงสมาชกิ ใน
หน่วยความจาหลกั เรยี งกันไปทลี ะแถว โดยจดั เรียงในชนั้ แรกให้หมดกอ่ น จึงเรยี งชัน้ ถัดไปทีละชั้น

182

จนกระท่ังหมด เชน่ จากอาร์เรย์ 3 มิติ ชอ่ื A [1 : 2 , 1 : 4 , 1 : 3] ในรปู ขา้ งตน้ เม่ือจดั เกบ็ แบบ
Row Major Order จะถูกจัดเก็บดังนี้

B A [1, 1, 1]

B + s A [1, 2, 1] แถวท่ี 1

B + 2s A [1, 3, 1]
B + 3s
ชนั้ ที่ 1
A [1, 4, 1]

A [2, 1, 1] แถวที่ 2

A [2, 2, 1]

A [2, 3, 1]

A [2, 4, 1] แถวท่ี 1
แถวที่ 2
A [1, 1, 2]

A [1, 2, 2] ชนั้ ท่ี 2

A [1, 3, 2]

A [1, 4, 2]

A [2, 1, 2]

A [2, 2, 2]
A [2, 3, 2]
A [2, 4, 2]

A [2, 4, 3]

ดังน้นั ถา้ ต้องการหา Ad A [ i , j , k ] ของอาร์เรย์ 3 มิติ A [ I1 : u1 , I2 : u2
, I3 : u3 ] ที่มกี ารเก็บแบบ Row Major Order กต็ ้องใช้สตู ร

Ad A [ i , j , k ] = B + ( k – I3 )rcs + ( i – I1 )cs + ( j – I2 )s

183

ตวั อย่างเชน่ Array X [ 1 : 7 , 1 : 9 , 1 : 4 ] แตล่ ะช่องเก็บจานวนจรงิ ซง่ึ นาไปเก็บใน

หน่วยความจาแบบ Row Major Order โดยเร่ิมต้นเก็บที่ Address 1001 จงหา Address

เรม่ิ ตน้ ของ X [2, 5, 3]

r = u1 - I1 + 1 c = u2 - I2 + 1

r = 7-1+1=7 c = 9-1+1=9

Ad A [ i , j , k ]= B + ( k – I3 )rcs + ( i – I1 )cs + ( j – I2 )s

Ad X [ 2, 5, 3 ] = 1001 + (3 - 1)x7x9x4 + (2 - 1)x9x4 + (5

- 1)x4

= 1001 + 504 + 36 + 16

= 1557

2. การจัดเรียงแบบคอลัมน์ (Column Major Order) เป็นการจัดเรียงสมาชกิ ทีละ
คอลมั น์เร่ิมตงั้ แต่คอลัมน์แรกแถวแรก โดยให้สมาชิกทอี่ ยใู่ นตาแหน่งเดียวกันของแต่ละช้นั เรยี งตอ่ กนั
ไปก่อน จากน้นั จัดเรยี งสมาชิกจะเกบ็ แตล่ ะแถวตามแนวต้งั ตอ่ ๆ กันไป โดยเกบ็ ทีละคอลัมนจ์ นเตม็
แล้วคอ่ ยเรม่ิ เก็บคอลัมน์ใหม่ เช่น

จากอาร์เรย์ 3 มติ ิ ชื่อ A [1 : 2 , 1 : 4 , 1 : 3] ในรูปข้างต้นเมอ่ื จัดเกบ็ แบบ Column
Major Order จะถกู จัดเกบ็ ดังนี้

B A [1, 1, 1] แถวที่ 1
B + s A [1, 1, 2] แถวท่ี 2

B + 2s A [1, 1, 3] คอลมั น์ท่ี 1
B + 3s A [2, 1, 1]

A [2, 1, 2]

A [2, 1, 3] แถวที่ 1
แถวท่ี 2
A [1, 2, 1] คอลมั น์ที่ 2

A [1, 2, 2]

A [1, 2, 3]

A [2, 2, 1]

A [2, 2, 2] แถวที่ 1

A [2, 2, 3]

A [1, 3, 1]

A [1, 3, 2]

184

A [1, 3, 3]
A [2, 3, 1]

A [2, 4, 3]

ดงั น้ันถา้ ต้องการหา Ad A [ i , j , k ] ของอารเ์ รย์ 3 มติ ิ A [ I1 : u1 , I2 : u2 ,
I3 : u3 ] ทม่ี ีการจัดเกบ็ แบบ Column Major Order กต็ อ้ งใชส้ ูตร Ad A [ i , j , k ] = B +
( j – I2 )rps + ( i – I1 )ps + ( k – I3 )s ตัวอยา่ งเช่น Array X [ 1 : 7 , 1 : 9 , 1 : 4 ] แตล่ ะ
ช่องเก็บจานวนจรงิ ซ่ึงนาไปเก็บในหน่วยความจาแบบ Column Major Order โดยเร่มิ ต้นเกบ็ ที่
Address 1001 จงหา Address เรมิ่ ต้นของ X [2, 5, 3]

r = u1 - I1 + 1 p = u3 - I3 + 1

r = 7-1+1=7 p = 4-1+1=4

Ad A [ i , j , k ]= B + ( j – I2 )rps + ( i – I1 )ps + ( k – I3 )s

Ad X [ 2, 5, 3 ] = 1001 + (5 - 1)x7x4x4 + (2 - 1)x4x4 +

(3 - 1)x4

= 1001 + 448 + 16 + 8

= 1473

ตวั อยา่ งที่ 7.5 สรา้ งโปรแกรมแถวลาดบั 3 มิติ ขนาด 2 แถว 1 คอลมั น์ และ 3 ระนาบ

#include <stdio.h>
#include <conio.h>

Int main()
{

int numbers[2][1][3];
int I,j,k;
printf(“Enter table values\n”);
for (I = 0;i<2;i++);
{
printf(“Table %d\n”,i+1);
for (j=0;j<1;j++)

{
for (k=0;k<3;k++)
scanf(“%d”,&number[i][j][k]);
}

}

185

For(i=0;i<2;i++)
{
Printf(“Table %d:\n”,i+1);
For(j=0;j<1;j++)
Printf(“%d\t”,numbers[i][j][k]);
Printf(“\n”);
}

}

Getch();

Return 0;

}

7.5 การแทรกและการลบ (INSERTING AND DELETING)
ให้ A เป็นอารเ์ รยท์ ่ีอยู่ในหน่วยความจาของคอมพิวเตอร์ การแทรกเปน็ การเพ่ิมขอ้ มลู 1

รายการเข้าไปใน A และการลบเป็นการเอาข้อมูล 1 รายการออกจากอารเ์ รย์ A
การเพิ่มข้อมูลอีก 1 รายการในสว่ นทา้ ยของอาร์เรยท์ าได้ง่าย หากพืน้ ที่ของหนว่ ยความจา

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

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

Data 5 12 25 29 38 42
12345678

1. ยา้ ยข้อมลู DATA ( 6 ) ไปอยตู่ าแหนง่ ที่ 7

Data 5 12 25 29 38 42

12345678

2. ยา้ ยข้อมลู DATA ( 5 ) ไปอยตู่ าแหน่งที่ 6

Data 5 12 25 29 38 42

12345678

3. ย้ายขอ้ มูล DATA ( 4 ) ไปอยตู่ าแหนง่ ที่ 5

Data 5 12 25 29 38 42

12345678

4. ใสข่ อ้ มลู 27 ในตาแหนง่ ที่ 4

Data 5 12 25 27 29 38 42

186

12345678

ในทานองเดยี วกัน การลบข้อมูล 1 รายการ ที่อยู่ท้ายสดุ ของอารเ์ รย์ก็ทาไดง้ ่าย แต่ถ้า
ต้องการลบข้อมลู 1 รายการ ท่ีอย่ตู รงกลางของอารเ์ รย์ จะตอ้ งการมีการยา้ ยข้อมลู ของชอ่ งต่างๆ
ที่ อยูด่ ้านล่างขึน้ มา เช่น จาก ARRAY Data ในตัวอยา่ งข้างต้น ถา้ ต้องการลบ 27 ออกจาก ARRAY
ต้องมีข้นั ตอนดงั นี้

1. ยา้ ยข้อมลู DATA ( 5 ) ไปอยู่ตาแหน่งที่ 4

Data 5 12 25 29 38 42

12345678

2. ยา้ ยข้อมลู DATA ( 6 ) ไปอยูต่ าแหน่งท่ี 5

Data 5 12 25 29 38 42

12345678

3. ยา้ ยข้อมูล DATA ( 7 ) ไปอยตู่ าแหนง่ ท่ี 6

Data 5 12 25 29 38 42

12345678

7.6 ตัวแปรชุดของตัวอักขระ

ในกรณีของการใชต้ วั แปรชุดกับข้อมูลชนิด char จะมองเป็นการทางานกับข้อมูลหลาย ๆ ตวั
อกั ขระหรือขอ้ ความทเี่ รียกวา่ สตรงิ (String) คา่ คงที่ของข้อความเป็นสงิ่ ทมี่ ีการใช้เสมอในโปรแกรม
เช่น “Hello” แตใ่ นการใชง้ านตวั แปรสตรงิ จะต้องมกี ารเตรียมพ้นื ที่ในการเกบ็ ข้อความเผอื่ ไวห้ นงึ่
ตาแหน่งเสมอเชน่ หากต้องการประกาศตัวแปรเพ่ือเก็บข้อความวา่ “Mickey Mouse” จะต้องจอง
พ้ืนทีเ่ ทา่ กับจานวนตวั อักขระทีม่ ีและบวกไปดว้ ย1 เสมอเนื่องจากลักษณะการเกบ็ ข้อมูลประเภท
ข้อความในหนว่ ยความจาจะมีการปะตวั อักษร Null หรือ ‘\0’ ตอ่ ท้ายเสมอเพือ่ ใหร้ ้วู ่าเปน็ จดุ ส้ินสดุ
ของข้อมูล ในที่นตี้ ้องจองพื้นทขี่ นาด13 ตัวอกั ขระการจองพน้ื ทีด่ ังกลา่ วจะเหมือนการจองพ้นื ที่ของ
ขอ้ มลู ประเภทตัวแปรชดุ เปน็ ตัวแปรชดุ ของ char สามารถใชค้ าสั่งในการประกาศตวั แปรคอื

char message[13];

หากตอ้ งการกาหนดคา่ ให้กับตวั แปร message สามารถทาได้ด้วยคาส่งั

char message[ ] = “Mickey”;

187

จาลองการเกบ็ ข้อมูลดังกลา่ วในหนว่ ยความจาดงั รปู ที่ 7.4

รูปที่ 7.7 แสดงแบบจาลองการเก็บข้อมูลประเภทสตรงิ ในหน่วยความจา

คา่ คงทีส่ ตริงที่พบเห็นได้เสมอไดแ้ ก่ข้อความทีใ่ ชใ้ นฟังกช์ นั printf( ) เช่น

printf ( “Hello, world\n” );

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

char *pmessage = “Hello, world”;

pmessage จะเป็นพอยนเ์ ตอร์ประเภท char ชไี้ ปท่ีตวั แปรชุดของตวั อักษร จะแตกตา่ งจาก
การใช้ตัวแปร ชดุ ท่วั ไปเช่น

char amessage[ ] = “Hello, world”;

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

รปู ท่ี 7.8 แสดงการจองพนื้ ท่ีให้กับตวั แปรชดุ และพอยนเ์ ตอร์ชี้ไปยงั คา่ คงท่ีสตรงิ

188

ตวั อยา่ งที่ 7.6 เขียนโปรแกรมนับจานวนตัวอักษร

#include<stdio.h>
main()
{

char name[]="Computer Science";
char string[60];
int count=0,i=0;
while (name[i] !='\0'){

count++;
i++;
}
printf("Length is %d\n",count);
scanf("%s",string);
printf("Text:%s",string);
count=0;
i=0;
while (string[i] !='\0'){
count++;
i++;
}
printf("Length is %d\n",count);

}

ตัวอย่างท่ี 7.7 นาขอ้ ความจานวน 2 ขอ้ ความารวมกันแลว้ นบั จานวนตวั อกั ษร

#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{

char s1[] = "Computer";
char s2[] = "Education";
char s3[20];
char s4[20];
strcat(s1,s2);
printf("%s",s1);
printf("%d\n",strlen(s1));
printf("%d\n",strlen(s2));
printf("name: ");scanf("%s",s3);
printf("sername: ");scanf("%s",s4);
strcat(s3,s4);
printf("name-sername: %s",s3);
printf("%d\n",strlen(s3));

189

getch();
}

จะเหน็ วา่ s เปน็ พอยน์เตอร์ในฟังก์ชนั จะมีการตรวจสอบขอ้ มูลวา่ มีคา่ เท่ากบั ‘\0’ หรือไม่
และมีกาเล่อื นตาแหน่งทีละ 1 คา่ (นับว่าข้อมูลมคี วามยาวเพ่ิมข้ึนทลี ะ1) โดยใช้ s++ คาตอบที่ไดจ้ าก
การเรยี กใช้ฟงั กช์ นั นจ้ี ะเป็นความยาวของขอ้ มูลท่เี กบ็ อย่ภู ายในโดยทไี่ ม่รวมคา่ Null การเรียกใช้
ฟงั กช์ ัน strlen สามารถทาได้หลายลักษณะ

strlen (“Hello world”); /* string constant */
strlen (array); /* char array[ ]=”Hello world”; */
strlen (ptr); /* char *ptr=”Hello world”; */

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

strlen(&str[2]) หรอื strlen(str+2)

เปน็ การส่งแอดเดรสของสมาชกิ str[2] ให้กับฟงั ก์ชัน strlen( ) การประกาศฟังก์ชนั strlen( )
สามารถทาได้โดยการประกาศ

int strlen(char s[ ]) { ......... } หรอื intstrlen(char *arr) { ............ }

190

ตวั อยา่ งของการทางานของสตริงดงั ตัวอย่างท่ี 7.8 เปน็ การใช้ฟงั ก์ชัน strcpy( ) ท่ีทา
หนา้ ที่ในการทาสาเนา (Copy) ข้อความจากตวั แปรหน่งึ ไปยังอกี ตัวแปรหนึ่งสามารถเขยี นโดยใน
พารามิเตอรใ์ นลักษณะตวั แปรชุดและพอยนเ์ ตอร์ไดด้ ังตวั อย่าง

ตัวอยา่ งที่ 7.8 ฟังกช์ ัน strcpy ( ) ทาหนา้ ทสี่ าเนาข้อความจากตวั แปรหนง่ึ ไปยังอีกตวั แปรหนึง่ เขยี น
ใน ลักษณะตัวแปรชุด

#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{

char s1[ ] = “Computer";
char s2[ ] = “Education";
strcpy(s1,s2); printf("%s",s1);
strcpy(s2, “CMU”);printf (“%s”,s2);
}

ตัวอย่างท่ี 7.9 นาข้อความเปรยี บเทยี บกัน

#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{

char s1[ ] = "ABCDEF";
char s2[ ] = "XYZ";
if (strcmp(s1,s2)!=0)

printf("Not equal");
else

printf("Equal");
}

7.7 การประยกุ ตใ์ ช้โครงสรา้ งข้อมูลแถวลาดบั

งานประยุกตท์ ใี่ ช้แถวลาดับเข้ามาช่วยมมี ากมาย ซึง่ มผี ลให้การเขยี นโปรแกรมมปี ระสทิ ธภิ าพ
สูงข้นึ เช่น

การประยุกตใ์ ชแ้ ถวลาดบั ในเมทริกซ์
การประยุกตใ์ ชแ้ ถวลาดับมักจะพบในปัญหาท่ัวๆ ไป ในสว่ นของปญั หาท่ีเกย่ี วกบั เมทริกซ์
โดยท่วั ไปการจดั เก็บค่าของสมาชิกของเมทรกิ ซ์จะใชแ้ ถวลาดบั 2 มิติ เมือ่ ตอ้ งการเก็บค่าทกุ ๆ ค่าของ
เมทริกซ์

191

ตัวอย่างเมทริกซ์ A และ B เป็นเมทริกซ์ขนาด 3 X 3 ดงั นี้

235 104

A= 0 5 1 B= 2 1 0

125 342

เม่อื จัดเกบ็ ใน Array A และ Array B จะได้ดังนี้

123 123
1235 1104
A2 0 5 1 B2 2 1 0
3125 3342

ในเมทรกิ ซม์ ีปฏบิ ัตกิ ารต่าง ๆ เช่น การบวกเมทริกซ์ การลบเมทรกิ ซ์ การคูณเมทริกซ์ และ
การหาอนิ เวอร์สของเมทริกซ์ ในทน่ี ขี้ อยกตัวอย่างปฏิบัติการบวกและการคูณกนั ของเมทริกซ์ 2 เมท
ริกซ์

การบวกเมทริกซจ์ ะกระทาได้ก็ตอ่ เมอ่ื เมทริกซท์ ่จี ะนามาบวกกันต้องเปน็ เมทริกซ์ทม่ี ีขนาด
เดียวกัน โดยสมาชิกในตาแหนง่ เดยี วกนั นามาบวกกัน

235 104 339

051+210=261

125 342 467

สว่ นการคณู เมทริกซจ์ ะกระทาได้ก็ต่อเม่ือเมทรกิ ซ์ทีจ่ ะคูณกนั ต้องมีจานวนคอลัมน์ของเมท

รกิ ซ์ตวั ต้งั เทา่ กบั จานวนแถวของเมทรกิ ซ์ตวั คูณเสมอ มิฉะน้ันจะนามาคณู กนั ไม่ได้ เช่น

2 5 (2 x 2) + (5 x 3)

0 1 x 2 = (0 x 2) + (1 x 3)

1 5 3 (1 x 2) + (5 x 3)

3x2 2x1 3x1

19

=3

17 3 x 1

192

เมทรกิ ซ์บางเมทริกซ์เราไม่จาเป็นตอ้ งเก็บค่าสมาชิกทกุ ๆ ตัว ให้เก็บเพยี งบางส่วนของเมท
รกิ ซ์ไวเ้ ท่านั้น เพื่อประหยดั เนื้อทใี่ นหนว่ ยความจาหลัก ตัวอยา่ งเชน่ เมทริกซส์ ามเหลีย่ ม เมทริกซ์
สมมาตร และเมทรกิ ซก์ ระจาย เป็นตน้ เมทรกิ ซเ์ หล่านี้เราไม่จาเป็นตอ้ งจัดเกบ็ สมาชิกในแถวลาดับ 2
มิติ โดยอาจจะจัดเก็บสมาชกิ ในแถวลาดับ 1 มิติแทนก็ได้

เมทรกิ ซส์ ามเหล่ยี ม (Triangular Matrix)
เมทรกิ ซส์ ามเหลย่ี ม เปน็ ลกั ษณะของเมทริกซส์ เ่ี หลย่ี ม (Square matrix) ที่มีข้อมูลเฉพาะ
ตอนบนหรือตอนลา่ งของเส้นแทยงมมุ หลัก มี 2 แบบคอื
1. เมทริกซส์ ามเหล่ียมลา่ ง (Lower Triangular Matrix) เปน็ เมทริกซ์ทีม่ ีสมาชิกอยู่เหนือ
เส้นแทยงมุมหลักมคี ่าเป็นศูนยท์ ้งั หมด
2. เมทริกซ์สามเหลี่ยมบน (Upper Triangular Matrix) เป็นเมทริกซ์ท่ีมีสมาชิกอย่ใู ตเ้ สน้ แท
ยงมุมหลกั มีค่าเปน็ ศูนยท์ ั้งหมด

B11 0 0 0 A11 A12 A13 A14
B21 B22 0 0 0 A22 A23 A24
B31 B32 B33 0 0 0 A33 A34
B41 B42 B43 B44 0 0 0 A44
รปู แสดง Lower Triangular รปู แสดง Upper Triangular

ตวั อย่างการนาเมทริกซส์ ามเหล่ยี มล่างมาเกบ็ ในตัวแปรอารเ์ รย์ 1 มิติ จะกระทาได้ 2 แบบ
ดังน้ี
1. แบบแถว (Row Major Order)

a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]

B11 B21 B22 B31 B32 B33 B41 B42 B43 B44

2. แบบคอลมั น์ (Column Major Order)
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]

B11 B21 B31 B41 B22 B32 B42 B33 B43 B44

193

สรปุ

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

ตัวแปรอาร์เรย์ 1 มิติ ตวั แปรอาร์เรย์ทีเ่ ก็บข้อมลู ได้เพียงแถวเดียว ใชล้ าดับในการอา้ งถงึ
ข้อมลู

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

ตวั แปรอาร์เรย์ 3 มิติ ตวั แปรอาร์เรยท์ เี่ ก็บข้อมลู ลกั ษณะของลกู บาศก์ โดยใช้ แถว(Row)
หลัก(Column) และลึก (Deep)

194

แบบฝึกหดั

1. เขียนโปรแกรมเพื่อรบั ข้อมูล N จานวน โดยเก็บข้อมูลในตัวแปรชุด และให้พมิ พ์ข้อมลู ในลา ดบั ที่
กลับกบั การป้อน ขอ้ มลู เช่น ป้อนข้อมลู 1 2 3 4 5 6 จะพิมพ์คา ตอบในลักษณะ 6 5 4 3 2 1

2. เขียนโปรแกรมเพ่อื รบั ขอ้ มูลเขา้ มาเกบ็ ในตัวแปรชดุ 2 ชดุ คอื xi และ yi แตล่ ะชดุ มีขอ้ มูลเท่ากัน
คอื N ตวั ให้หาคา่

3. เขยี นโปรแกรมเพอื่ รบั ขอ้ มูลจานวนเต็มเข้ามาเก็บยังตัวแปรชดุ 2 ตวั แปรชุด ซ่งึ มีขนาดเท่ากัน
คือ N โดยมขี อ้ กาหนดในการรับ ข้อมูลของตวั แปรชุดท้ังคู่ คอื ขอ้ มูลตัวแรกจะเปน็ ขอ้ มลู อะไรก็
ได้แต่จะต้องมคี ่าอยู่ในช่วง 1 ถึง 20 สว่ นข้อมลู ตวั ถดั ไปต้องมีค่ามากกวา่ สามารถตัวก่อนหน้าตัว
มันเอง โดยมคี ่ามากกว่าไมเ่ กิน 5 เมอ่ื รับข้อมลู เสร็จแล้ว ให้ทาการรวม (Merge) ตวั แปรชุด
ทั้งหมดเข้าด้วยกนั โดยเรยี งตามลา ดบั ข้อมูลจากน้อยไปมาก หากมีคา่ เท่ากันจะนา คา่ ใดไปไว้ใน
ตวั แปรชดุ กอ่ นก็ได้ เช่นตัวแปรชดุ 1 ตวั แปรชุด 2 ตวั แปรชุดคา ตอบ

4. เขียนโปรแกรมโดยใชต้ วั แปรชุด เพือ่ รบั ข้อมูลชนิดอืน่ และคะแนนสอบของนกั เรยี นห้องหนึง่ ซ่งึ มี
50 คน โดยรบั ข้อมูลเป็นจานวนเต็ม โปรแกรมจะต้องมีความสามารถต่าง ๆ ดงั นี้

5. เขียนโปรแกรมเพอื่ รับขอ้ ความจากผู้ใช้ใหแ้ ปลงข้อความดงั กล่าวโดย ตัวอกั ษรใดเปน็ ตวั a หรือ
A ใหแ้ ทรกข้อความแทนด้วย 555 ตวั อักษรใดเป็นตัว u หรือ U ใหแ้ ทนท่ีดว้ ย Hanaga และ
แสดงผลลพั ธท์ ไี่ ด้

6. เขยี นโปรแกรมเพอื่ รับตวั อกั ขระทางแป้นพมิ พท์ ลี ะ 1 ตวั อกั ษร จากนน้ั ทาการนับจานวน
ตัวอักษร A-Z และ a-z ท่รี บั เข้าไป ข้อมูลตัวพิมพ์ใหญห่ รอื ตวั พิมพ์เล็กจะนบั เป็นอักษรตัว
เดยี วกัน โดยจะสิ้นสดุ การรับขอ้ มลู เมื่อผูใ้ ชก้ ด “%” จากนัน้ ทา การพิมพ์ความถี่ของจานวนแต่
ละตัวอกั ษร A-Z หรอื a-z ท่ีปอ้ นเข้าไป กาหนดใหท้ า การพิมพ์ “*” เท่ากับจานวนค่าความถ่ี
ของการรบั แตล่ ะตวั อกั ษรทน่ี ับได้

7. เขยี นโปรแกรมเพ่ือรับค่าข้อมูลการวดั อณุ หภมู ิร่างกายของคนไขร้ ายหนึ่งเป็นเวลา 7 วัน โดยแต่
ละวนั จะทาการวดั อุณหภมู ิ 4 ครง้ั ในเวลาที่ตรงกนั คอื 6.00 น. 12.00 น. 18.00 น. และ 24.00
น. เขยี นโปรแกรมเพ่ือทาการเก็บข้อมูล โปรแกรมจะต้องมีความสามารถ
- คานวณอุณหภมู สิ งู ทส่ี ดุ และตา่ ทส่ี ดุ ท่วี ัดได้ในแตล่ ะวนั
- คานวณอุณหภมู เิ ฉลี่ยท่วี ัดไดใ้ นแตล่ ะวัน ทัง้ 7 วนั
- คานวณอณุ หภูมเิ ฉลีย่ ท่ีได้ในแตล่ ะช่วงเวลา ทั้ง 4 ช่วงเวลา
- คานวณอณุ หภูมิเฉลีย่ รวมท้ังหมด

8. เขยี นโปรแกรมเพื่อเก็บข้อมูลประตูไดแ้ ละเสยี ในการแข่งขันฟุตบอลรายการหนง่ึ ซึง่ มีทมี ฟตุ บอล
เข้า

195

ร่วมแขง่ ขนั 4 ทีม โดยแต่ละทีมจะทา การแขง่ ขันแบบพบกันหมด (เลน่ ทมี ละ 3 ครง้ั ) ให้
เขียนโปรแกรมโดยแยกประตูไดแ้ ละเสียออกเป็นตวั แปรชุด 2 มิติจานวน 2 ตัวแปรชดุ
โปรแกรมจะทาหน้าที่
- รบั ขอ้ มูลประตูไดแ้ ละเสียของแตล่ ะทีม
- หาผลต่างประตไู ด้เสียในการแข่งขนั แต่ละครั้งของแตล่ ะทีม และให้แสดงทีมท่มี ผี ลตา่ งดี
ทส่ี ดุ
- หาผลรวมประตทู ไ่ี ดข้ องแต่ละทมี และให้แสดงทมี ที่ทา ประตไู ด้มากท่ีได้
- หาประตูไดแ้ ละเสียเฉลย่ี ของแตล่ ะทีม
9. เขยี นโปรแกรมเพื่อสร้างตารางสรปุ จานวนนกั ศกึ ษาโดยแยกตามคณะและชั้นปที ี่นักศึกษาสังกดั

First Year Second Year Third Year Fourth Year >4 Total

Faculty 1 1500 1200 1150 1100 20 4970

Faculty 2 3500 3300 3200 3100 100 12200

...

Total ... ... ... ... ... ...

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

10. เขียนโปรแกรมเพื่อหาค่าผลบวกของเมตริกซ์ 2 เมตริกซ์ท่มี ีขนาดมติ ิเท่ากัน คอื 3x2 ใหร้ บั ขอ้ มูล
ของเมตรกิ ซ์ทง้ั 2 และคานวณคา่ ผลบวกของเมตรกิ ซ์ท่ีได้

196

เอกสารอ้างอิง

กวิน สนิ รงุ่ เรอื ง. (2554). คู่มือเรียนการเขยี นโปรแกรมภาษาซี. กรุงเทพฯ:สานักพิมพ์แห่ง
จฬุ าลงกรณ์

มหาวิทยาลัย.
ไกรศร ตัง้ โอภากลุ และ กิตนิ ันท์ พลสวสั ด์ิ. (2556). คมู่ ือเรยี นเขียนโปรแกรมภาษา C .พิมพ์คร้ังที่ 1
. นนทบรุ ี:บรษิ ัทไอดซี ี พรเี มยี ร์ จากัด.
ธนัญชยั ตรีภาค. งานพัฒนาและบริการส่อื อิเล็กทรอนิกส์. (2557). พอยน์เตอร์. (ออนไลน)์ .

แหลง่ ที่มา : http://e-learning.snru.ac.th/els/program1/lesson6/page6_1.html. (14
กุมภาพนั ธ์ 2557)
ธรี วฒั น์ ประกอบผล. (2553). คมู่ อื การเขียนโปรแกรม ภาษา C. กรุงเทพมหานคร : ซิมพลิฟาย.
วิจกั ษณ์ ศรสี จั จะเลศิ วาจา และดษุ ฎี ประเสริฐธติ ิพงษ.์ การเขยี นโปรแกรมภาษาซ.ี (ม.ป.ท.), 2545
ศริ ชิ ัย นามบุรี. (2557). บทที่ 10 พอยน์เตอร์(pointer). (ออนไลน์). แหลง่ ท่ีมา :
http://www.scribd.com/doc/33490603/ สบื ค้นเมอ่ื (14 กมุ ภาพนั ธ์ 2557)
อรพิณ ประวตั บิ ริสทุ ธิ์. (2556). คมู่ ือเขยี นโปรแกรมด้วย ภาษา C ฉบับสมบูรณ์. กรุงเทพมหานคร :

บริษทั โปรวิชนั จากดั .
http://alaska.reru.ac.th/5583709/C6.pdf สบื ค้นเม่ือ (12 กุมภาพนั ธ์ 2557)
http://krooa.files.wordpress.com/2013/07/cprogrammingv2-6.pdf สบื ค้นเม่ือ (15 มนี าคม
2557)
http://kanokwan.sru.ac.th/e-learning/12.php สืบค้นเม่อื (25 เมษายน 2557)
www.pdp.ac.th/30220/ppt/slide02_array.ppt สืบคน้ เมอ่ื (25 เมษายน 2557)
www.it.nrru.ac.th/krit/411101/Chap_10.ppt สืบค้นเมื่อ (25 เมษายน 2557)

การเขยี นโปรแกรมคอมพวิ เตอร์:197

แผนบริหารการสอนประจาบทท่ี 8

รายวิชา การโปรแกรมคอมพิวเตอร์
Computer Programming

หวั ข้อเนือ้ หา

8.1 แนวคิดเกย่ี วกบั ฟังกช์ นั
8.2 ประเภทของฟังกช์ ัน
8.3 การประกาศโปร์โตไทป์ ของฟงั ก์ชัน
8.4 ตวั แปรทว่ั ไปและตวั แปรเฉพาะท่ี
8.5 ฟังก์ชนั แบบเรยี กซา้

วัตถุประสงค์เชิงพฤติกรรม

1. เพอ่ื ให้ผู้เรยี นมีความเขา้ ใจเกย่ี วกับประเภทของฟังก์ชนั ในภาษาซี
2. เพ่อื ใหผ้ ูเ้ รยี นอธิบายฟังก์ชนั ในภาษาซีได้
3. เพ่ือใหผ้ เู้ รยี นมีความเข้าใจเก่ยี วกับฟังก์ชันทส่ี รา้ งขนึ เองได้
4. เพอ่ื ใหผ้ ู้เรียนเขียนโปรแกรมโดยใชฟ้ งั ก์ชันทส่ี ร้างเองได้
5. เพ่อื ใหผ้ เู้ รยี นอธบิ ายเก่ยี วกับฟงั กช์ ันมาตรฐานในภาษาซีได้
6. เพอื่ ใหผ้ เู้ รียนเขียนโปรแกรมเก่ียวกับฟงั กช์ นั มาตรฐานในภาษาซีได้
7. เพ่ือใหผ้ ้เู รยี นเขยี นโปรแกรมโดยใช้ฟังก์ชันทส่ี รา้ งขนึ เองรว่ มกับฟงั ก์ชันมาตรฐานได้
8. เพือ่ ใหผ้ ู้เรียนอธิบายความแตกต่างระหวา่ งตัวแปรแบบท่ัวไปและตัวแปรเฉพาะท่ีได้
9. เพื่อใหผ้ เู้ รียนเขยี นโปรแกรมในลักษณะของฟงั ก์ชนั แบบเรยี กซ้าได้

วิธสี อนและกิจกรรมการเรยี นการสอนประจาบท
1. บรรยายเนอื หาในแตล่ ะหัวข้อ พร้อมยกตวั อยา่ งประกอบ
2. ศกึ ษาจากเอกสารประกอบการสอน
3. ผสู้ อนสรุปเนอื หา
4. ท้าแบบฝกึ หัดเพอื่ ทบทวนบทเรยี น
5. ผเู้ รยี นถามขอ้ สงสัย
6. ผู้สอนทา้ การซักถาม

198 : การเขยี นโปรแกรมคอมพวิ เตอร์

สอ่ื การเรยี นการสอน

1. เอกสารประกอบการสอนวิชาการโปรแกรมคอมพิวเตอร์
2. ภาพเล่ือน (Slide)
3. บทความจากหนงั สือ หรอื เว็บไซต์ตา่ งๆ
4. เคร่ืองคอมพิวเตอร์

การวัดผลและการประเมนิ

1. ประเมนิ จากการซกั ถามในชนั เรียน
2. ประเมินจากความรว่ มมือและความรับผดิ ชอบต่อการเรียน
3. ประเมนิ จากการทา้ แบบฝกึ หดั ทบทวนท้ายบทเรียน
4. ประเมนิ จากการฝกึ ปฏิบตั ิ

การเขยี นโปรแกรมคอมพวิ เตอร์:199

บทที่ 8
การเขยี นโปรแกรมยอ่ ย

การเขียนโปรแกรมคอมพิวเตอร์นันสามารถสร้างค้าใหม่ขึนมาได้ และสามารถเรียกใช้ได้เม่ือ
ต้องการ โดยค้าใหม่ท่ีสร้างขึนจะประกอบด้วยฟังก์ช่ันต่างๆ รวมกันอยู่ ถ้าหากค้าใหม่ที่สร้างขึนนีไม่มี
การคืนค่าออกมา การท้างานก็จะเป็นโปรแกรมย่อย การเขียนโปรแกรมที่มีการท้างานแบบโปรแกรม
ย่อย (Procedure) ซึ่งเป็นส่วนหนึ่งของโปรแกรม แต่มีหน้าที่เฉพาะตัวโดยแยกการท้างานออกจาก
โปรแกรมอย่างอิสระ จะช่วยลดความซับซ้อนของโปรแกรม ซึ่งจะท้าให้สามารถแก้ไขและเพ่ิมเติมการ
ท้างานของโปรแกรมได้ง่ายขึน ในบางครังโปรแกรมหลักจะมีการส่งข้อมูลไปท้างานในโปรแกรมย่อย
ด้วย ถ้ามีการคืนค่ากลับออกมาจะท้างานเป็นฟังก์ชัน (Function) เป็นกลุ่มของค้าสั่งท่ีสร้างขึนมา
เพื่อให้ท้างานอย่างใดอย่างหนึ่ง สามารถเรียกขึนมาใช้ได้หลายครังท้าให้โปรแกรมดูง่ายขึน สามารถ
ปรับปรุงแก้ไขโปรแกรมไดง้ ่ายขนึ ในการเขยี นโปรแกรมด้วยภาษาซีจะต้องมีฟังก์ชัน main() เสมอ และ
ถ้าต้องการให้โปรกรมท้างานใดๆ ฟังก์ชัน main() จะไปเรียกใช้ฟังก์ช่ันอ่ืนๆ ให้โปรแกรมท้างาน ใน
ภาษาซีจะมีไลบรารีส้าหรับเก็บค่าฟังก์ชันต่างๆ ให้เราเลือกใช้งาน เช่น ฟังก์ชัน printf() จะเก็บไว้ใน
stdio.h ซ่ึงเคยทราบมาแล้ว หากผู้เขียนโปรแกรมท้าความเข้าใจวิธีการสร้างค้าใหม่หรือการสร้าง
ฟังกช์ นั นจี ะทา้ ให้โปรแกรมท้างานได้อย่างมีประสทิ ธภิ าพมากยงิ่ ขึน

8.1 แนวคิดเก่ียวกบั ฟังกช์ ัน

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

200 : การเขยี นโปรแกรมคอมพวิ เตอร์

โปรแกรมได้สนั ลงมาก จากรปู ต่อไป จะเหน็ ว่าในฟังก์ชัน main() สามารถเรียกใช้ฟังก์ชัน line ขึนมาใช้
งานได้หลายครัง

void main() void line();

{ {
……………… void line();
{ ………………..
line();
……………… …………………………………………………….. ……....
……………… }

line();

}

รปู ที่ 8.1 โครงสรา้ งโปรแกรมแบบฟงั กช์ ัน

ตัวอยา่ ง ฟงั กช์ นั ต่อไปนี ชอื่ วา่ Show_A() จะไมม่ กี ารสง่ ค่ากลบั โดยประกาศว่า void และ
ไม่มีการผ่านค่าพารามิเตอร์ การท้างาน เมื่อคอมพิวเตอร์เรียกใช้ฟังก์ชัน Show_A() เครื่องจะพิมพ์
AAA และ BBB

void Show_A()

{
printf(“AAA\n”);
printf(“BBB\n”);

}

ตัวอยา่ ง ฟังกช์ ันนีจะมีการประกาศตวั แปร i ภายในฟงั กช์ ัน เม่อื คอมพิวเตอร์ก็จะมีการเรียกใช้
ฟังกช์ ันนีจะมีการพมิ พ์ตวั A จ้านวน 20 ตวั

void Show_A(int A)
{

int I;
for(i=1; i<20; i++)
printf(“A”);

ตัวอย่าง ฟังก์ชันนีจะมีการรับข้อมูลที่เป็นเลขจ้านวนเต็มเข้าไป ผ่านทางพารามิเตอร์ A เม่ือ
โปรแกรมเรยี กใช้ฟังก์ชั่นนีจะพิมพ์ตัว A จ้านวนเท่ากับค่าตัวเลขจ้านวนเต็มท่ีผ่านเข้าไปในฟังก์ชั่น เช่น

การเขยี นโปรแกรมคอมพวิ เตอร์:201

ถ้าเรียกเป็น Show_A(5); ก็จะพิมพ์ A จ้านวน 5 ตัว เรียกเป็น Show_A(12) ก็จะพิมพ์ตัว A จ้านวน
12 ตวั

void Show_A(int A)
{

int i;
for(i=1; i<A; i++)
printf(“A”);

ตัวอย่าง ฟังก์ชันนีใช้ในการบวกเลขจ้านวนเต็มที่ผ่านเข้าไปทางพารามิเตอร์ A และ B เม่ือ
โปรแกรมเรยี กใชฟ้ ังกช์ ันนจี ะมีการคืนคา่ ผลบวกทเี่ ปน็ เลขจ้านวนเต็ม (int) ออกมา

int ADD_AB(int A, int B)
{

int x;
x = A+B;
return x;

ในโปรแกรมหน่ึงๆ อาจมีฟงั กช์ ันท่ีสรา้ งขนึ เองหลายๆ ฟงั ก์ชนั กไ็ ด้ ขนึ อยูก่ บั การเขียนโปรแกรม
ส้าหรับต้าแหน่งของฟังก์ชันในโปรแกรมนันนิยมสร้างไว้ส่วนบนของโปรแกรม โดยอยู่ต่อจากจาก
#include และอยกู่ ่อน main()

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

202 : การเขียนโปรแกรมคอมพวิ เตอร์

ตวั อย่างท่ี 8.1 โปรแกรมสร้างชื่อฟังก์ชัน line() ซึ่งมีการท้างานคล้ายกับโปรแกรมย่อยโดยจะพิมพ์
กรอบสี่เหล่ียมเป็นเส้นตรง ฟังก์ชันนีจะไม่มีการคืนค่าและไม่มีการคืนค่าผ่านพารามิเตอร์ ในโปรแกรม
จะมีการเรียกใช้ฟงั กช์ ัน line() ในฟังก์ชนั หลักหรอื main() จ้านวน 2 ครงั

#include <stdio.h>

#include <conio.h> /* ประกาศชื่อฟังกช์ นั */
void line()

{
ini j; /* ประกาศตวั แปรในฟังกช์ นั */

for(j=1; j<=26; j++) /* พิมพร์ หสั ASCII B0 จานวน 20 คร้ัง */
printf(“\xB0”);
printf(“\n”);

}

main()

{

printf(“\n”); /* เรียกใชฟ้ ังกช์ นั line() */

line();

printf(“\xB0 I LOVE COMPUTER……… \xB0\n”);
/* เรียกใชฟ้ ังกช์ นั line() */
line();

getch();

return 0;

}

ตัวอยา่ งที่ 8.2 ในโปรแกรมนีจะสร้างฟังก์ชันช่ือ add ส้าหรับใช้ในการบวกเลข โดยฟังก์ชันจะผ่าน
ค่าที่ต้องการบวกสองตัวเข้าไปในพารามิตอร์ a และ b เม่ือฟังก์ชันท้างานจะคืนค่าผลบวกท่ีเป็นค่า
จ้านวนเตม็ ออกมา

#include <stdio.h>

#include <conio.h>

int add(int a, int b)

{

int c;

c = a *b; /* คืนค่าผลบวกของ a และ b */
return c;

}

main() { /* คานวณค่าผลบวกและพิมพ์ */
printf(“ 3 + 5 = %d\n”, add(3,5);

getch();

return 0;

}

การเขยี นโปรแกรมคอมพิวเตอร์:203

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

ตวั อย่างที่ 8.3 โปรแกรมตอ่ ไปจะนา้ ตวั อยา่ งที่ 8.2 มาพัฒนาเป็นโปรแกรมบวกเลข โดยปอ้ นตวั เลข
สองตวั ท่ีตอ้ งการบวกได้

#include <stdio.h>
#include <conio.h>
int x, y;
int add(int a, int b)
{

int c;
c=a+b;
return c;
}
main()
{
printf(“Input number 1 : “);
scanf(“%d”,&x);
printf(“Input number 2 : “);
scanf(“%d”,&y);
printf(“%d + %d = %d\n”, x, y, add(x,y));
getch();
return 0;
}

จากโปรแกรมจะเหน็ ว่าคอมพิวเตอรจ์ ะรบั ข้อมูลทางคีย์บอร์ดตวั แรกเข้ามาเก็บในตวั แปร x
และตวั ที่สองเขา้ มาเก็บไว้ในตัวแปร y จากนนั โปรแกรมจะเรียกใช้ฟงั กช์ ัน add โดยนา้ คา่ ในตวั แปร x
และตวั แปร y สง่ ให้ฟังก์ชันโดยผ่านทางพารามิเตอร์ a และ b จากนนั น้า a และ b มาค้านวณและคนื
คา่ c ท่เี ปน็ จา้ นวนเตม็ (int) กลบั มา และทา้ คา้ สง่ั ถัดไป

8.2 ประเภทของฟังกช์ ัน

ฟงั กช์ ันภาษาซี ถา้ แบ่งได้ตามที่มาของฟงั ก์ช่ันสามารถแบ่งออกไดเ้ ป็น 2 ประเภท คอื

1. ฟงั ก์ชันมาตรฐาน (Standard Function) เปน็ ฟงั กช์ น่ั ท่มี อี ยู่แล้ว จะเกบ็ ไว้ในไลบรารี่

204 : การเขียนโปรแกรมคอมพวิ เตอร์

เช่น ฟังก์ชันลบจอภาพ ฟังก์ชันรับตัวอักขระ ฟังก์ชันแสดงผล เป็นต้น ในการใช้งานเราต้องเรียกใช้
#include เพื่อเรียกไฟล์สว่ นหัวของโปรแกรมขนึ มากอ่ น จงึ จะสามารถเรยี กใชง้ านฟงั ก์ชันนันๆ ได้

ฟงั กช์ ันมาตรฐาน เป็นฟังกช์ ันที่ผผู้ ลติ คอมไพล์เลอร์เขียนขึนเพ่ือผู้ใชน้ า้ ไปใชใ้ นการเขียน
โปรแกรมเพ่ือให้เขียนโปรแกรมไดส้ ะดวกและงา่ ยขนึ บางครงั อาจเรียกว่า library functions ปกติ
ฟังก์ชนั เหลา่ นีจะจัดเกบ็ ไวใ้ น header files ดงั นันผใู้ ชจ้ ะต้องรวู้ ่าฟังก์ชนั นนั อยู่ใน header file ใด จึง
จะนา้ ไปเรยี กใชใ้ นส่วนต้นของโปรแกรม ดว้ ย #include <header file.h> ได้ เชน่ #include
<stdio.h> ฟงั กช์ นั มีมากมาย อาจจ้าแนกดังนี

1.1 ฟังก์ชันทางคณิตศาสตร์ เป็นฟังกช์ นั ที่ใชท้ างการค้านวณ ทางคณิตศาสตร์ ปกติอยใู่ น
math.h ผลลพั ธ์ ที่ไดจ้ ากฟงั ก์ชนั กลุม่ นเี ป็นข้อมูลประเภท double ดังนนั ตัวแปรท่ใี ชจ้ ึงเปน็ พวกท่ีมี
ชนดิ เป็น double

ฟังก์ชนั sin(x) เป็นฟังกช์ นั ใช้ค้านวณหาค่าของ sine โดย x มคี ่าของมุมในหน่วย เรเดยี น
ฟงั กช์ นั cos(x) ใช้หาค่า cosine โดย x มีหน่วยเปน็ เรเดียน(radian)
ฟังก์ชัน tan(x) ใช้หาคา่ tangent โดย x มีหน่วยเปน็ เรเดียน(radian)

ตวั อยา่ งท่ี 8.4 การใชฟ้ งั ก์ชนั ทางคณิตศาสตร์ sin, cos และ tan

#include <stdio.h>
#include <conio.h>
#include <math.h>
main()
{

float deg , angle, pi = 3.141592654; clrscr();
printf("Please enter value of angle in degree that you want to find tan cos sin :");
scanf("%f",&deg);
angle = deg * pi / 180; /* เปลยี่ นคา่ องศา ใหเ้ ป็นเรเดียน */
printf("\nvalue of tangent %4.0f degree is %4.2f ",deg,tan(angle));
printf("\nvalue of sine %4.0f degree is %4.2f ",deg,sin(angle));
printf("\nvalue of cosine %4.0f degree is %4.2f ",deg,cos(angle));
}

ฟังกช์ นั sqrt(x) ใช้หาคา่ รากทีส่ องของ x โดย x เปน็ ตัวเลขหรอื ตวั แปรท่ีไม่ตดิ ลบ
ฟงั กช์ นั exp(x) ใชห้ าคา่ ex โดย e มคี า่ ประมาณ 2.718282
ฟังกช์ นั pow(x,y) ใช้หาค่า x y
ฟงั ก์ชนั log(x) ใช้หาคา่ log ฐาน e เรยี กว่า natural logarithm โดย x เปน็ ตัวเลขหรอื ตัว
แปรทไี่ ม่ติดลบ

การเขยี นโปรแกรมคอมพวิ เตอร์:205

ฟงั ก์ชนั log10(x) ใชห้ าคา่ log ฐาน 10 โดย x เป็นตวั เลขหรอื ตวั แปรทไ่ี ม่ติดลบ
ฟังก์ชัน ceil(x) ใช้ในการปัดเศษทศนิยมของ x เมอ่ื x เป็นเลขทศนิยม
ฟงั ก์ชนั floor(x) ใชใ้ นการตัดเศษทศนยิ มของ x ทิงเมื่อ x เปน็ เลขทศนยิ ม
ฟงั ก์ชัน fabs(x) ใชใ้ นการหาค่าสัมบูรณ์ของคา่ คงท่ีหรือตัวแปรทม่ี ที ศนยิ ม โดยเปน็ บวกหรอื
ลบกไ็ ด้

ตวั อย่างที่ 8.5 โปรแกรมคานวณโดยใช้ฟังก์ชัน sqrt, exp, pow, log, ceil, floor, fabs

#include <stdio.h>
#include <conio.h>
#include <math.h>
main()
{

double x = 10.0 , y = 2.0 ,z = 16.0,a = 2.718282 , b = -2.718282 , m=1.0;
printf("\npow\(x,y\) = %4.2f when x=10.0 y=2.0", pow(x,y));
printf("\nsqrt\(z\) = %4.2f when z=16.0", sqrt(z));
printf("\nexp\(m\) = %4.6f when m=1.0",exp(m));
printf("\nlog\(a\) = %4.2f when a=2.718282",log(a));
printf("\nlog10\(x\) = %4.2f when x=10.0",log10(x));
printf("\nceil\(a\) = %4.2f when a=2.718282",ceil(a));
printf("\nceil\(b\) = %4.2f when b=-2.718282",ceil(b));
printf("\nfloor\(a\) = %4.2f when a=2.718282",floor(a));
printf("\nfloor\(b\) = %4.2f when b=-2.718282",floor(b));
printf("\nfabs\(a\) = %4.6f when a=2.718282" ,fabs(a));
printf("\nfabs\(b\) = %4.6f when b=-2.718282" ,fabs(b));
}

1.2 ฟังก์ชนั ทจ่ี ดั การเกยี่ วกบั ตัวอกั ษร(character functions) เป็นฟังกช์ นั ที่จดั การกับ
ตัวอกั ษร single char เทา่ นัน ตัวอักษรนีใชห้ นว่ ยความจ้าเพียง 1 ไบต์ ฟังกช์ ันเหลา่ นีอยใู่ น header
file ชอ่ื ctype.h ก่อนจะท้าการเขียนโปรแกรมจึงต้อง #include <ctype.h> เขา้ มาในส่วนต้นของ
โปรแกรม

ฟงั กช์ ัน isalnum(cha) เป็นฟงั ก์ชนั ที่ใช้ตรวจสอบว่าข้อมูลในตวั แปร(ซ่ึงคือตวั แปรประเภท
char ) เป็นตัวอักขระหรือตวั เลขหรอื ไม่ ถ้าเป็นตวั อักษรหรือตัวเลข ฟงั ก์ชันจะส่งค่าทไ่ี ม่ใช่ 0 มาให้ ถา้
ขอ้ มลู ในตัวแปร เปน็ อักขระพิเศษอื่นทีไ่ ม่ตัวอักษรหรือตวั เลขจะส่งค่าออกมาเปน็ 0

ฟงั กช์ ัน isalpha(cha) เปน็ ฟังกช์ ันที่ใช้ตรวจสอบว่าขอ้ มูลในตวั แปร(ซึ่งคือตวั แปรประเภท
char ) เป็นตวั อกั ขระหรือไม่ ถ้าเป็นตัวอักษรฟังก์ชันจะให้ค่าทีไ่ มใ่ ช่ 0 ออกมาถา้ เป็นตัวเลขหรืออักขระ
พิเศษอื่นฟังกช์ นั จะส่งคา่ 0 ออกมา

206 : การเขยี นโปรแกรมคอมพวิ เตอร์

ฟังกช์ นั isdigit(cha) เป็นฟังกช์ นั ที่ใช้ตรวจสอบวา่ ข้อมูลในตวั แปร(ซึง่ คือตัวแปรประเภท
char ) ฟังก์ชนั เป็นตัวเลขหรอื ไม่ ถา้ เป็นตวั เลขฟงั กช์ นั จะให้ค่าท่ีไมใ่ ช่ 0 ออกมา ถ้าเป็นตัวอักษรหรือ
อกั ขระพเิ ศษอนื่ ฟงั ก์ชนั จะส่ง 0 ออกมา
ตวั อยา่ งที่ 8.6 โปรแกรมการใช้ฟังก์ชนั จดั การตวั อักษร

#include <stdio.h>
#include <ctype.h>
#include <conio.h>
main()
{

char cha1 = 'B' ,cha2 ='3',cha3= '&';
printf("\n %d is return value of isdigit\(cha1\) of %c",isdigit(cha1),cha1);
printf("\n %d is return value of isdigit\(cha2\) of %c ",isdigit(cha2),cha2);
printf("\n %d is return value of isalpha\(cha3\) of %c ",isalpha(cha3),cha3);
printf("\n %d is return value of isalpha\(A\) of %c ",isalpha('A'),'A');
printf("\n %d is return value of isalpha\('0'\) of %c ",isalpha('0'),'0');
printf("\n %d is return value of isalpha\('$'\) of %c ",isalpha('$'),'$');
printf("\n %d is return value of isalnum\(cha1\) of %c",isalnum(cha1),cha1);
printf("\n %d is return value of isalnum\(cha2\) of %c ",isalnum(cha2),cha2);
printf("\n %d is return value of isalnum\(cha3\) of %c ",isalnum(cha3),cha3);
printf("\n %d is return value of isalnum\(A\) of %c ",isalnum('A'),'A');
printf("\n %d is return value of isalnum\('0'\) of %c ",isalnum('0'),'0');
printf("\n %d is return value of isalnum\('$'\) of %c ",isalnum('$'),'$');
}

ฟงั ก์ชัน islower(cha) ฟงั ก์ชันทใ่ี ชต้ รวจสอบว่าตัวอกั ขระในตัวแปร cha เป็นตัวพมิ พ์เล็ก
หรอื ไม่ ถา้ เปน็ ตวั พิมพ์เล็กฟังกช์ นั จะส่งค่ากลบั เปน็ จ้านวนเต็มที่ไมใ่ ช่ 0 แตถ่ า้ ไม่ใช่ตวั พมิ พเ์ ล็กจะสง่ ค่า
กลบั เปน็ 1

ฟงั กช์ นั isupper(cha) ฟงั ก์ชันที่ใชต้ รวจสอบว่าตวั อกั ขระในตัวแปร cha เปน็ ตวั พิมพ์ใหญ่
หรือไม่ ถา้ เป็นตวั พิมพ์ใหญ่ ฟังกช์ ันจะส่งคา่ กลับเปน็ จา้ นวนเต็มท่ไี มใ่ ช่ 0 แต่ถ้าไม่ใชต่ วั พมิ พใ์ หญจ่ ะส่ง
คา่ กลบั เปน็ 0

ฟังก์ชัน tolower(cha) ฟงั กช์ ันทใ่ี ช้เปลีย่ นตวั พิมพ์ใหญ่ท่ีเกบ็ อยใู่ นตวั แปรใหเ้ ป็นตัวพิมพเ์ ล็ก
ฟงั กช์ ัน toupper(cha) ฟังก์ชันท่ใี ช้เปล่ยี นตัวพิมพ์เลก็ ท่ีเกบ็ อยู่ในตัวแปรให้เปน็ ตัวพิมพ์ใหญ่

ตวั อยา่ งท่ี 8.7 โปรแกรมแสดงค่า upperlower

#include <stdio.h>
#include <ctype.h>
#include <conio.h>
main()
{

char cha1 = 'D' , cha2 = 'a' ,cha3 = 'f' , cha4 = 'N'

การเขยี นโปรแกรมคอมพวิ เตอร์:207

printf("\ncheck cha1 = 'D' is uppercase yes or no : %d ",isupper(cha1));
printf("\ncheck cha2 = 'a' is lower yes or no : %d ",islower(cha2));
printf("\ncheck cha2 = 'a' is upper yes or no : %d ",isupper(cha2));
printf("\ncheck 'i' is lower yes or no : %d ",islower('i'));
printf("\ncheck 'L' is uppercase yes or no : %d ",isupper('L'));
printf("\nchange cha3 = 'f' to uppercase %c : ", toupper(cha3));
printf("\nchange cha4 = 'N' to lowercase %c : ", tolower(cha4));
}

ฟงั กช์ นั isspace(cha) ฟังก์ชนั ทใี่ ชต้ รวจสอบว่าข้อมูลในตวั แปร cha เป็น whitespace
หรอื ไม่ whitespace ได้แก่ space ,tab ,vertical tab ,formfeed ,carriage retun ,newline ถ้ามี
whitespace จริง ฟังก์ชันจะสง่ คา่ ไมเ่ ท่ากับ 0 ถา้ ไมจ่ ริงจะส่งค่า 0

ฟงั ก์ชนั isxdigit(cha) ฟงั ก์ชนั ที่ใชต้ รวจสอบวา่ ขอ้ มูลในตวั แปร cha เป็น เลขฐานสิบหก
( คือ 0-9 , A-F , a – f) หรอื ไม่ ถา้ จริงส่งคา่ ตัวเลขท่ีไมใ่ ช่ 0 ถ้าไมจ่ ริงสง่ ตัวเลข 0

ตัวอย่างท่ี 8.8 โปรแกรมตรวจสอบวา่ เปน็ เลขฐานสบิ หก

#include <stdio.h>
#include <conio.h>
#include <ctype.h>
main()
{

char cha1 ='\r',cha2= '\n',cha3='\v' ,cha4 ='A';
clrscr();
printf("\n%d is volue return from isspace %c ",isspace(cha1),cha1);
printf("\n%d is volue return from isspace %c ",isspace(cha2),cha2);
printf("\n%d is volue return from isspace %c ",isspace(cha3),cha3);
printf("\n%d is volue return from isxdigit %c ",isxdigit(cha4),cha4);
printf("\n%d is volue return from isxdigit %c ",isxdigit('0'),'0');
printf("\n%d is volue return from isxdigit %c ",isxdigit('g'),'g');
}

ฟงั ก์ชนั gotoxy(x,y); เปน็ ฟงั กช์ นั อย่ใู น conio.h ใช้สงั่ ให้เคอร์เซอร์เคลื่อนที่ไปตามต้าแหน่ง
ท่รี ะบุ โดย x คอื ต้าแหน่งของสดมภ์บนจอภาพ (คล้ายคา่ x ของกราฟ)ค่าเพ่มิ จากซา้ ยไปขวามคี ่าตงั แต่
1 ถงึ 79 ต้าแหนง่ ท่ี 80 สงวนไวไ้ ม่ให้ใช้
สว่ น y คือต้าแหน่งแถวบนจอภาพนับจากบนลงลา่ ง มีค่าได้ตังแต่ 1 ถงึ 24 ตา้ แหน่งท่ี25 สงวนไว้

ฟังก์ชนั clreol(); เป็นฟงั กช์ ันอยู่ใน conio.h ใชล้ บขอ้ ความตงั แตต่ า้ แหนง่ ที่เคอรเ์ ซอร์อย่ไู ป
จนจบบรรทัด

208 : การเขียนโปรแกรมคอมพวิ เตอร์

ฟังก์ชัน delline(); เป็นฟังก์ชนั อยู่ในconio.h ใชล้ บขอ้ ความทังบรรทัดที่เคอรเ์ ซอร์อยู่ไปจน
จบบรรทดั และเลื่อนข้อความในบรรทดั ล่างขนึ มาแทน

ฟังกช์ นั insline(); เป็นฟงั ก์ชันอยู่ในconio.h ใช้แทรกบรรทัดวา่ ง 1 บรรทัดใตบ้ รรทัดที่
เคอร์เซอรอ์ ยู่

ฟงั ก์ชนั system(“dos command”); เป็นฟงั ก์ชนั อย่ใู นstdlib.h ใช้เรียกค้าสั่งของ dos
ขนึ มาทา้ งาน เช่นค้าสง่ั cls dir date time

ฟงั กช์ ัน abort(); ฟงั กช์ นั ท่ีอยู่ใน <stdlib.h> ใช้ ยกเลิกการทา้ งานของโปรแกรมทันทีไมว่ า่
จะทา้ งานส้าเร็จหรือไม่ และมีข้อความ Abnomal program termination แสดงทางจอภาพ

ฟังกช์ นั abs(x); ฟังกช์ ันที่อย่ใู น <stdlib.h> ใชห้ าค่าสัมบูรณข์ อง x โดย x ตอ้ งเป็นจ้านวน
เต็ม

ฟังก์ชัน labs(x); ฟังก์ชันทอ่ี ยใู่ น <stdlib.h> ใช้หาคา่ สมั บรู ณข์ อง x โดย x ตอ้ งเป็นlong
integer

ฟงั กช์ ัน atoi(s); ฟงั กช์ นั ท่ีอยู่ใน <stdlib.h> ใชเ้ ปลีย่ นขอ้ ความใหเ้ ป็นเลขจา้ นวนเต็ม
ฟงั ก์ชัน atol(s); ฟงั ก์ชันท่อี ยู่ใน <stdlib.h> ใชเ้ ปลี่ยนขอ้ ความใหเ้ ปน็ long integer
ฟงั กช์ นั atof(s); ฟงั ก์ชนั ที่อยใู่ น <stdlib.h> ใช้เปลีย่ นข้อความใหเ้ ป็น floating point

ตัวอย่างท่ี 8.9 โปรแกรมตรวจสอบฟังกช์ นั atoi, atoll และ atof

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{ char numstring1[10],numstring2[10],numstring3[10];

int in1; float flo1; long lon1; clrscr();
printf("\nEnter number as string1 : ");
scanf("%s",numstring1);
printf("\nEnter number as string2 : ");
scanf("%s",numstring2);
printf("\nEnter number as string3 : ");
scanf("%s",numstring3);
in1 =atoi(numstring1); flo1 = atof(numstring2); lon1=atol(numstring3);
printf("nnumstring1 =%s change to integer %d ",numstring1,in1);
printf("\nnumstring2 =%s change to floating point %4.4f ",numstring2,flo1);
printf("\nnumstring3 =%s change to long integer %d ",numstring3,lon1);
printf("\nsummation of in1,flo1,lon1 is %6.4f ",in1+flo1+lon1);
printf("\nsummation of atoi(numstring1),atof(numstring2),atol(numstring2)
is %6.4lf:",atoi(numstring1)+atof(numstring2)+atol(numstring3));
}

การเขยี นโปรแกรมคอมพิวเตอร์:209

2. ฟงั ก์ชันท่ผี ูเ้ ขียนโปรแกรมสร้างขนึ้ (User-defined Function) เปน็ ฟงั ก์ชนั หรือโปรแกรม
ย่อยทผ่ี ใู้ ชส้ ร้างขึนมาใช้ในโปรแกรม เพื่อท้างานใดงานหนึง่ ซ่งึ ท้าให้โปรแกรมดูง่ายขนึ และลดความ
ซบั ซอ้ นลง เพอื่ ท้างานบางอย่างตามความตอ้ งการ

รปู แบบฟงั ก์ชัน

ทังฟงั ก์ชันมาตรฐานและฟังก์ชนั ท่ีผูใ้ ชส้ รา้ งขนึ มีรปู แบบ ดงั นี

type function_name(type1 arg1,type2 arg2,...,typeN argN)
{

local varilabel declarations;
statement_1;
statement_2;

...
statement_N;
return(value)
}

โดย
type คือ ประเภทของข้อมูลทส่ี ง่ กลับ สว่ นนีจะมีหรอื ไม่มีกไ็ ด้ ขึนอยกู่ บั การท้างานของฟงั กช์ ัน

ถ้าหากฟังกช์ ันไมม่ ีการส่งคา่ กลับสว่ นนีจะประกาศเปน็ void ชนิดของฟังกช์ นั หรอื ชนิดของข้อมูล
เช่น int , float , char , double , void ท่ีสง่ ไปให้ต้าแหน่งที่เรียกใช้ ถ้าไมม่ ีการสง่ ค่ากลบั ไปให้
ตา้ แหนง่ ที่เรยี กใช้ จะใช้ void ถา้ ไมม่ ีการกา้ หนด จะไดข้ ้อมลู ทส่ี ง่ กลับมาเปน็ int เสมอ

Function_name คือ ช่ือของฟังกช์ นั ทสี่ ร้างขึน ควรตงั ชือ่ ใหส้ ื่อความหมายถงึ การท้างานของ
ฟังก์ชัน ชื่อฟงั ก์ชัน สามารถเรียกใช้งานผา่ นชอ่ื นไี ดโ้ ดยการตังชอื่ จต้องเปน็ ไปตามกฏการตงั ชื่อของ
ภาษาซี

type1 arg1,type2 arg2,...,typeN argN เป็นชนิดและช่ือของ argument หรอื พารามิเตอร์
เปน็ ตัวแปรหรอื พารามิเตอร์ท่ีใช้รบั ค่าผ่านเขา้ มาในฟังกช์ ัน สว่ นนีจะมหี รอื ไมม่ ีกไ็ ด้ ขนึ อยู่กบั การท้างาน
ของฟังก์ชัน parameter ค่าท่ี 1 , 2ถงึ N ท่ีจะรับมาจากผูเ้ รียกใชฟ้ งั กช์ นั ถา้ เป็นฟังกช์ นั ที่ไม่มีการรับ
และสง่ คา่ parameter จะใช้คา้ วา่ void

{ จดุ เริม่ ต้นของฟังก์ชนั
location variable declaration คือ สว่ นท่ีมกี ารประกาศชนดิ และชือ่ ของตวั แปรที่จะใช้
เฉพาะในฟังก์ชัน โดยสว่ นท่ีอยฟู่ งั ก์ชัน จะไม่สามารถเรยี กใชต้ ัวแปรเหล่านีได้
statement_1; statement_2; ... statement_N เปน็ ค้าสง่ั ที่ใช้งานในฟังก์ชนั

210 : การเขยี นโปรแกรมคอมพวิ เตอร์

return(value); คอื คา้ สั่งท่ีใชส้ ่งข้อมลู หรอื ค่าทเ่ี ปน็ ผลลัพธจ์ ากการประมวลผลใน
ฟังกช์ นั ปใหผ้ เู้ รยี กใช้ฟังกช์ ัน โดยชนดิ ของข้อมลู ท่สี ่งต้องเป็นชนิดเดียวกับชนิดของฟังกช์ ันหรอื ชนดิ ของ
ขอ้ มลู ของฟังก์ชนั ถา้ เปน็ ฟงั กช์ นั ทไี่ ม่มีการสง่ ค่า(void) จะไมต่ ้องใชค้ ้าสัง่ return

} สว่ นสิ้นสุดของฟังก์ชัน

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

1. ฟงั ก์ชนั ที่ไมม่ ีการรบั การส่งค่าใด ๆ ในการเรียกใชฟ้ ังกช์ นั
2. ฟงั ก์ชนั ที่ต้องรับคา่ parameter หรอื argument เข้าในการท้างานในฟงั ก์ชัน
3. ฟังก์ชนั ท่ีต้องรบั คา่ parameter เข้ามาในการท้างานและส่งค่ากลบั ไปให้ตา้ แหน่งที่
เรียกใช้

1.1 ฟงั ก์ชันที่ไมม่ ีการรบั และส่งค่า
การเรียกใชฟ้ ังก์ชันประเภทนี ไมต่ ้องสง่ ค่าอาร์กเู มนต์(argument) หรอื พารามเิ ตอร์

(parameter) ใด ๆ ไปให้ฟงั ก์ชนั และฟงั กช์ นั กไ็ มม่ ีการสง่ ค่าใดกลับมาให้ ส่วนมากจะใช้แสดง
รายละเอยี ดหรือข้อความท่ีตอ้ งแสดงบอ่ ย ๆ

โครงสรา้ งของฟังก์ชนั ทไี่ ม่มีการรับส่งคา่
void functionname(void)
{
local variable declaration;
statements;
}

หรือ functionname()
{ local variable declaration; statements; }

ฟงั กช์ ันประเภทนีจะไม่มีฟงั ก์ชนั return () อยูใ่ นฟงั กช์ ัน

การเขยี นโปรแกรมคอมพิวเตอร์:211

ตวั อย่างท่ี 8.10 โปรแกรมฟังก์ชันท่ไี ม่มีการรับสง่ ค่า

#include<stdio.h>
message()
{
printf("************ C Language *********** \n");
}

void main()
{ printf("First Message\n");

message();
printf("Second Message\n");
message();
printf("Third Message\n");
message();
}

ตวั อยา่ งท่ี 8.11 ฟงั ก์ชันแสดงรายชือ่ ภาพยนตร์ทก่ี ้าลงั เข้าฉาย โดยใหผ้ ู้ใช้เลอื กว่าต้องการตรวจสอบ
รายการภาพยนตร์หรือไม่

#include<stdio.h>
void movie()
{ printf("Now showing \n");

printf("1.Spider man \n");
printf("2.Harry Potter \n");
printf("3.Resident Evil \n");
}
void main()
{
char ans;
printf("Do you want to check movies program? (y/n)");
scanf("%c",&ans);
if(ans=='y')

movie();
else

printf("Thank you");
}

2.2 ฟงั ก์ชันท่มี ีการรบั คา่ แต่ไมม่ ีการส่งคา่ กลบั

212 : การเขยี นโปรแกรมคอมพวิ เตอร์

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

โครงสรา้ งของฟังก์ชนั ทม่ี ีการรับคา่ พาราเตอรแ์ ตไ่ ม่มีการส่งค่ากลับ

void functionname(type arg1,type arg2,…,type argN)

{
local variable declaration;
statements;

} /* end function */

หรือ

functionname(type arg1,type arg2,…,type argN)
{
local variable declaration; statements;
}

ตัวอย่างที่ 8.12 ตัวอย่าง ฟังกช์ นั ที่มีการรับคา่ แต่ไม่มีการสง่ ค่ากลบั

#include <stdio.h>
float inputFloat()

{
float x;
printf(“\n Input value :”);
scanf(“%f”,&x);
return(x);

}
float SumFloat(floatx,float y)
{

return (x*y);
}
void PrintOut( float x)
{
printf(“\n Result is %.2f”,x);
}
void main()
{
float a,b,result;
a = inputFloat();
b = inputFloat();
result = SumFloat(a,b);

การเขยี นโปรแกรมคอมพวิ เตอร์:213

PrintOut(result);
}

2.3 ฟังกช์ ันทีม่ ีการรับคา่ และสง่ ค่ากลับ
ฟังกช์ ัน ประเภทนี ตอ้ งมีทังชนิดของฟงั ก์ชนั และอาร์กูเมนต์ และในโครงสร้างต้องมี

ค้าสั่ง return (value)เพือ่ ส่งคา่ กลบั ยกเว้นกรณีท่ีใช้ตัวแปรพอยน์เตอร์ มาเป็นตัวรบั ส่งค่า กอ็ าจไม่
ต้องมีคา้ ส่ัง return

โครงสร้างของฟังกช์ ัน

type functionname(type arg1,type arg2,...,type argN)
{
local variable declaration;
statements;
return(value);
}

ตัวอย่างท่ี 8.13 ตัวอยา่ งฟงั ก์ชนั ทม่ี ีการรับค่าและสง่ ค่ากลับ โปรแกรมคา้ นวณเงนิ ทอนลูกค้า โดยเม่ือ
ลกู ค้าซือสนิ คา้ โปรแกรมจะท้าการรับค่าราคาสนิ คา้ และจา้ นวนเงนิ ลูกคา้ และสรา้ งฟงั ก์ชนั คิดเงนิ ทอน
ขึน

#include<stdio.h>
float cal_change(float price,float money)
{

float z;
z = money-price;
return(z);
}
main()
{
float price,money,change;
printf("Enter good price :"); scanf("%f",&price);
printf("Enter receive money :"); scanf("%f",&money);
change = cal_change(price,money);
printf("Customer change =%.2f \n",change);

}

214 : การเขียนโปรแกรมคอมพวิ เตอร์

8.3 การประกาศโปรโ์ ตไทป์ (Prototypes) ของฟงั กช์ นั

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

รปู แบบ

ประเภทข้อมลู ชอื่ ฟงั กช์ ัน(ประเภท พารามเิ ตอร์1 ,…., พารามเิ ตอร์

N);

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

#include <stdio.h>
double volume (double s1, double s2, double s3);
double volume (double s1, double s2, double s3)
{

return s1*s2*s3;
}
main()
{

double vol;
vol = volume(12.2, 5.67, 9.03);
printf(“Volume : %f”, vol);
return 0;
}

การเขยี นโปรแกรมคอมพวิ เตอร์:215

ตัวอย่างท่ี 8.15 โปรแกรมต่อไปนเี ป็นตัวอยา่ งการสรา้ งฟงั กช์ นั ทไ่ี ม่มีการคนื คา่ 3 ฟงั กช์ ัน แตล่ ะ
ฟงั ก์ชนั ให้พมิ พช์ นั ใหพ้ ิมพ์ตัวอกั ษรตา่ งๆ และจะสรา้ งฟังก์ชนั ไว้หลงั main()

#include <stdio.h>
#include <conio.h>
void P_AAA();
void P_BBN();
void P_CCC();
main()
{

P_AAA();
P_BBB();
P_CCC();
getch();
return 0;
}
void P_AAA()
{
int j;
for(j=1; j<20; j++)

printf(“A”);
printf(“\n”);
}

ตวั อย่างท่ี 8.16 ตวั อยา่ งนเี ปน็ ตวั อย่างการฟงั กช์ นั ท่มี ีการสง่ ข้อมูลทเ่ี ป็นตัวเลขออกไป 3 ค่า จากนนั
ฟังก์ชันจะคืนค่าสูงสดุ ออกมา

void P_BBB()
{
int j;

for(j=1; j<20; j++)
printf(“B”);

printf(“\n”);
}
void P_CCC()
{
int j;

for(j=1; j<20; j++)
printf(“C”);

printf(“\n”);
}

216 : การเขยี นโปรแกรมคอมพวิ เตอร์

เม่อื รนั โปรแกรม คอมพวิ เตอร์จะรบั ข้อมลู ทางแปน้ พิมพ์เข้าไปสามค้า และแสดงคา่ สงู สุด
ออกมา ดงั ตัวอยา่ งผลการรันตอ่ ไปนี

enter three integers : 22 85 17

Maximum is : 85

8.4 ตวั แปรทั่วไปและตัวแปรเฉพาะท่ี

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

ตวั แปรแบบท่ัวไป (global variables) คือตวั แปรท่ปี ระกาศไวน้ อกฟงั กช์ ัน ตัวแปรประเภท
นีทกุ ส่วนของโปรแกรมสามารถเรียกใช้ได้ ทา้ ให้ฟังกช์ นั ย่อยๆ และฟังกช์ นั หลกั สามารถเรยี กใช้ตวั แปร
ประเภทนไี ด้ทนั ที แต่คา่ ของมันจะเปลีย่ นแปลงไปตามที่ฟงั ก์ชนั นนั ๆ เรียกใช้

ตวั แปรแบบเฉพาะที่ (local variables) เปน็ ตัวแปรทใ่ี ช้งานภายในฟังกช์ ันเฉพาะนนั ๆ
ฟงั กช์ ันเดยี ว การประกาศตัวแปรประเภทนจี ะประกาศภายในฟังก์ชัน ซ่ึงจะทา้ ให้ฟังกอ์ ่ืนไมส่ ามารถ
เรียกใช้ฟังกช์ นั นันได้ แต่ฟังกช์ นั อน่ื ก็สามารถประกาศตัวแปรช่ือซ้ากับตัวแปรนันได้ ซง่ึ ตัวแปรชอ่ื
เดยี วกนั แตป่ ระกาศในตา่ งฟังกช์ ันจะเป็นตัวแปรคนละตวั กัน ละเม่ือออกจากฟงั ก์ชนั ค่าของตัวแปรชนดิ
นีจะหายไป ไมเ่ หมือนตวั แปรแบบท่วั ไป

การเขยี นโปรแกรมคอมพวิ เตอร์:217

ตวั อย่างที่ 8.17 ตัวอย่างการเขยี นโปรแกรมประกาศตวั แปร

#include <stdio.h>
int maximum(int, int, int);
main()
{

int a,b,c;
printf(“enter three integers : “);
scanf(“%d%d%d”, &a, &b, &c);
printf(“maximum is : %d\n”, maximum(a,b,c);
return 0;
}
int maximum(int x, int y, int z)
{
int max =x ;
if(y> max)

max = y;
if (z>max)

max = z;
return max;
}

ตัวอยา่ งที่ 8.18 เปน็ ตวั อยา่ งการใชต้ ัวแปรแบบทั่วไปรว่ มกบั ฟังก์ชนั ในโปรแกรมจะสร้างฟงั กช์ ันชอ่ื
Ex ภายในฟังก์ชันจะใสค่ ่า 5 ให้กบั ตัวแปร a

#include “stdio.h>
int A;
void Ex()
{

A= 5;
printf(“%d\n”,A);
main()
{
A = 3;
Printf(“%d\n”,A);
Ex();
Print(“%d\n”,A);
Return 0;
}

218 : การเขียนโปรแกรมคอมพวิ เตอร์

ผลการรนั โปรแกรม

3
5
5

การท้างานของโปรแกรมนันจะมตี ัวแปร a เปน็ ตวั แปรแบบทวั่ ไปซ่งึ ทุกสว่ นของโปรแกรม
สามารถเรียกใช้ได้ ในโปรแกรมหลกั จะใส่คา่ 3 ให้กับตัวแปร a และพมิ พ์คา่ ในตวั แปร a ซง่ึ จะได้เปน็ 3
ตอ่ มาเรียกใชฟ้ งั ก์ชัน Ex โดยในฟังกช์ ันจะใส่ค่า 5 ให้กับตัวแปร a และพิมพ์คา่ จะไดเ้ ป็น 5 ต่อมาเม่ือ
จบฟังก์ชัน Ex โปรแกรมจะพิมพค์ ่า a อีกครัง ซ่ึงจะได้ผลลัพธ์เปน็ 5 เนอ่ื งจากคา่ ในตวั แปรได้เปล่ยี นไป
จากการท้างานของฟงั กช์ นั Ex

ตวั อยา่ งที่ 8.19 เปน็ ตวั อย่างการใช้ตัวแปรแบบเฉพาะท่ี โดยในฟงั ก์ชนั Ex มกี ารประกาศตวั แปรแบบ
เฉพาะท่ชี อ่ื a ซง่ึ เป็นชอื่ เดียวกับตวั แปรแบบท่วั ไป

#include “stdio.h”
int A;
void Ex()
{

Int A;
A = 5;
printf(“%d\n”,A);
}
Main()
{
A = 3;
printf(“%d\n”,A);
Ex();
printf(“%d\n”,A);
return 0;
}

การเขยี นโปรแกรมคอมพิวเตอร์:219

ผลการรันโปรแกรม

3
5
3

การท้างานของโปรแกรมนนั ฟงั กช์ ันหลักจะใสค่ า่ 3 ให้กบั ตัวแปร a โดยฟงั กช์ นั หลักจะเรียกใช้
ตัวแบบทว่ั ไป จากนันโปรแกรมจะพิมพ์ค่าในตัวแปร a ซง่ึ ทา้ ใหผ้ ลลพั ธท์ ี่ไดเ้ ป็น 3 ต่อมามีการเรยี กใช้
ฟังกช์ ัน Ex() โดยในฟงั ก์ชนั จะมกี ารประกาศตวั แปรแบบเฉพาะช่ือ a และใสค่ า่ 5 ใหก้ ับตัวแปร เมือ่
ฟงั กช์ ัน Ex() ทา้ งานจะพิมพค์ ่า 5 เม่อื จบจากฟงั ก์ชนั และกลับมาทา้ งานฟงั กช์ นั หลกั ให้พิมพค์ า่ ในตวั
แปร a อีกครงั ท้าให้ค่าท่ไี ด้เปน็ 3 ตามเดมิ เนื่องจากถ้ามีการประกาศตวั แปรแบบเฉพาะทใี่ นฟังกช์ ันจะ
ใช้ตวั แปรตัวนัน ท้าใหค้ ่าในตัวแปร a ทีเ่ ปน็ ตัวแปรแบบท่ัวไปทีป่ ระกาศนอกฟังก์ชนั มีค่าเท่าเดมิ

8.5 ฟงั ก์ชนั แบบเรียกซา้

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

0!=1
1!=1
2!=2*1
3! = 3 * 2 * 1

ซ่งึ สามารถเขียนฟงั กช์ ันแฟคทอเรยี ลในรูปแบบของความสัมพันธไ์ ด้ดังนี n ! = 1 ในกรณี n =
0 n ! = n * (n-1) * (n-2) * … * 3 * 2 * 1 ในกรณีท่ี n >0 กรณที ี่ n = 0 เป็นจดุ สินสดุ ของการเรยี ก
ตวั เอง ในกรณีของแฟคทอเรียลฟงั ก์ชนั แสดงโปกรแกรมดังตัวอยา่ งท่ี 4.11

220 : การเขียนโปรแกรมคอมพวิ เตอร์

ตัวอย่างที่ 8.20 แสดงแฟคทอเรียลฟงั ก์ชนั ในลกั ษณะของฟังก์ชนั เรียกตวั เอง

#include <stdio.h>
long int fac ( int n )
{
if (n == 0)
return ( 1 );
else
return ( n * fac(n-1) );
}
main ( )
{
int n;
printf (“Input n :> “);
scanf(“%d” , &n);
printf(“ %d factorial is :> %ld “, n, fac(n) );
}

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

ตวั อยา่ งท่ี 8.21 แสดงแฟคทอเรยี ลฟงั ก์ชนั ในลกั ษณะของฟงั ก์ชนั ปกติ

#include <stdio.h>
long int fac ( int n) {
long int result=1;
int I;
for (i = n; i > 0; i-- )
result *= i;
return ( result );
}
main ( ) {
int n;
printf (“Input n :> “);
scanf(“%d” , &n);
printf(“ %d factorial is :> %ld “, n, fac(n) );
}

การเขยี นโปรแกรมคอมพวิ เตอร์:221

ตวั อย่างท่ี 8.22 การหาคา่ เลขยกกา้ ลงั ดว้ ยฟังกช์ นั แบบเรียกซ้า

#include <stdio.h>
float power (float val, int pow) {
if (pow == 0)
return(1.0);
else
return(power(val, pow-1) * val);
}
void main( ) {
float b=10.0, ans;
int p=4;
ans = power ( b, p );
printf(“Answer of %f power %d is %f”, b, p, ans);
}

สรุป

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

222 : การเขียนโปรแกรมคอมพวิ เตอร์

แบบฝกึ หัด

1. หาที่ผดิ พลาดของคา้ สงั่ ตอ่ ไปนี และแก้ไขใหถ้ ูกต้อง

pa1 = a; . .

pf1 = f; . .

pf2 = &a; . .

pf1 = pf2 + pa2; . .

printf(“\nf = %.2f”, pf1); . .

pa2 = &pa1; . .

printf(“\na = %d”, pa1); . .

2. เขียนโปรแกรมเพอ่ื ค้านวณเลขยกกา้ ลงั โดยรับคา่ เลขฐานและเลขยกก้า ลังจากผใู้ ช้ โดยใช้โปรโต
ไทปท์ ่ีกา้ หนด ดังนี รับข้อมูล void readData (float *, int * );
ค้านวณ float power (float *, int );
ก้าหนดให้ข้อมลู ที่เข้าสฟู่ ังกช์ ันทงั 2 คือ เลขฐานและเลขยกก้าลงั ตามลา้ ดับ

3. เขียนโปรแกรมเพ่ือท้าการหาผลบวกของอนุกรม โดยก้าหนดใหร้ บั ค่าตัวเลขเริ่มต้นของอนกุ รม
และตัวเลขสดุ ท้ายของอนกุ รม จากนนั น้าตัวเลขทังหมดในอนุกรมนนั มาบวกกนั สมมติ ตวั เลข
เรมิ่ ต้น คอื 5 ตวั เลขตัวสุดทา้ ยคือ 10 จะท้า การนา้ ตวั เลขตังแต่ 5 – 10 มาบวกกนั ผลลพั ธ์ท่ไี ด้
คือ 45 เป็นตน้
ก้าหนดให้เขียนฟังกช์ ัน cal( ) ท้าหนา้ ทคี่ ้านวณหาผลบวกของอนุกรมดงั กล่าว ซ่ึงมีโปรโตไทป์
ดังนี

void cal ( int, int, long * ) ;

โดยทข่ี ้อมลู เข้าฟังกช์ นั ตวั แรก คอื เลขเรมิ่ ต้น ตัวที่ 2 คือ เลขสุดทา้ ย และตัวสุดทา้ ย คอื
ผลรวม

4. เขยี นโปรแกรมเพ่ือท้า การคา้ นวนค่าจา้ งของพนักงาน โดยกา้ หนดใหร้ บั คา่ จ้านวนช่ัวโมงการ
ทา้ งาน (Hour) และประเภทของงานท่พี นักงานทา้ (Type) โดยมีขอ้ กา้ หนดในการคา้ นวณดงั นี
ประเภทของงาน อัตราคา่ จา้ ง / ชัว่ โมง
0 30
1 40

การเขยี นโปรแกรมคอมพวิ เตอร์:223

2 45
3 50
หากผใู้ ชป้ อ้ นประเภทของงานนอกเหนือจากประเภทงานดังกลา่ ว จะแสดงข้อความวา่ “Error Data”
กา้ หนดใหเ้ ขียนฟังกช์ ันเพ่ือรับขอ้ มลู ประเภทของงาน และอัตราค่าจา้ งตอ่ ชั่วโมงไว้ในฟังก์ชันเดียวกัน
และเขยี นฟังกช์ นั cal ( ) ท้าหนา้ ทค่ี ้านวณค่าจ้างของพนกั งาน ซึ่งมีโปรโตไทปด์ ังนี
void cal ( char , int, float * ) ;
โดยท่ีข้อมูลเขา้ ฟังกช์ นั cal( ) ตวั แรกคือประเภทของงาน ตัวท่ี 2 คือ ชัว่ โมงท้า งาน ตัวที่ 3 คือ ค่าจ้าง
ทีไ่ ด้

224 : การเขยี นโปรแกรมคอมพวิ เตอร์

เอกสารอ้างอิง

กวิน สินรุ่งเรือง. (2554). คู่มอื เรียนการเขียนโปรแกรมภาษาซี. กรงุ เทพฯ:สา้ นกั พมิ พ์แหง่ จฬุ าลงกรณ์
มหาวิทยาลยั .

ไกรศร ตังโอภากุล และกิตนิ นั ท์ พลสวสั ด.์ิ (2556). คมู่ ือเรยี นเขียนโปรแกรมภาษา C ฉบบั สมบรู ณ์
พมิ พ์ครังท่ี 1 . นนทบุรี : ไอดีซี.

ไกรศร ตังโอภากุล. (2554). คมู่ อื เรยี นเขียนโปรแกรมภาษา C. พมิ พ์ครังที่ 1. นนทบุรี:ไอดซี ี.
ฝ่ายต้าราทางวชิ าการคอมพวิ เตอร์. (2556). ค่มู ือเรยี นคอมพวิ เตอร์และการบารงุ รักษา. กรงุ เทพฯ: ซเี

เอด็ ยูเคชนั่ จา้ กัด.
ฝา่ ยตา้ ราทางวิชาการคอมพวิ เตอร.์ (2555). ค่มู ือเรียนคอมพิวเตอรภ์ าษาC. กรงุ เทพฯ: ซีเอด็ ยเู คชน่ั

จ้ากดั (มหาชน).
ธรี วัฒน์ ประกอบผล.(2556). คู่มือการเขียนโปรแกรมภาษา C ฉบับสมบูรณ.์ พิมพ์ครังที่ 1. กรุงเทพฯ.

ส้านกั พมิ พ์ ซิมพลฟิ าย.
วิจักษณ์ ศรสี จั จะเลศิ วาจา และดุษฎี ประเสริฐธติ พิ งษ.์ (2545). การเขียนโปรแกรมภาษาซี.

ภาควิชาวิทยาการคอมพิวเตอร์ คณะวิทยาศาสตร์ มหาวทิ ยาลัยเชียงใหม.่
โอภาส เอยี่ มสริ ิวงศ์ . (2552). การเขียนโปรแกรมดว้ ยภาษา C.กรุงเทพฯ: ซีเอ็ดยเู คช่นั .
ศริ ิชยั นามบรุ .ี (2557). (ออนไลน)์ . แหลง่ ที่มา :

http://www.scribd.com/doc/33490603/ สบื คน้ เม่ือ (14 กุมภาพนั ธ์ 2557)

อรพิณ ประวตั ิบริสุทธ.ิ์ (2556). ค่มู ือเขียนโปรแกรมดว้ ย ภาษา C ฉบบั สมบูรณ์. กรงุ เทพมหานคร :
บรษิ ทั โปรวชิ นั จา้ กัด.

http://alaska.reru.ac.th/5583709/C6.pdf สบื คน้ เมือ่ (12 กุมภาพนั ธ์ 2557)
http://krooa.files.wordpress.com/2013/07/cprogrammingv2-6.pdf สืบค้นเมื่อ (15 มีนาคม

2557)

http://kanokwan.sru.ac.th/e-learning/12.php สบื คน้ เม่อื (25 เมษายน 2557)

www.pdp.ac.th/30220/ppt/slide02_array.ppt สืบคน้ เม่อื (25 เมษายน 2557)
www.it.nrru.ac.th/krit/411101/Chap_10.ppt สืบค้นเม่ือ (25 เมษายน 2557)

การเขียนโปรแกรมคอมพวิ เตอร์ :225

แผนบรหิ ารการสอนประจาบทท่ี 9

รายวิชา การเขยี นโปรแกรมคอมพิวเตอร์
Computer Programming

หวั ข้อเนอ้ื หา
9.1 ความรทู้ ั่วไปเกี่ยวกับโครงสรา้ ง
9.2 การประกาศขอ้ มลู แบบโครงสร้าง
9.3 การอ้างถึงสมาชิกของตัวแปรโครงสรา้ ง
9.4 การใช้ข้อมลู แบบโครงสร้างกบั ฟังกช์ นั
9.5 การใช้ตวั แปรแถวลาดับเป็นสมาชกิ ของโครงสรา้ ง
9.6 ขอ้ มลู โครงสร้างซ้อนโครงสรา้ ง
9.7 ยูเนยี น

วตั ถปุ ระสงค์เชงิ พฤติกรรม

1. เพอื่ ให้ผ้เู รยี นมีความเข้าใจเกยี่ วกับการกาหนดข้อมลู โครงสร้าง
2. เพ่อื ใหผ้ ู้เรียนอธบิ ายเก่ียวกับการเกบ็ ขอ้ มลู แบบโครงสร้าง
3. เพอ่ื ใหผ้ ู้เรียนมีความเขา้ ใจเกี่ยวกบั ข้อมลู โครงสรา้ งกบั ฟังกช์ นั ได้
4. เพื่อให้ผู้เรียนเขียนโปรแกรมโดยใช้ขอ้ มลู โครงสรา้ งกับฟังกช์ นั ได้
5. เพ่ือให้ผู้เรียนอธบิ ายเกย่ี วกับแถวลาดับเป็นสมาชิกของโครงสร้างได้
6. เพ่อื ให้ผเู้ รยี นเขยี นโปรแกรมโดยใชต้ วั แปรแถวลาดบั เปน็ สมาชกิ โครงสร้างได้
7. เพือ่ ให้ผเู้ รยี นเขียนโปรแกรมโครงสรา้ งซ้อนโครงสร้างได้
8. เพื่อใหผ้ ู้เรียนเขียนโปรแกรมในลกั ษณะยูเนียนได้

วธิ สี อนและกิจกรรมการเรียนการสอนประจาบท
1. บรรยายเน้อื หาในแต่ละหวั ขอ้ พร้อมยกตัวอย่างประกอบ
2. ศกึ ษาจากเอกสารประกอบการสอน
3. ผสู้ อนสรุปเนอื้ หา
4. ทาแบบฝกึ หดั เพอ่ื ทบทวนบทเรียน
5. ผู้เรียนถามข้อสงสยั
6. ผูส้ อนทาการซักถาม

226:การเขยี นโปรแกรมคอมพวิ เตอร์

สอ่ื การเรียนการสอน

1. เอกสารประกอบการสอนวิชาการโปรแกรมคอมพวิ เตอร์
2. ภาพเลอื่ น (Slide)
3. บทความจากหนงั สือ หรอื เว็บไซตต์ ่างๆ
4. เคร่ืองคอมพวิ เตอร์

การวดั ผลและการประเมิน

1. ประเมนิ จากการซักถามในช้ันเรยี น
2. ประเมนิ จากความรว่ มมือและความรบั ผดิ ชอบต่อการเรยี น
3. ประเมนิ จากการทาแบบฝึกหัดทบทวนทา้ ยบทเรียน
4. ประเมินจากการฝกึ ปฏบิ ัติ