8.4 การรับข้อมูลจากคีย์บอร์ดเพื่อนำไปเก็บไว้ในตัวแปรภายในโครงสร้าง

8.4 การรับข้อมูลจากคีย์บอร์ดเพื่อนำไปเก็บไว้ในตัวแปรภายในโครงสร้าง

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

	/*             ipstruc1.c              */ #include <stdio.h>                             /* gets() in  this file */           /*  บรรทัดที่  1  */ #include <stdlib.h>            /* atoi(),atof() in this file */                           /*  บรรทัดที่  2  */ #include <conio.h>                                                                              /*  บรรทัดที่  4  */ void main(void)                                                                                       /*  บรรทัดที่  5  */ {                                                                                                           /*  บรรทัดที่  6  */       struct      person                                                                           /*  บรรทัดที่  7  */ {                                                                                                     /*  บรรทัดที่  8  */       char  name[20];                                                                   /*  บรรทัดที่  9  */       float salary;                                                                            /*  บรรทัดที่  10 */       int   age;                                                                                      /*  บรรทัดที่  11 */ };                                                                                                /*  บรรทัดที่  12  */       struct      person   one;                                                            /*  บรรทัดที่  13  */       char numstr[81];                                                                      /*  บรรทัดที่  14  */       clrscr();                                                                                      /*  บรรทัดที่  15  */       printf("\n *** Person Data ***\n\n Enter name : ");                 /*  บรรทัดที่  16  */       gets(one.name);                                                                        /*  บรรทัดที่  17  */       printf("Enter salary : ");                                                           /*  บรรทัดที่  18  */       gets(numstr);                                                                            /*  บรรทัดที่  19  */       one.salary=atof(numstr);                                                        /*  บรรทัดที่  20  */       printf("Enter age : ");                                                                /*  บรรทัดที่  21  */       gets(numstr);                                                                                  /*  บรรทัดที่  22  */       one.age=atoi(numstr);                                                              /*  บรรทัดที่  23  */       printf("\n\nName = %s\n",one.name);                                    /*  บรรทัดที่  24  */       printf("Salary = %f\n",one.salary);                                           /*  บรรทัดที่  25  */       printf("Age = %d\n",one.age);                                                  /*  บรรทัดที่  26  */       printf("\n\nPress any key back to program...");                        /*  บรรทัดที่  27  */       getch();                                                                                    /*  บรรทัดที่  28  */ }                                                                                                  /*  บรรทัดที่  29  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่  8.3  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่  7  ประกาศข้อมูลแบบโครงสร้าง  โดยที่  person  เป็นชื่อข้อมูลแบบโครงสร้าง
บรรทัดที่  13  ประกาศตัวแปรโครงสร้างชื่อ  one
บรรทัดที่  17  รับข้อมูลที่ผู้ใช้เติมจากคีย์บอร์ด  แล้วนำไปเก็บไว้ในตัวแปร  name  ภายในโครงสร้าง  one
บรรทัดที่  19  และ  20    รับ ข้อมูลที่ผู้ใช้เติมจากคีย์บอร์ด  แล้วนำไปเก็บไว้ในตัวแปร  numstr  แล้วแปลงค่าที่รับเข้ามาเป็นจำนวนทศนิยม  ไปเก็บไว้ในตัวแปร  salary  ภายในโครงสร้าง  one
บรรทัดที่  22  และ  23    รับ ข้อมูลที่ผู้ใช้เติมจากคีย์บอร์ด  แล้วนำไปเก็บไว้ในตัวแปร  numstr  แล้วแปลงค่าที่รับเข้ามาเป็นจำนวนเต็ม  ไปเก็บไว้ในตัวแปร  age  ภายในโครงสร้าง  one
บรรทัดที่  24  และ  26    นำค่าตัวแปร  name, salary  และ  age ภายในโครงสร้าง  one  แสดงออกที่จอภาพ

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

	/*             ipstru2.c                                */ #include <stdio.h>             /* gets() in  this file */                            /*  บรรทัดที่  1  */ #include <stdlib.h>     /* atoi(),atof() in this file */                                /*  บรรทัดที่  2  */ #include <conio.h>                                                                          /*  บรรทัดที่  3  */ void main(void)                                                                                /*  บรรทัดที่  4  */ {                                                                                                      /*  บรรทัดที่  5  */       struct      person                                                                        /*  บรรทัดที่  6  */ {                                                                                                        /*  บรรทัดที่  7  */       char  name[20];                                                                   /*  บรรทัดที่  8  */       float salary;                                                                            /*  บรรทัดที่  9  */       int   age;                                                                             /*  บรรทัดที่  10  */ };                                                                                               /*  บรรทัดที่  11  */       struct      person   one ,two;                                                 /*  บรรทัดที่  12  */       char numstr[81];                                                                      /*  บรรทัดที่  13  */       clrscr();                                                                                     /*  บรรทัดที่  14  */       printf("\n *** Person Data ***\n\n Enter name : ");                      /*  บรรทัดที่  15  */       gets(one.name);                                                                           /*  บรรทัดที่  16  */       printf("Enter salary : ");                                                                 /*  บรรทัดที่  17  */       gets(numstr);                                                                              /*  บรรทัดที่  18  */       one.salary=atof(numstr);                                                             /*  บรรทัดที่  19  */       printf("Enter age : ");                                                                 /*  บรรทัดที่  20  */       gets(numstr);                                                                                /*  บรรทัดที่  21  */       one.age=atoi(numstr);                                                                /*  บรรทัดที่  22  */       two = one;             /*copy struct one to struct two*/                  /*  บรรทัดที่  23  */       printf("\n\nName1 = %s\n",one.name);                                      /*  บรรทัดที่  24  */       printf("Salary1 = %f\n",one.salary);                                             /*  บรรทัดที่  25  */       printf("Age1 = %d\n",one.age);                                                   /*  บรรทัดที่  26  */       printf("\n\nName2 = %s\n",two.name);                                   /*  บรรทัดที่  27  */       printf("Salary2 = %f\n",two.salary);                                            /*  บรรทัดที่  28  */       printf("Age2 = %d\n",two.age);                                                /*  บรรทัดที่  29  */       printf("\n\nPress any key back to program...");                        /*  บรรทัดที่  30  */       getch();                                                                                     /*  บรรทัดที่  31  */ }                                                                                               /*  บรรทัดที่  32  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่  8.4  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่  23  สำหรับคำสั่ง  two  =  one;  ที่อยู่ในโปรกรม  ipstru2.c  เป็นคำสั่งให้คัดลอกข้อมูลที่อยู่ในตัวแปรทุกตัวภายในโครงสร้าง  one  ไปเก็บไว้ในโครงสร้าง  two  โดยมีค่าข้อมูลเหมือนกันทุกประการ  (ดูรูปที่  8.3  ประกอบความเข้าใจ)
  

รูปที่  8.3  แสดงผลการทำงานของคำสั่ง  two  =  one;

8.3 การอ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง

8.3 การอ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง
(accessing  structure  members)
            การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบโครงสร้าง  สามารถทำได้โดยเรียกชื่อตัวแปรโครงสร้าง  (struct_var)  ตามด้วยเครื่องหมาย  .  (period)  จากนั้นก็ตามด้วยชื่อตัวแปรภายในโครงสร้าง  (element_name)  หรือบางครั้งเรียกว่า  member_name

รูปแบบการอ้างอิงตัวแปรภายในโครงสร้าง

struct_var. member_name

            

เช่น  person.emp_name  หมายถึง  ชื่อพนักงาน
person.position  หมายถึง  ตำแหน่งของพนักงาน
person.salary  หมายถึง  เงินเดือนของพนักงาน
x.a, x.b, x.c  หมายถึง  ตัวแปร  a, b  และ  c  ตามลำดับ
(ให้ดูข้อมูลแบบโครงสร้างตัวอย่างที่  1  และ  2  ที่ผ่านมาประกอบความเข้าใจด้วย)

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

	/*             struct1.c                */ #include<stdio.h>                                                           /*  บรรทัดที่  1  */ #include<conio.h>                                                          /*  บรรทัดที่  2  */ void main(void)                                                                /*  บรรทัดที่  3  */ {                                                                                       /*  บรรทัดที่  4  */ struct  record                                                                  /*  บรรทัดที่  5  */ {                                                                                     /*  บรรทัดที่  6  */ int   i;                                                                               /*  บรรทัดที่  7  */ char  j;                                                                              /*  บรรทัดที่ 8  */ float k;                                                                            /*  บรรทัดที่  9  */ };                                                                                    /*  บรรทัดที่  10 */ struct record one,two;                                                     /*  บรรทัดที่  11  */ clrscr();                                                                            /*  บรรทัดที่  12  */ one.i=7; one.j='I'; one.k=1.2345;                                    /*  บรรทัดที่  13  */ two.i=4; two.j='J'; two.k=9.8765;                                    /*  บรรทัดที่  14  */ printf("I = %d, J = %c, K = %.5f\n",one.i,one.j,one.k);   /*  บรรทัดที่  15  */ printf("I2 = %d, J2 = %c, K2 = %.5f\n",two.i,two.j,two.k);/*  บรรทัดที่  16  */ printf("\nPress any key back to program...");                  /*  บรรทัดที่  17  */ getch();                                                                           /*  บรรทัดที่  18  */ }                                                                                     /*  บรรทัดที่  19  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่  8.1  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่  5  ประกาศข้อมูลแบบโครงสร้าง  โดยที่  record  เป็นชื่อข้อมูลแบบโครงสร้าง
บรรทัดที่  11  ประกาศตัวแปรโครงสร้างชื่อ  one  และ  two
บรรทัดที่  13  และ  14  เป็นการอ้างอิงตัวแปรภายในโครงสร้าง
บรรทัดที่  15    นำค่าตัวแปร  i, j, k  ภายในโครงสร้าง  one  แสดงออกที่จอภาพ
บรรทัดที่  16    นำค่าตัวแปร  i, j, k  ภายในโครงสร้าง  two  แสดงออกที่จอภาพ

โปรแกรมตัวอย่างที่  8.2 แสดงการประกาศตัวแปรข้อมูลแบบโครงสร้างและการอ้างอิงสมาชิกภายใน  แบบที่  2

	/*             struct2.c                */ #include<stdio.h>                                                                             /*  บรรทัดที่  1  */ #include<conio.h>                                                                        /*  บรรทัดที่  2  */ void main(void)                                                                                /*  บรรทัดที่  3  */ {                                                                                                     /*  บรรทัดที่  4  */       struct      simple                                                                       /*  บรรทัดที่  5  */ {                                                                                                    /*  บรรทัดที่  6  */       int  num;                                                                                        /*  บรรทัดที่  7  */       char ch;                                                                                 /*  บรรทัดที่  8  */ } a,b;                                                                                             /*  บรรทัดที่  9  */       clrscr();                                                                                         /*  บรรทัดที่  10  */       a.num = 9;            a.ch='K';                                                           /*  บรรทัดที่  11  */       b.num = a.num+6;              b.ch=a.ch - 1;                                      /*  บรรทัดที่  12  */       printf("Number a = %d, Char a = %c\n", a.num, ++a.ch);          /*  บรรทัดที่  13  */       printf("Number b = %d, Char b = %c\n", b.num-6, b.ch);          /*  บรรทัดที่  14  */       printf("\nPress any key back to program...");                               /*  บรรทัดที่  15  */       getch();                                                                                        /*  บรรทัดที่  16  */ }                                                                                                  /*  บรรทัดที่  17  */

ผลลัพธ์ที่ได้จากโปรแกรม

 

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่  8.2  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่  5  ประกาศข้อมูลแบบโครงสร้าง  โดยที่  simple  เป็นชื่อข้อมูลแบบโครงสร้าง
บรรทัดที่  11  และ  12  เป็นการอ้างอิงตัวแปรภายในโครงสร้าง
บรรทัดที่  13    นำค่าตัวแปร  num, ch  ภายในโครงสร้าง  a  แสดงออกที่จอภาพ
บรรทัดที่  14    นำค่าตัวแปร  num, ch  ภายในโครงสร้าง  b  แสดงออกที่จอภาพ

8.2 การประกาศข้อมูลแบบโครงสร้าง (declaration of a structure data type)

8.2 การประกาศข้อมูลแบบโครงสร้าง (declaration  of  a  structure  data  type)
            สามารถทำได้โดยคำสั่ง  struct  มาช่วยในการประกาศข้อมูลแบบโครงสร้าง  โดยมีรูปแบบการประกาศดังน
ี้รูปแบบที่  1

struct  struct_name
{
type1  name1;
type2  name2;
……..
typeN  nameN;
}   struct_var;

             รูปแบบที่ 2

struct   struct_name
{
type1  name1;
type2  name2;
……..
typeN  nameN;    
} ;
struct  struct_name  struct_var;

  โดยที่

struct  เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง
struct_name  เป็นชื่อข้อมูลแบบโครงสร้าง  ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว
struct_var  เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายในโครงสร้าง
type1  name1, type2  name2,…,typeN  nameN  เป็นชนิด  และชื่อตัวแปรที่ 1, 2, 3, … , N  ตามลำดับ  บางครั้งอาจจะเรียก  name1, name2,…,nameN  ว่า  element 1, element 2, … ,  element N  ตามลำดับ

ตัวอย่างที่  8.2  แสดงการประกาศข้อมูลแบบโครงสร้าง

            1)

struct  employee
{
char  emp_name[30];
char  position[30];
int  salary;
}  person;
หรือจะใช้คำสั่งดังนี้
struct  employee
{
char  emp_name[30];
char  position[30];
int  salary;
};
struct  employee  person;

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

รูปที่  8.1  แสดงข้อมูลแบบโครงสร้าง  employee  ภายในหน่วยความจำ

            2)

struct  y
{
int  a;
char b;
float  c;
}  x;

หรือจะใช้คำสั่งดังนี้

struct  y
{
int  a;
char b;
float  c;
};
struct  y  x;

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

8.1 ความหมายและลักษณะของข้อมูลแบบโครงสร้าง

ทที่  8
ข้อมูลแบบโครงสร้างและยูเนียน

            สำหรับในบทนี้จะกล่าวถึง  ข้อมูลแบบโครงสร้าง  (structures)  ซึ่งเป็นข้อมูลชนิดหนึ่งที่มีลักษณะสำคัญ  คือ  สามารถรวบรวมข้อมูลหลาย ๆ  ชนิดเข้ามาเก็บไว้ด้วยกัน  เพื่อความสะดวกในการจัดการข้อมูลต่างชนิดกัน  และช่วยในการจัดเก็บข้อมูลแบบ  record  ซึ่งเป็นพื้นฐานที่สำคัญในการจัดการแฟ้มข้อมูลต่อไป  ส่วนในตอนท้ายของบทนี้จะกล่าวถึงข้อมูลแบบยูเนียน(unions)  ซึ่งเป็นข้อมูลชนิดหนึ่งที่ทำให้เราสามารถใช้ตัวแปรหลาย ๆ  ชนิด  ภายในเนื้อที่เดียวกัน  ทำให้การใช้เนื้อที่ในหน่วยความจำลดลง  และสามารถทำงานได้อย่างมีประสิทธิภาพมากขึ้น

8.1 ความหมายและลักษณะของข้อมูลแบบโครงสร้าง

            ข้อมูลแบบโครงสร้าง  คือ  ข้อมูลชนิดหนึ่งที่เกิดจากการรวบรวมตัวแปรหลาย ๆ  ชนิดมาเก็บไว้ด้วยกัน  โดยเก็บไว้ภายใต้ชื่อโครงสร้าง  (structure  name)  เดียวกัน
ตัวอย่างที่  8.1  ต้องการเก็บข้อมูลของพนักงานแต่ละคนซึ่งประกอบด้วย  ชื่อพนักงาน  ตำแหน่ง  และเงินเดือน  จำนวน  10  คน
ดังนั้นข้อมูลของพนักงานคนที่ 1, 2, 3…, 10  จะมีโครงสร้างแฟ้มข้อมูลดังนี้  คือ

ตารางที่  8.1  แสดงโครงสร้างแฟ้มข้อมูลของพนักงาน

คนที่	ชื่อพนักงาน (ตัวแปรตัวที่ 1)	ตำแหน่ง (ตัวแปรตัวที่ 2)	เงินเดือน (ตัวแปรตัวที่ 3)
1 2 3 …. 10	นาย ก. นาย ข. นาย ค. ……… นาย ช.	ผู้จัดการทั่วไป โปรแกรมเมอร์ นักวิเคราะห์ระบบ …………………. นักบัญชี	20,000 10,000 12,000 ………. 15,000

           

            จะเห็นว่าข้อมูลของพนักงานแต่ละคนจะมีตัวแปรทั้งหมด  3  ตัวแปร  คือ  ตัวแปรที่เก็บชื่อพนักงาน  ตัวแปรที่เก็บตำแหน่ง  และตัวแปรที่เก็บเงินเดือน  ตามลำดับ  ลักษณะเช่นนี้เราสามารถนำข้อมูลของพนักงานแต่ละคนมาจัดเป็นข้อมูลแบบโครง สร้างได้ดังนี้

          ตารางที่  8.2  แสดงข้อมูลแบบโครงสร้าง

ข้อมูล (data)	ชื่อตัวแปร (variable  name)	ชนิดตัวแปร (type  of  variable)
ชื่อพนักงาน ตำแหน่ง เงินเดือน	emp_name position salary	string string integer(int)

7.2 ฟังก์ชันที่เขียนขึ้น (user defined functions)

7.2 ฟังก์ชันที่เขียนขึ้น  (user  defined  functions)
            ฟังก์ชันที่เขียนขึ้นหรือบางครั้งเราเรียกว่าโปรแกรมย่อย  คือ  ส่วนของโปรแกรมที่เขียนขึ้นเพื่อให้สามารถทำงานได้อย่างใดอย่างหนึ่งตามความ ต้องการ  สำหรับผู้เขียนโปรแกรมภาษา  Cนิยมเรียกโปรแกรมย่อยว่า  ”ฟังก์ชัน”  ส่วนผู้ที่เขียนโปรแกรมภาษาปาสคาล  โคบอล  ฟอร์แทรน  เบสิก  นิยมเรียกว่า  ”โปรแกรมย่อย”  อย่างไรก็ตามโปรแกรมย่อยหรือฟังก์ชันก็มีลักษณะการทำงานเหมือนกัน เพียงแต่เรียกชื่อต่างกันเท่านั้นสำหรับในเอกสารนี้จะเรียกว่า  ฟังก์ชัน  ซึ่งในเนื้อหาส่วนนี้ จะเป็นการเรียนรู้เกี่ยวกับฟังชันที่เขียนขึ้น  (user  define  functions  :  UDF)  ตั้งแต่การประกาศรูปแบบฟังก์ชัน  การเขียนตัวฟังก์ชันและการเรียกใช้ฟังก์ชันเพื่อให้สามารถใช้ฟังก์ชันที่ เขียนขึ้นในโปรแกรมภาษา  C  ได้อย่างถูกต้อง
ตัวอย่างที่  7.4  แสดงฟังก์ชันที่เขียนขึ้นเพื่อใช้งานอย่างใดอย่างหนึ่ง  เช่น

void  asterisk_line( )  {
int  j, n=30;
for(j=1; j<=n; j++)
printf(“*”);
}

            ฟังก์ชัน  asterisk_line( )  เป็นฟังก์ชันที่ใช้พิมพ์เครื่องหมาย  *  (asterisk)  จำนวน  30  ตัวออกทางจอภาพ
             7.2.1 ประเภทของฟังก์ชันที่เขียนขึ้น
(types  of  user  defined  functions )
            ในการเขียนฟังก์ชันขึ้นมาใช้งานอย่างใดอย่างหนึ่ง  เราสามารถจำแนกฟังก์ชันที่เขียนขึ้นตามลักษณะการส่งค่าไปและรับค่ากลับได้  3  แบบ  คือ

1) ฟังก์ชันที่ไม่มีการส่งค่าไปและรับค่ากลับ
2) ฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีรับค่ากลับ
3) ฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

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


            7.2.2 โครงสร้างของฟังก์ชัน  (the  structure  of  functions)
            ฟังก์ชันที่สร้างขึ้นมาแต่ละฟังก์ชันจะประกอบด้วยโครงสร้างดังนี้   
รูปแบบโครงสร้างของฟังก์ชันในภาษา  C

type  function_name(type1  arg1, type2  arg2,..,  typeN  argN)
{
local  variable  declaration;
statement(s);
return( varlue);
} 

  โดยที่  

type  คือ  ชนิดของข้อมูลที่ส่งกลับมายังชื่อฟังก์ชันที่เรียกใช้  โดยปกติแล้วถ้าไม่มีการกำหนด  type  ว่าเป็นชนิด  int, float, char  หรือ  double  จะได้ค่าข้อมูลที่ส่งกลับมาเป็นชนิด  int  เสมอ  ยกเว้นว่าฟังก์ชันนั้นไม่มีการส่งค่ากลับจะต้องกำหนดให้  type  เป็น  void
function_name  คือ  ชื่อฟังก์ชัน  ซึ่งเราสามารถตั้งชื่อฟังก์ชันโดยอาศัยกฎเกณฑ์ของการตั้งชื่อตัวแปรในภาษาซี
type1  arg1, type2  arg2,…, typeN  argN  คือ  การประกาศชื่อและชนิดของตัวแปรที่จะใช้เป็น  argument  ตัวที่ 1, 2, 3,…, N  ตามลำดับ  ถ้าเป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับเลย  ให้ใช้คำว่า  void  แทน
{  คือ  จุดเริ่มต้นของฟังก์ชัน
}  คือจุดสิ้นสุดของฟังก์ชัน
local  variable  declaration  คือ  การประกาศชนิดและชื่อของตัวแปรที่ใช้ได้เฉพาะภายในฟังก์ชัน  ถ้าอยู่นอกฟังก์ชันจะไม่สามารถใช้ตัวแปร  local  ที่ประกาศไว้ได้
statement(s)  คือ  คำสั่งต่าง ๆ  ที่ใช้ในฟังก์ชัน  ถ้ามีมากกว่า  1  คำสั่งให้จบท้ายแต่ละคำสั่งด้วยเครื่องหมาย  ;  (semicolon)
return(value)  คือ  คำสั่งที่ใช้ส่งค่ากลับไปยังชื่อฟังก์ชันที่เรียกใช้  ส่วน  value  ที่อยู่ภายใน  ( )  คือ  ค่าที่จะถูกส่งกลับ  คำสั่งนี้จะใช้เฉพาะฟังก์ชันที่มีการส่งค่ากลับเท่านั้น  ถ้าเป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและกลับ  หรือเป็นฟังก์ชันชนิดที่มีแต่การส่งค่าไปอย่างเดียว  ก็ไม่ต้องใช้คำสั่งนี้

   โปรแกรมตัวอย่างที่  7.10  แสดงโครงสร้างของฟังก์ชัน
 
 

	/*             funct1.c                 */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ void one(void);                /* function Prototype */                             /*  บรรทัดที่  3  */ void two(void);                /* function Prototype */                             /*  บรรทัดที่  4  */ void main(void)                                                                                    /*  บรรทัดที่  5  */ {                                                                                                         /*  บรรทัดที่  6  */      clrscr();                                                                                  /*  บรรทัดที่  7  */      one();                     /* call one() */                                        /*  บรรทัดที่  8  */      two();                     /* call two() */                                         /*  บรรทัดที่  9  */      printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */      getch();                                                                                  /*  บรรทัดที่  11  */ }  /*  end main  */                                                                         /*  บรรทัดที่  12  */ /* one function */                                                                  /*  บรรทัดที่  13  */      void one()                                                                              /*  บรรทัดที่  14  */      {                                                                               /*  บรรทัดที่  15  */           int a=5, b=7;                                         /*  บรรทัดที่  16  */           printf("A = %d, B = %d\n",a,b);          /*  บรรทัดที่  17  */      }                                                                               /*  บรรทัดที่  18  */ /* two function */                                                                   /*  บรรทัดที่  19  */      void two()                                                                              /*  บรรทัดที่  20  */      {                                                                               /*  บรรทัดที่  21  */           float p=4.5, q=3.5;                              /*  บรรทัดที่  22  */           p+=q;                                                    /*  บรรทัดที่  23  */           printf("P = %6.3f, Q = %6.3f\n",p,q); /*  บรรทัดที่  24*/      }                                                                               /*  บรรทัดที่  25  */

 

   ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.10 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  และ  4  คำ สั่ง  void  one(void);  และ  void  two(void);  คำสั่งประกาศชื่อฟังก์ชันและชนิดของการส่งค่ากลับมายังฟังก์ชัน  ซึ่งในกรณีนี้ทั้งฟังก์ชัน  one( )  และ  two( ) เป็นฟังก์ชันชนิดที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ   เนื่องจากคำว่า  void  ที่อยู่หน้าชื่อฟังก์ชัน  one( )  และ  two( )  เป็นการบอกว่าไม่มีการรับค่าที่ส่งกลับ  ส่วนคำว่า  void  ที่อยู่ภายใน  ( )  ของฟังก์ชัน  one( )  และ  two  เป็นการบอกว่าไม่มี  argument  นั่นคือไม่มีการส่งค่าไปนั่นเอง 
ข้อสังเกต  การประกาศชื่อและชนิดของฟังก์ชันจะต้องประกาศไว้ก่อนฟังก์ชัน  main( )   เพราะจะทำให้เราสามารถใช้ฟังก์ชันที่ประกาศไว้ในส่วนใดของโปรแกรมก็ได้
บรรทัดที่  8  และ  9  คำ สั่ง  one( );  และ  two( );  เป็นการเรียกใช้ฟังก์ชันชื่อ  one( )  และ  two( )  ตามลำดับ  โดยฟังก์ชัน  one( )  อยู่ที่คำสั่งบรรทัดที่  14  ถึง  18  และ  ฟังก์ชัน  two( )  อยู่ที่บรรทัดที่  20  ถึง  25
บรรทัดที่  14  ถึง  18  ฟังก์ชัน  one( )  ให้พิมพ์ค่าที่เก็บไว้ในตัวแปร  a  และ  b  แสดงที่จอภาพ
บรรทัดที่  20  ถึง  25  ฟังก์ชัน  two( )  ให้พิมพ์ค่าที่เก็บไว้ในตัวแปร  p  และ  q  และพิมพ์ค่าตัวแปร  q  แสดงที่จอภาพ
บรรทัดที่  10  และ  11  ภายหลังจากทำงานตามฟังก์ชัน  one( )  และ  two( )  แล้ว  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            เพื่อความเข้าใจเกี่ยวกับการทำงานของฟังก์ชันมากยิ่งขึ้น  จากโปรแกรม  funct1.c  สามารถอธิบายการทำงานได้ดังนี้  (ดูรูปที่ 7.1  ประกอบ)

โปรแกรมหลัก                                                       ฟังก์ชัน  one( )
           
                                                                        ฟังก์ชัน  two( )

รูปที่  7.1  แสดงการทำงานระหว่างโปรแกรมหลักกับฟังก์ชันที่เขียนขึ้น

            7.2.3 การเรียกใช้ฟังก์ชัน  (calling  the  function)
            การเรียกใช้ฟังก์ชันที่เขียนขึ้นมาใช้งานสามารถทำได้โดย  เรียกชื่อฟังก์ชันนั้นแล้วตามด้วย  argument  ของฟังก์ชัน  (ถ้ามี)  จากนั้นปิดท้ายด้วยเครื่องหมาย  ;  ซึ่งจะมีผลทำให้ย้ายการทำงานจากโปรแกรมหลักไปยังฟังก์ชันที่ถูกเรียกใช้ ทันที
             รูปแบบการใช้ฟังก์ชันในภาษา  C

        funct_name  (argument_list);

   โดยที่

funct_name  คือ  ชื่อฟังก์ชันที่ต้องการใช้งาน
argument_list คือชื่อตัวแปรหรือนิพจน์หรือค่าคงที่ที่ใช้ส่งค่าไป  ถ้ามีมากกว่า  1 argument  ให้ใช้เครื่องหมาย  ,  (comma)  คั่นระหว่าง  argument  แต่ละค่า  เช่น  จากตัวอย่างโปรแกรม  funct1.c  มีคำสั่งที่เรียกใช้ฟังก์ชัน  คือ  คำสั่ง  one( );  และ  two( );  ซึ่งอยู่ในโปรแกรมหลักคือฟังก์ชัน  main( )

            7.2.4 การประกาศรูปแบบฟังก์ชัน  (function  prototype)
            ฟังก์ชันในภาษา  C  มีลักษณะการใช้งานเหมือนกับตัวแปร  ถ้าเราต้องการจะใช้ตัวแปรตัวใดจะต้องประกาศชนิดและชื่อตัวแปรเสียก่อนจึงจะ สามารถนำตัวแปรที่ประกาศไว้มาใช้งานได้  ทำนองเดียวกันฟังก์ชันก็เช่นกันจะต้องมีการประกาศชื่อและชนิดของฟังก์ชัน เสียก่อน  จึงจะสามารถนำมาใช้งานได้
         
          รูปแบบการประกาศฟังก์ชันในภาษา  C

 type  funct_name( type1,  type2,…..,  typeN);
หรือ
type  funct_name( type1  arg1,  type2  arg2,…..,  typeN  argN);

   โดยที่ 

type  คือ  ชนิดของค่าข้อมูลที่ส่งกลับมายังฟังก์ชัน  ถ้าไม่ระบุจะเป็นชนิด  int  เสมอ  ถ้าไม่มีการส่งค่ากลับให้ใช้คำว่า  void
funct_name  คือชื่อฟังก์ชัน  ซึ่งเราสามารถตั้งชื่อฟังก์ชันโดยใช้กฎเกณฑ์เดียวกันกับการตั้งชื่อตัวแปร
type1, type2,….., typeN  คือ  ชนิดของ  argument  ตัวที่  1, 2, 3,…, N  ตามลำดับ
arg1, arg2,….., argN  คือ  ชื่อ  argument  ที่ใช้ในการส่งค่าไปตัวที่  1, 2, 3,…, N        ตามลำดับ

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

1) float add(int, float);
2) int sum(int p, int q);  หรือ  int sum(int, int);
3) void move(int, float, int);
4) float calculate(float, float);
5) void point(int*, int*, float);    แสดงว่า  argumant  ตัวที่  1  และ  2  เป็นตัวแปรพอยน์เตอร์  argument  ตัวที่  3  เป็น  float

โปรแกรมตัวอย่างที่  7.11  แสดงการประกาศรูปแบบของฟังก์ชัน

	/*             funct2.c */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ int max(int, int);                                                                                    /*  บรรทัดที่  3  */ void main(void)                                                                                    /*  บรรทัดที่  4  */ {                                                                                                        /*  บรรทัดที่  5  */      int p=30, q=45, m;                                                              /*  บรรทัดที่  6  */      clrscr();                                                                                  /*  บรรทัดที่  7  */      m=max(p,q);                                                                        /*  บรรทัดที่  8  */      printf("Return Maximum Value is...%d",m);                     /*  บรรทัดที่  9  */      getch();                                                                                  /*  บรรทัดที่  10  */ }  /*   end main()   */                                                                             /*  บรรทัดที่  11  */                 /* max() function */                                                              /*  บรรทัดที่  12  */ int max(int a, int b)                                                              /*  บรรทัดที่  13  */ {                                                                                               /*  บรรทัดที่  14  */      return( ( a>b ?  a : b ) );                                      /*  บรรทัดที่  15  */ }                                                                                               /*  บรรทัดที่  16  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.11 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  คำสั่ง  int  max (int, int);  การประกาศรูปแบบฟังก์ชัน
บรรทัดที่  8  คำสั่ง  m = max(p, q);  เป็นการเรียกใช้งานฟังก์ชัน  max( )  พร้อมทั้งส่งค่า  argument  ค่าตัวแปร  p  และ  q  ไปให้ด้วย  ซึ่งภายหลังจากทำงานในฟังก์ชัน  max( )  แล้ว  ได้ค่าอะไรให้เก็บไว้ที่ตัวแปร  m
บรรทัดที่  13  ถึง  16    เป็นฟังก์ชัน  max( )    ซึ่งมีการทำงานคือ    สำหรับนิพจน์   (a>b?  a : b)  ที่อยู่ในฟังก์ชัน  return( )  หมายความว่า    ถ้าเงื่อนไข  a>b  เป็นจริง  ให้ส่งค่าของตัวแปร  a  กลับไปยังฟังก์ชันที่เรียกมา  แต่ถ้าเงื่อนไข  a>b  เป็นเท็จ ให้ส่งค่าของตัวแปร  b  กลับไปยังฟังก์ชันที่เรียกมา
บรรทัดที่  10  หยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            7.2.5 ฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ
            การประกาศฟังก์ชันนี้จะมีชนิดเป็น  void  และภายในเครื่องหมาย  ( )  จะมีคำว่า void  อยู่แสดงว่าไม่มีทั้งการส่งค่าไปและรับค่ากลับ  นอกจากนี้ในโครงสร้างของฟังก์ชันชนิดนี้จะไม่มีคำสั่ง  return(value);
            1) การประกาศฟังก์ชันที่ไม่มีทั้งการส่งค่าไปและรับค่ากลับ
รูปแบบการประกาศฟังก์ชัน

            void funct_name(void );
หรือ
            void funct_name( );

  

          
เช่น  void  one(void);  หรือ void  one( );  เป็นต้น

            2) โครงสร้างของฟังก์ชันแบบไม่มีทั้งการส่งค่าไปและรับค่ากลับ 
รูปแบบโครงสร้างฟังก์ชัน

               
void  funct_name(void);
{
local  variable  decaration;
statement(s);
}

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

	/*             funct3.c                 */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ void asterisk_line(void);                                                                     /*  บรรทัดที่  3  */ void main(void)                                                                                    /*  บรรทัดที่  4  */ {                                                                                                      /*  บรรทัดที่  5  */      clrscr( );                                                                                 /*  บรรทัดที่  6  */      asterisk_line( );                                                                     /*  บรรทัดที่  7  */      printf("****** C and C++ PROGRAMMING ******\n");    /*  บรรทัดที่  8  */      asterisk_line();                                                                      /*  บรรทัดที่  9  */      printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */      getch();                                                                                  /*  บรรทัดที่  11  */ }                                                                                                      /*  บรรทัดที่  12  */ /* asterisk_line function */                                                  /*  บรรทัดที่  13  */      void asterisk_line( )                                                             /*  บรรทัดที่  14  */      {                                                                                               /*  บรรทัดที่  15  */           int j, n=40;                                                             /*  บรรทัดที่  16  */           for(j=1; j<=n; j++)                                                /*  บรรทัดที่  17  */           printf("*");                                                           /*  บรรทัดที่  18  */           printf("\n");                                                              /*  บรรทัดที่  19  */ }                                                                                               /*  บรรทัดที่  20  */

ผลลัพธ์ที่ได้จากโปรแกรม

 

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.12 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้               

บรรทัดที่  3  คำสั่ง  void  asterisk_line (void);  แสดงว่าฟังก์ชันชื่อ  asterisk_line( )  เป็นฟังก์ชันที่ไม่มีทั้งการส่งค่าไป  และรับค่ากลับ
บรรทัดที่  7  และ  9  เป็นคำสั่งเรียกใช้ฟังก์ชัน  asterisk_line( )  ซึ่งฟังก์ชันอยู่คำสั่งบรรทัดที่  14  ถึง  19
บรรทัดที่  14  ถึง  19  ฟังก์ชัน  asterisk_line( )  มีการทำงานโดยพิมพ์  *  จำนวน  40  ตัวออกแสดงที่จอภาพ
บรรทัดที่  10  และ  11  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

             7.2.6 ฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ
            การประกาศฟังก์ชันชนิดนี้  มีชนิดเป็น  void  แต่ภายในเครื่องหมาย  ( )  จะมีชนิดของ    argument  ปรากฏอยู่ตามปกติ    ส่วนโครงสร้างของฟังก์ชันชนิดนี้จะไม่มีคำสั่ง  return(value);
            1) การประกาศฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ
รูปแบบการประกาศฟังก์ชัน

                void  funct_name(type1, type2,….., typeN);
หรือ
                void  funct_name( type1  arg1, type2  arg2,….., typeN  argN);

   ตัวอย่างที่  7.6  แสดงการประกาศฟังก์ชัน

void multiply(int, int);
void add(float, int);
void a(int*, int);

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

               
void  funct_name( type1  arg1,  type2  arg2,…..,  typeN  argN);
{
local  variable  declaration;
statement(s);
}

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

	/*             pvalue.c                */ /*             pass value to function        */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ void add(int, int);                                                                                 /*  บรรทัดที่  3  */ void subtract(float, float);                                                                   /*  บรรทัดที่  4  */ void multiply(int, float);                                                                       /*  บรรทัดที่  5  */ void divide(float, int);                                                                          /*  บรรทัดที่  6  */ void main(void)                                                                                    /*  บรรทัดที่  7  */ {                                                                                                         /*  บรรทัดที่  8  */      int x=3, y=5;                                                                          /*  บรรทัดที่  9  */      float z=6.5;                                                                            /*  บรรทัดที่  10  */      clrscr( );                                                                                 /*  บรรทัดที่  11  */      add(x,y);                                /* called add */                    /*  บรรทัดที่  12  */      subtract(z, z+4.5);               /*called subtract */              /*  บรรทัดที่  13  */      multiply(y,z);                         /*called multiply */               /*  บรรทัดที่  14  */      divide(z+11.5, x);                /*called divide */                  /*  บรรทัดที่  15  */      printf("\nPress any key back to program ..."); /*  บรรทัดที่  16  */      getch();                                                                                  /*  บรรทัดที่  17  */ }  /*  end main()  */                                                                     /*  บรรทัดที่  18  */ /* add function */                                                                 /*  บรรทัดที่  19  */      void add(int p, int q)                                                           /*  บรรทัดที่  20  */      {                                                                                               /*  บรรทัดที่  21  */           int  k;                                                                       /*  บรรทัดที่  22  */           k=p+q;                                                                  /*  บรรทัดที่  23  */           printf("P = %d \tQ = %d \tK = %d\n",p,q,k);    /*  บรรทัดที่  24  */      }                                                                                               /*  บรรทัดที่  25  */ /* subtract function */                                                          /*  บรรทัดที่  26  */      void subtract(float p, float q)                                                       /*  บรรทัดที่  27  */      {                                                                                        /*  บรรทัดที่  28  */           float k;                                                                              /*  บรรทัดที่  29  */           k=q-p;                                                                              /*  บรรทัดที่  30  */           printf("P = %.3f \tQ = %.3f \tK = %.3f\n",p,q,k);       /*  บรรทัดที่  31  */      }                                                                                     /*  บรรทัดที่  32  */ /* multiply function */                                                                     /*  บรรทัดที่  33  */      void multiply(int p, float q)                                                           /*  บรรทัดที่  34  */      {                                                                                           /*  บรรทัดที่ 35  */             float k;                                                              /*  บรรทัดที่  36  */             k=p*q;                                                             /*  บรรทัดที่  37  */             printf("P = %d \tQ = %.3f \tK=%.3f\n",p,q,k);            /*  บรรทัดที่  38  */       }                                                                                      /*  บรรทัดที่  39  */ /* divide function */                                                                        /*  บรรทัดที่  40  */       void divide(float p, int q)                                                              /*  บรรทัดที่  41  */       {                                                                                       /*  บรรทัดที่  42  */             float k;                                                                              /*  บรรทัดที่  43  */             k=p/q;                                                                              /*  บรรทัดที่  44  */             printf("P = %.3f \tQ = %d \tK = %.3f\n",p,q,k);         /*  บรรทัดที่  45  */ }                                                                                                         /*  บรรทัดที่  46  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.13 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  ประกาศฟังก์ชันที่มีการส่งค่า  int  ไป  แต่ไม่มีการรับค่ากลับ  ชื่อฟังก์ชัน  add( )
บรรทัดที่  4  ประกาศฟังก์ชันที่มีการส่งค่า  float  ไป  แต่ไม่มีการรับค่ากลับ  ชื่อฟังก์ชัน  subtract( )
บรรทัดที่  5  ประกาศฟังก์ชันที่มีการส่งค่า  int  และ  float  ไป  แต่ไม่มีการรับค่ากลับ  ชื่อฟังก์ชัน  multiply( )
บรรทัดที่  6  ประกาศฟังก์ชันที่มีการส่งค่า  float  และ  int  ไป  แต่ไม่มีการรับค่ากลับ  ชื่อฟังก์ชัน  divide( )
บรรทัดที่  12  เรียกใช้ฟังก์ชัน  add( )  โดยส่งค่าตัวแปร  x  และ  y  ที่เป็น  int  ไป  ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่  20  ถึง  25
บรรทัดที่  13  เรียกใช้ฟังก์ชัน  subtract( )  โดยส่งค่าตัวแปร  z  และ  z + 4.5  ที่เป็น   float  ไป  ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่  27  ถึง  32
บรรทัดที่  14  เรียกใช้ฟังก์ชัน  multiply( )  โดยส่งค่าตัวแปร  y  และ  z  ที่เป็น  int  และ  float  ไป  ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่  34  ถึง  39
บรรทัดที่  15  เรียกใช้ฟังก์ชัน  divide( )  โดยส่งค่าตัวแปร  z + 11.5  และ  x  ที่เป็น  float  และ  int  ไป  ซึ่งการทำงานของฟังก์ชันจะอยู่บรรทัดที่  41  ถึง  46
บรรทัดที่  20  ถึง  25  เป็นการทำงานของฟังก์ชัน  add( )  โดยบวกตัวเลข  และแสดงผลออกจอภาพ
บรรทัดที่  27  ถึง  32  เป็นการทำงานของฟังก์ชัน  subtract( )  โดยลบตัวเลข  และ  แสดงผลออกจอภาพ
บรรทัดที่  34  ถึง  39  เป็นการทำงานของฟังก์ชัน  multiply( )  โดยคูณตัวเลข  และ  แสดงผลออกจอภาพ
บรรทัดที่  41  ถึง  46  เป็นการทำงานของฟังก์ชัน  divide( )  โดยหารตัวเลข  และ  แสดงผลออกจอภาพ
บรรทัดที่  16  และ  17  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

โปรแกรมตัวอย่างที่  7.14  แสดงการส่งค่า  address  ของตัวแปรชุดไปยังฟังก์ชันที่มีการส่งค่าไปแต่ไม่มีการรับค่ากลับ

	/*  padd.c              */ /*  pass address of array to function                */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ void address(int *);                                                                             /*  บรรทัดที่ 3  */ void main(void)                                                                                    /*  บรรทัดที่  4  */ {                                                                                                    /*  บรรทัดที่  5  */       int array[5]= {100, 200, 300, 400, 500 };                         /*  บรรทัดที่  6  */       clrscr( );                                                                                 /*  บรรทัดที่  7  */       address(array);                                                                    /*  บรรทัดที่  8  */       printf("\nPress any key back to program ..."); /*  บรรทัดที่  9  */       getch();                                                                                  /*  บรรทัดที่  10  */ }  /*  end main() */                                                                 /*  บรรทัดที่  11  */ /* address function */                                                          /*  บรรทัดที่  12  */       void address(int *ptr)                                                         /*  บรรทัดที่  13  */       {                                                                                               /*  บรรทัดที่  14  */             int j;                                                                         /*  บรรทัดที่  15  */             for(j=0; j<5; j++)                                                  /*  บรรทัดที่  16  */             printf( "Array#%d = %d\n",j+1, *(ptr+j) );     /*  บรรทัดที่  17  */ }                                                                                               /*  บรรทัดที่  18  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.14 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  คำสั่ง  void  address(int*);  เป็นการประกาศรูปแบบฟังก์ชันที่มีการส่งค่าไปเป็นชนิด  int*  แต่ไม่มีการส่งค่ากลับ  ซึ่งฟังก์ชันชื่อ  address( )
บรรทัดที่  8  คำสั่ง  address(array);  เป็นการเรียกใช้ฟังก์ชัน  address( )  โดยส่งค่าตัวแปร  array  ไปให้ฟังก์ชัน  ซึ่งฟังก์ชัน  array  อยู่คำสั่งบรรทัดที่  13  ถึง  18
บรรทัดที่  13  ถึง  18  ฟังก์ชัน  address( )  รับค่าของ  array  มาแสดงผลออกจอภาพ  โดยใช้คำสั่ง  for  วนลูปช่วยในการเข้าถึงข้อมูลใน  array
บรรทัดที่  9  และ  10  ภายหลังจากทำงานตามฟังก์ชัน  address  แล้ว  ก็จะพิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            7.2.7 ฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ
            ฟังก์ชันชนิดนี้เป็นฟังก์ชันที่ต้องมีชนิดและ  argument  ของฟังก์ชันส่วนในโครงสร้างของฟังก์ชันชนิดนี้จะต้องมีคำสั่ง  return(value);  เพื่อส่งค่ากลับด้วย  ยกเว้นในกรณีที่ใช้ตัวแปรพอยน์เตอร์  (pointer)  มาช่วยไม่ต้องมีคำสั่ง  return(value);  ก็ได้
            1) การประกาศฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ

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

type  funct_name( type1, type2,….., typeN);
หรือ
type  funct_name( type1  arg1, type2  arg2,….., typeN  argN);

   ตัวอย่างที่  7.7  แสดงการประกาศฟังก์ชัน

int multiply(int, int);
float add(float, int);
int a(int*, int);

            2) โครงสร้างของฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ
รูปแบบโครงสร้างของฟังก์ชัน

type  funct_name( type1  arg1,  type2  arg2,…..,  typeN  argN);
{
local  variable  declaration;
statement(s);
return(value);
}

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

	/*             rvaluef.c */ /*             pass and return value function                         */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ int calculate(int, int);                                                                           /*  บรรทัดที่  3  */ void main(void)                                                                                    /*  บรรทัดที่  4  */ {                                                                                                        /*  บรรทัดที่  5  */       int  p=3, q=4, r;                                                                    /*  บรรทัดที่  6  */       clrscr( );                                                                                 /*  บรรทัดที่  7  */       r = calculate(p,q);                                                               /*  บรรทัดที่  8  */       printf("P = %d, Q = %d, R = %d\n",p,q,r);                      /*  บรรทัดที่  9  */       printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */       getch();                                                                                  /*  บรรทัดที่  11  */ }   /*   end main()  */                                                                     /*  บรรทัดที่  12  */       int calculate(int p, int q)                                                     /*  บรรทัดที่  13  */       {                                                                                               /*  บรรทัดที่  14  */             return (p+q);                                                         /*  บรรทัดที่  15  */       }                                                                                               /*  บรรทัดที่  16  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.15 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  คำสั่ง  int  calculate (int, int);  การประกาศรูปแบบฟังก์ชันที่มีการส่งค่า  argument  ไป  2  ตัว  ชนิด  int  และ  มีการส่งค่ากลับมายังฟังก์ชันเป็นชนิด  int  เช่นกัน  โดยฟังก์ชันชื่อ  caculate( )
บรรทัดที่  8  คำสั่ง  r = caculate (p, q);  เป็นการเรียกใช้ฟังก์ชัน  caculate( )  และส่งค่า  p  และ  q  ส่งไปให้ฟังก์ชันด้วย  ตามลำดับ  ซึ่งฟังก์ชัน  caculate( )  อยู่คำสั่งบรรทัดที่  13  ถึง  16
บรรทัดที่  13  ถึง  16  ฟังก์ชัน  caculate( )  โดยมีการทำงาน  คือ  นำค่าตัวแปร  p  และ  q  ที่ได้มาบวกกัน  แล้วส่งผลลัพธ์ที่ได้กลับไปให้  ณ  จุดที่เรียกใช้ในฟังก์ชัน  main( )  นั่นคือ  ไปเก็บไว้ที่ตัวแปร  r
บรรทัดที่  9  แสดงค่าตัวแปร  p, q  และ  r  แสดงที่จอภาพ
บรรทัดที่  10  และ  11  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

โปรแกรมตัวอย่างที่  7.16  แสดงการใช้งานฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับที่มี  argument  เป็นพอยน์เตอร์

	/*             cref.c                      */ /*      call by address to function and return value  */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ int change(int *, int *);                                                                         /*  บรรทัดที่  3  */ void main(void)                                                                                    /*  บรรทัดที่  4  */ {                                                                                                      /*  บรรทัดที่  5  */       int p=50, q=100;                                                                 /*  บรรทัดที่  6  */       clrscr( );                                                                                 /*  บรรทัดที่  7  */       printf("P = %d, Q = %d\n",p,q);                                        /*  บรรทัดที่  8  */       change(&p,&q);                                                                  /*  บรรทัดที่  9  */       printf("P = %d, Q = %d\n",p,q);                                        /*  บรรทัดที่  10  */       change(&p,&q);                                                                  /*  บรรทัดที่  11  */       printf("P = %d, Q = %d\n",p,q);                                        /*  บรรทัดที่  12  */       printf("\nPress any key back to program ..."); /*  บรรทัดที่  13  */       getch();                                                                                  /*  บรรทัดที่  14  */ }                                                                                                    /*  บรรทัดที่  15  */       int change(int *ptr_p, int *ptr_q)                                      /*  บรรทัดที่  16  */       {                                                                                               /*  บรรทัดที่  17  */             int tempo;                                                              /*  บรรทัดที่  18  */             tempo  = *ptr_p;                                                  /*  บรรทัดที่  19  */             *ptr_p = *ptr_q;                                                    /*  บรรทัดที่  20  */             *ptr_q = tempo;                                                   /*  บรรทัดที่  21  */       }                                                                                               /*  บรรทัดที่  22  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.16 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  คำสั่ง  int  change (int*, int*);  การประกาศรูปแบบฟังก์ชันที่มีการส่งค่า  ของตัวแปร  2  ตัวที่เป็นพอยน์เตอร์  และมีการส่งค่ากลับมายังฟังก์ชัน  โดยฟังก์ชันชื่อ  change( )
บรรทัดที่  8  แสดงค่าตัวแปร  p  และ  q  ออกที่จอภาพ  คือ  p = 50  และ  q = 100
บรรทัดที่  9  คำสั่ง  change (&p, &q);  คำสั่งเรียกใช้ฟังก์ชัน  change( )  โดยส่งค่า  address  ของ  p  และ  q  ไปยังฟังก์ชัน  change( )  ด้วย  ตามลำดับ  ซึ่งฟังก์ชัน  change( )  อยู่คำสั่งบรรทัดที่  16  ถึง  22
บรรทัดที่  16  ถึง  22  ฟังก์ชัน  change( )  มีการทำงานโดยใช้ตัวแปรพอยเตอร์ในการสลับค่าตัวแปร  p  และ  q  ดังนั้น  p = 100  และ  q = 50
บรรทัดที่  10  แสดงค่าตัวแปร  p  และ  q  ภายหลังจากที่สลับค่ากันแล้ว  แสดงออกจอภาพ
บรรทัดที่  11  ทำงานเหมือนคำสั่งบรรทัดที่  9  ดังนั้น  ภายหลังจากสลับค่ากันแล้ว  จะได้  p = 50, q = 100
บรรทัดที่  12  แสดงค่าตัวแปร  p  และ  q  ภายหลังจากที่สลับค่ากันอีกครั้ง  แสดงออกจอภาพ
บรรทัดที่  13  และ  14  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

โปรแกรมตัวอย่างที่  7.17  แสดงการใช้งานฟังก์ชันที่มีทั้งการส่งค่าไปและรับค่ากลับ  มี  argument  เป็นพอยน์เตอร์  3  ตัว

	/*             calcu.c                  */ #include<stdio.h>                                                                              /*  บรรทัดที่  1  */ #include<conio.h>                                                                             /*  บรรทัดที่  2  */ void calcu(int *, int *, int *);                                                                /*  บรรทัดที่  3  */ void main(void)                                                                                    /*  บรรทัดที่  4  */ {                                                                                                      /*  บรรทัดที่  5  */       int a=3, b=10, c=5;                                                             /*  บรรทัดที่  6  */       clrscr( );                                                                                 /*  บรรทัดที่  7  */       calcu(&a, &b, &c);                                                               /*  บรรทัดที่  8  */       printf("A = %d, B = %d, C = %d\n",a,b,c);                      /*  บรรทัดที่  9  */       printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */       getch();                                                                                  /*  บรรทัดที่  11  */ }                                                                                                    /*  บรรทัดที่  12  */       void calcu(int *pa, int *pb, int *pc)                                  /*  บรรทัดที่  13  */       {                                                                                               /*  บรรทัดที่  14  */             *pa = *pa * 5;                                                       /*  บรรทัดที่  15  */             *pb = *pb + 10;                                                   /*  บรรทัดที่  16  */             *pc = *pc + *pb;                                                 /*  บรรทัดที่  17  */       }                                                                                               /*  บรรทัดที่  18  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างที่ 7.17 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  3  คำสั่ง  void  calcu(int*, int*, int*);  ประกาศตัวรูปแบบฟังก์ชันที่มีการส่งค่า  address  ของตัวแปร  3  ตัวที่เป็นพอยน์เตอร์  ฟังก์ชันชื่อ  calcu( )
บรรทัดที่  8  คำสั่ง  calcu(&a,  &b,  &c);  คำสั่งที่มีการเรียกใช้ฟังก์ชัน  calcu( )  โดยส่งค่า  address  ของ  a, b  และ  c  ไปยังฟังก์ชัน  calcu( )  ตามลำดับ  ฟังก์ชัน  calcu( )  อยู่คำสั่งบรรทัดที่  13  ถึง  18
บรรทัดที่  13  ถึง  18  ฟังก์ชัน  calcu( )  จะใช้ตัวแปรพอยเตอร์ในการคำนวณค่าของตัวแปรใหม่  โดย  จะได้
ค่าของ  a  ที่ตัวแปรพอยเตอร์  *pa  ชี้อยู่  เป็น  3 * 5 = 15 
ค่าของ  b  ที่ตัวแปรพอยเตอร์  *pb  ชี้อยู่  เป็น  10 + 10 = 20
ค่าของ  c  ที่ตัวแปรพอยเตอร์  *pc  ชี้อยู่  เป็น  5 + 20 = 25
บรรทัดที่  9  แสดงค่าตัวแปร  a, b  และ  c  ออกที่จอภาพ
บรรทัดที่  10  และ  11  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม