ข้อมูลแบบโครงสร้าง (structure) เป็นข้อมูลชนิดหนึ่งเกิดจากการรวมข้อมูลชนิดต่าง ๆ จำนวนหนึ่งไว้ด้วยกันภายใต้ชื่อโครงสร้างเดียวกัน เช่น ข้อมูลแบบโครงสร้าง ชื่อ student ประกอบดัวย
ตัวแปร ชื่อ name เป็นข้อมูล ประเภท string(ข้อความ)
ตัวแปร ชื่อ surname เป็นข้อมูล ประเภท string
ตัวแปร ชื่อ birthyear เป็นข้อมูล ประเภท int
ตัวแปร ชื่อ sex เป็นข้อมูล ประเภท string
ตัวแปร ชื่อ room เป็นข้อมูล ประเภท int
ตัวแปรที่เกิดจากข้อมูลแบบโครงสร้าง เรียกว่าตัวแปรโครงสร้าง เช่น ตัวแปรโครงสร้าง คือ นักเรียนคนที่ 1 นักเรียนคนที่ 2 นักเรียนคนที่ 3 แต่ละคนจะประกอบด้วยข้อมูลของตัวแปรต่าง ๆ ที่อยู่ภายในข้อมูลแบบโครงสร้าง เช่น
ตัวแปรโครงสร้าง นักเรียนคนที่ 1 มีตัวแปรต่าง ๆ ที่มีข้อมูลเป็นดังนี้
ตัวแปร ชื่อ name เป็นข้อมูล ประเภท string มีข้อมูล คือ ชัย
ตัวแปร ชื่อ surname เป็นข้อมูล ประเภท string มีข้อมูล คือ สายเสมอ
ตัวแปร ชื่อ birthyear เป็นข้อมูล ประเภท int มีข้อมูล คือ 2501
ตัวแปร ชื่อ sex เป็นข้อมูล ประเภท string มีข้อมูล คือ ชาย
ตัวแปร ชื่อ room เป็นข้อมูล ประเภท int มีข้อมูล คือ 6
ตัวแปรโครงสร้าง นักเรียนคนที่ 2 มีตัวแปรต่าง ๆ ที่มีข้อมูลเป็นดังนี้
ตัวแปร ชื่อ name เป็นข้อมูล ประเภท string มีข้อมูล คือ สมหญิง
ตัวแปร ชื่อ surname เป็นข้อมูล ประเภท string มีข้อมูล คือ เย็นใจ
ตัวแปร ชื่อ birthyear เป็นข้อมูล ประเภท int มีข้อมูล คือ 2502
ตัวแปร ชื่อ sex เป็นข้อมูล ประเภท string มีข้อมูล คือ หญิง
ตัวแปร ชื่อ room เป็นข้อมูล ประเภท int มีข้อมูล คือ 5
การประกาศข้อมูลแบบโครงสร้าง
เป็นการกำหนดลักษณะของข้อมูลแบบโครงสร้าง มี 2 รูป คือ ประกาศข้อมูลแบบโครงสร้างก่อนแล้วจึงกำหนด ตัวแปรให้มีข้อมูลเป็นแบบโครงสร้าง หรือประกาศข้อมูลแบบโครงสร้างพร้อมกับกำหนดตัวแปรพร้อมกัน แต่ทั้งสองแบบใช้ คำสั่งร่วมกัน คือ struct
รูปแบบที่ 1 กำหนดโครงสร้างพร้อมกับการประกาศตัวแปรที่มีโครงสร้างนั้น มีรูปแบบ ดังนี้
struct structure name
{
type1 name1;
type2 name2;
...
typeN nameN;
} structure variable1, structure variable2,..., structure variableN;
รูปแบบที่ 2 กำหนดโครงสร้างก่อน แล้วจึงการประกาศตัวแปรที่มีโครงสร้างนั้น ในภายหลัง มีรูปแบบ ดังนี้
struct structure name
{
type1 name1;
type2 name2;
...
typeN nameN;
};
struct structure name struture variable1, structure variable2,..., structure variableN;
โดย struct เป็นคำสั่งสำหรับประกาศข้อมูลแบบโครงสร้าง
Structure name เป็นชื่อของข้อมูลแบบโครงสร้างใช้สำหรับกำหนดให้ข้อมูลกลุ่มอื่นๆ ให้มีโครงสร้างแบบเดียวกัน
type1,type2,...,typeN คือชนิดของตัวแปร หรือ ข้อมูล ต่าง ๆ เช่น int float char ฯลฯ
name1, name2,..., nameN คือชื่อของตัวแปร ต่าง ๆ
structure variable เป็นชื่อของตัวแปรที่โครงสร้างเหมือนกับข้อมูลโครงสร้างชื่อ structure name
ตัวอย่าง struct person
{
char name[20];
char surname[20];
double salary;
int birthday;
} sompol , wimolsiri , jeera;
หรือ ตัวอย่างในรูปแบบที่2
ตัวอย่าง struct person
{
char name[20];
char surname[20];
double salary;
int birthday;
};
struct person sompol , wimolsiri , jeera;
ลักษณะการจัดการหน่วยความจำ เปรียบเทียบได้ดังรูป
การอ้างอิงถึงสมาชิกของตัวแปรโครงสร้าง
ในการระบุหรืออ้างอิงถึงตัวแปรซึ่งเป็นสมาชิกในโครงสร้างของตัวแปรโครงสร้าง นั้น ทำได้ ดังนี้
Structure variable.name โดย structure variable คือ ชื่อของตัวแปรโครงสร้าง ส่วน name คือ ชื่อของตัวแปรที่เป็นสมาชิกในโครงสร้างนั้น ดังเช่น ในตัวอย่างที่ผ่านมา sompol.salary จะหมายถึงตัวแปร salary ในตัวแปรโครงสร้างชื่อ sompol หรือ jeera.birthday หมายถึง ตัวแปร birthday ในตัวแปรโครงสร้าง ชื่อ jeera
ดังนั้นในตัวแปรโครงสร้าง wimolsiri จะมีสมาชิกที่อ้างถึงได้ ดังต่อไปนี้
wimolsiri.name
wimolsiri.surname
wimolsiri.salary
wimolsiri.birthday
ตัวอย่าง การอ้างอิงถึงสมาชิกของตัวแปรโครงสร้าง ให้นักเรียนศึกษาโปรแกรม และคาดคะเนผล แล้วทดสอบ ว่าเป็นตามที่คาดคะเนหรือไม่
/* ref_to_st.c */
#include
#include
#include
main()
{
struct member /* ประกาศ ข้อมูลโครงสร้างชื่อ member */
{
char name[20], surname[20],id_num[6]; /* ประกาศตัวแปร ชนิด ข้อความ ชื่อ name,surname,id_num */
int level,room,no_room; /* ประกาศตัวแปร จำนวนเต็ม คือ level , room , room_no */
}room412; /* ประกาศตัวแปรชื่อ room412 มีโครงสร้างข้อมูล แบบ member */
strcpy(room412.name,"Kanokporn"); */ นำข้อความให้เป็นค่าในตัวแปร name ซึ่งเป็นสมาชิกของตัวแปร room412 */
strcpy(room412.surname,"Jakka"); */ นำข้อความให้เป็นค่าในตัวแปร surname ซึ่งเป็นสมาชิกของตัวแปร room412 */
strcpy(room412.id_num,"26534"); */ นำข้อความให้เป็นค่าในตัวแปร id_num ซึ่งเป็นสมาชิกของตัวแปร room412 */
room412.level=4; /* กำหนดค่า ให้แก่ตัวแปร level ซึ่งเป็นสมาชิกของตัวแปรโครงสร้าง room412 */
room412.room=12; /* กำหนดค่า ให้แก่ตัวแปร room ซึ่งเป็นสมาชิกของตัวแปรโครงสร้าง room412 */
room412.no_room=20; /* กำหนดค่าให้แก่ตัวแปรno_room ซึ่งเป็นสมาชิกของตัวแปรโครงสร้าง room412 */
printf("\nid_num = %s name = %s surname = %s ",room412.id_num,room412.name,room412.surname);
printf("\nlevel = %d room = %d no_room = %d ",room412.level,room412.room,room412.no_room);
}
จะเห็นได้ว่าการอ้างอิงถึงตัวแปรซึ่งเป็นสมาชิกของตัวแปรโครงสร้างมีวิธีการเฉพาะ แต่การกำหนดค่าให้แก่ตัวแปรเหล่านั้น ใช้วิธีการทำนองเดียวกับเมื่อตัวแปรชนิดนั้น อยู่เป็นอิสระนอกตัวแปรโครงสร้าง
การกำหนดข้อมูลให้ตัวแปรโครงสร้าง และการแสดงผลตัวแปรโครงสร้าง
การกำหนดข้อมูลและการแสดงผลตัวแปรโครงสร้างนั้นนำหลักการเข้าถึงตัวแปรที่เป็นสมาชิกของตัวแปรโครงสร้าง ที่ใช้รูปแบบดังที่ผ่านมาแล้ว คือ structure variable.name เมื่อ structure variable คือ ชื่อของตัวแปรโครงสร้าง ส่วน name คือ ชื่อของตัวแปรที่เป็นสมาชิกของตัวแปรโครงสร้าง ส่วนการกำหนดข้อมูลให้แก่ตัวแปรโครงสร้างและการแสดงผลตัวแปรโครงสร้างนำหลักการเข้าถึงตัวแปรที่เป็นสมาชิกของตัวแปรโครงสร้างและการกำหนดข้อมูลให้แก่ตัวแปรและการแสดงผลตัวแปรตามชนิดของตัวแปร มาใช้ประกอบกัน
ตัวอย่าง ให้นักเรียนศึกษาโปรแกรม /* str_variable1.c */ แล้วคาดคะเนผล แล้วทดสอบว่าเป็นตามที่คาดคะเนหรือไม่
/* str_variable1.c */
#include
#include
#include
#include
main()
{
struct person
{
char name[20],surname[20];
int age;
float salary;
};
struct person sompol,tanapol;
char numstring[20];
char forename[20];
clrscr();
printf("\nPerson \nEnter name :");
scanf ("%s",forename); /* รับข้อความจากแป้นพิมพ์ ไปเก็บในตัวแปร forename */
strcpy(tanapol.name,forename); /* ทำสำเนาforename เก็บใน tanapol.name */
printf("\nEnter tanapol.surname :");
scanf("%s",tanapol.surname);
printf("\nEnter salary :");
scanf( "%s", numstring); /* รับข้อความจากแป้นพิมพ์ ไปเก็บในตัวแปร numstring */
tanapol.salary = atof(numstring); /* เปลี่ยนตัวเลขที่เป็นข้อความใน numstring ให้เป็นจำนวนเลขที่เป็นทศนิยมและกำหนดให้เป็นข้อมูลของ ตัวแปร tanapol.salary */
printf("\nEnter age :");
scanf("%d",&tanapol.age); /* รับข้อความจากแป้นพิมพ์ ไปเก็บในตัวแปร tanapol.age */
sompol = tanapol ; /* คัดลอกข้อมูลของตัวแปรโครงสร้าง tanapol ไปให้กับตัวแปรโครงสร้าง sompol */
printf("\n tanapol.name = %s \n tanapol.surname =%s \n tanapol.age =%d years \ntanapol.salary =%8.2f bath",tanapol.name,tanapol.surname,tanapol.age,tanapol.salary);
printf("\n sompol.name = %s \n sompol.surname =%s \n sompol.age =%d years \nsompol.salary =%8.2f bath",sompol.name,sompol.surname,sompol.age,sompol.salary);
}
ตัวแปรชุดของข้อมูลแบบโครงสร้าง (arrays of structures)
ตัวแปรชุดของข้อมูลแบบโครงสร้าง มีลักษณะทำนองเดียวกับตัวแปรชุดหรือ array ของข้อมูลประเภทอื่น ๆ คือ เป็นกลุ่มของข้อมูลแบบโครงสร้างที่เก็บไว้ในชื่อเดียวกัน ต่างกันที่ดัชนีหรือเลขกำกับชื่อ โดยการประกาศตัวแปรชุดของข้อมูลแบบโครงสร้างชนิดอื่น ๆ คืออาจประกาศโครงสร้างพร้อมกับกำหนดชื่อตัวแปรพร้อมกัน หรือประกาศโครงสร้างก่อนแล้วมากำหนดชื่อตัวแปรในภายหลัง ดังตัวอย่าง
ตัวอย่าง การประกาศตัวแปรชุดของข้อมูลแบบโครงสร้าง
struct room412
{
char name[20];
char surname[20];
float salary;
int birthyear;
} student[55] ;
struct room412
{
char name[20];
char surname[20];
float salary;
int birthyear;
} ;
struct room412 student[55];
หน่วยความจำที่ใช้ในตัวแปรชุดของข้อมูลแบบโครงสร้าง เป็นลักษณะทำนองเดียวกับตัวแปรชุดของข้อมูลประเภทอื่น ๆ โดยหน่วยความจำทั้งหมดที่ใช้เป็นผลรวมของหน่วยความจำที่ใช้โดยสมาชิกแต่ละตัว ซึ่งมีหน่วยความจำที่ใช้ขึ้นกับตัวแปรสมาชิกแต่ละตัวของข้อมูลแบบโครงสร้าง
การอ้างอิงถึงตัวแปรสมาชิกซึ่งอยู่ในข้อมูลโครงสร้าง ทำได้โดยการระบุถึงสมาชิกของตัวแปรชุดตามด้วยตัวแปรที่เป็นสมาชิกในข้อมูลแบบโครงสร้าง ในลักษณะ structure variable.name โดย
structure variable คือ ชื่อตัวแปรชุดพร้อมดัชนี name คือ ตัวแปรในข้อมูลโครงสร้าง ดังในตัวอย่างที่ผ่านมา
student[0].surname หมายถึงตัวแปรชื่อ surname ในโครงสร้างข้อมูล ของตัวแปรโครงสร้างชื่อ student[0]
โดยการกำหนดค่าตัวแปรเป็นไปทำนองเดียวกับตัวแปรอื่น ๆ ที่ผ่านมา
ตัวอย่าง จงศึกษาวิเคราะห์โปรแกรม structur1.c คาดคะเนการทำงานของโปรแกรม แล้วทดสอบว่าเป็นตามที่คาดหรือไม่
/* structur1.c */
#include
#include
#include
main()
{
struct member /* ประกาศสร้างข้อมูลโครงสร้าง ชื่อ member */
{
int num;
char name[20];
char surname[20];
char grade;
}student[60]; /* สร้างตัวแปรชุด ชื่อstudent สำหรับข้อมูลโครงสร้าง โดยใช้โครงสร้างข้อมูล member */
clrscr();
int i,time;
printf("How many students that you want to input data? ");
scanf("%d",&time);
for (i=0;i
{
printf("\nEnter number of student %d person.",i+1);
scanf("%d",&student[i].num); /* รับข้อมูลจากแป้นพิมพ์ไปเก็บในตัวแปร num ของ student[i] */
printf("Enter name of student %d person.",i+1);
scanf("%s",student[i].name); /* รับข้อมูลจากแป้นพิมพ์ไปเก็บในตัวแปร name ของ student[i] */
(ต่อหน้าถัดไป)
printf("Enter surname of student %d person.",i+1);
scanf("%s",student[i].surname); /* รับข้อมูลจากแป้นพิมพ์ไปเก็บในตัวแปร surname ของ student[i] */
printf("Enter grade of student %d person.",i+1);
student[i].grade = getch(); /* รับข้อมูลจากแป้นพิมพ์ไปเก็บในตัวแปร grade ของ student[i] */
printf("\n student no. = %d is %s %s get %c in computer.",student[i].num,student[i].name,student[i].surname,student[i].grade); /* แสดงข้อมูลทางจอภาพ */
}
}
พอยน์เตอร์ชนิดโครงสร้าง
ตัวแปรพอยน์เตอร์ชนิดโครงสร้างใช้ในการตำแหน่งในหน่วยความจำของข้อมูล เช่นเดียวกับพอยน์เตอร์ชนิดอื่น ๆ การประกาศพอยน์เตอร์ชนิดโครงสร้าง ประกาศ ดังนี้
struct structure_name *pointer_name
โดย struct คำสั่งประกาศสร้างข้อมูลโครงสร้าง structure_name คือ ชื่อโครงสร้างข้อมูล ที่พอยน์เตอร์จะเป็นตัวชี้ pointer_name เป็นชื่อพอยน์เตอร์ ส่วน * เป็นเครื่องหมายที่ใช้แสดงว่าเป็นพอยน์เตอร์ โดยการประกาศสร้างพอยน์เตอร์นี้อาจทำพร้อมการประกาศโครงสร้างข้อมูล ดังตัวอย่าง
struct school {
int address;
char street[30];
char kwhang[25];
char khet[25];
} *ptr;
struct school {
int address;
char street[30];
char kwhang[25];
char khet[25];
};
struct school *ptr;
การใช้พอยน์เตอร์อ้างอิงตัวแปรที่เป็นสมาชิกในข้อมูลแบบโครงสร้าง ใช้รูปแบบ ดังนี้
(*ptr).variable หรือ ptr->variable
โดย ptr คือ ชื่อพอยน์เตอร์ และ variable คือชื่อตัวแปรที่เป็นสมาชิกในข้อมูลแบบโครงสร้าง เช่น
ในข้อมูลแบบโครงสร้างชื่อ school จะใช้ดังรูปแบบ (*ptr).address หรือ ptr-> address เป็นการใช้พอยน์เตอร์ ptr อ้างถึงตัวแปร address ทั้งสองรูปแบบ(ในรูปแบบ (*ptr).address จะต้องใช้วงเล็บเสมอเพราะลำดับของเครื่องหมายสำคัญกว่าเครื่องหมาย *) ในกรณีที่จะหาตำแหน่งในหน่วยความจำของตัวแปร ใช้เครื่องหมาย & เช่น &(*ptr).address และ &ptr-> address เป็นการระบุตำแหน่งในหน่วยความจำของตัวแปร address ส่วน &(*ptr).khet หรือ &ptr-> khet เป็นการระบุตำแหน่งในหน่วยความจำของตัวแปร khet
ตัวอย่าง ให้พิจารณาโปรแกรม ptrstr1.c แล้วคาดคะเนผล และทดสอบว่าตรงกับที่คาดคะเนหรือไม่
/* ptrstr1.c */
#include
#include
main()
{
struct ok /* บรรทัด 5 ถึง 9 เป็นการประกาศข้อมูลแบบโครงสร้าง */
{ /* ชื่อ ok */
int num,x1;
char word;
};
struct ok kikkok; /* ประกาศตัวแปรโครงสร้างชื่อ kikkok ซึ่งมีโครงสร้างเหมือนข้อมูลโครงสร้าง ok */
struct ok *ptr; /* ประกาศตัวแปรพอยน์เตอร์ชื่อ ptr แก่ข้อมูลโครงสร้าง ok */
clrscr(); ptr = &kikkok; /* ทำให้ ptr เก็บตำแหน่งในหน่วยความของตัวแปรโครงสร้าง ชื่อ kikkok */
ptr->num = 150; /* ทำให้ตัวแปร num มีค่าเป็น 150 หรือ ใช้ (*ptr).num = 150; */
(*ptr).word = 'A' ; /* ทำให้ตัวแปร word มีค่าเป็น A หรือ ใช้ ptr->word = 'A'; หรือ ใช้ kikkok.word = 'A'; */
(*ptr).x1 = 25; /* ทำให้ตัวแปร x1 มีค่าเป็น 25 หรือ ใช้ ptr->x1 = 25; */
printf("\n num = %d \n or = %d or = %d ",ptr->num,(*ptr).num,kikkok.num);
printf("\n word = %c \n or = %c or = %c",ptr->word,(*ptr).word,kikkok.word);
printf("\n x1 = %d \n or = %d or = %d ",ptr->x1,(*ptr).x1,kikkok.x1); }
ตัวแปรโครงสร้างกับฟังก์ชัน
ตัวแปรโครงสร้างนำไปใช้กับฟังก์ชัน โดยการส่งตัวแปรที่เป็นสมาชิกของข้อมูลแบบโครงสร้างเป็นอาร์กูเมนต์ได้เช่นเดียวกับตัวแปรอื่น ๆ ดังตัวอย่าง
ตัวอย่าง ให้นักเรียนศึกษาโปรแกรม ex9_1.c แล้วคาดคะเนการทำงานของโปรแกรม แล้วทดสอบว่าเป็นตามที่คิดหรือไม่
/* ex9_1.c */
#include
#include
#include
grade(int point);
main()
{ struct man{
char name[20];
int score; };
struct man loy;
printf("Please enter you score :"); scanf("%d",&loy.score);
grade(loy.score);
} /* จบ main() */
grade(int point)
{ clrscr();
if (point >=90)
printf("Grade A\n");
else if (point >= 80)
printf("Grade B\n");
else if (point >= 60)
printf("Grade C\n");
else if (point>=50)
printf("Grade D\n");
else
printf("Grade F\n");
return 0; }
ข้อมูลโครงสร้างแบบซ้อน
ตัวแปรโครงสร้างอาจใช้ข้อมูลโครงสร้างซ้อนอยู่เป็นข้อมูลหรือตัวแปรภายในโครงสร้างได้อีก โดยการอ้างถึงยึดหลักการอ้างเป็นลำดับชั้นตามแบบโครงสร้าง ข้อมูลลักษณะนี้อาจพิจารณาจากตัวอย่าง
ตัวอย่าง /*stronstr.c */
#include
#include
#include
struct team
{ char name[20]; int score; };
struct uero
{
struct team first; /* ตัวแปรโครงสร้างชื่อfirst อยู่ในโครงสร้าง team ซึ่งอยู่ภายในโครงสร้าง uero */
struct team second; /* ตัวแปรโครงสร้างชื่อsecond อยู่ในโครงสร้าง team ซึ่งอยู่ภายในโครงสร้าง uero */
};
struct uero football = { /* football เป็นตัวแปรโครงสร้างของโครงสร้าง uero */
{ "Denmark",6}, /*กำหนดข้อมูลให้กับตัวแปร first ซึ่งมีลักษณะเป็นตัวแปรโครงสร้าง */
{"Sweden",8} /*กำหนดข้อมูลให้กับตัวแปร second ซึ่งมีลักษณะเป็นตัวแปรโครงสร้าง */
};
main()
{
printf("\nGroup one\n"); printf("name = %s\n",football.first.name);
printf("score = %d\n",football.first.score); printf("\nGroup two\n");
printf("name = %s\n",football.second.name); printf("score = %d\n",football.second.score);
strcpy(football.first.name, "France"); /*กำหนดข้อมูลให้กับตัวแปร name ซึ่งอยู่ใน first ซึ่งมีลักษณะเป็นตัวแปรโครงสร้าง*/
football.first.score = 5; /*กำหนดข้อมูลให้ตัวแปร score ซึ่งอยู่ใน first ซึ่งมีลักษณะเป็นตัวแปรโครงสร้าง */
printf("\nGroup three\n"); printf("name = %s\n",football.first.name);
printf("score = %d\n",football.first.score);
}
ข้อมูลแบบยูเนียน (UNION)
ยูเนียนเป็นข้อมูลชนิดหนึ่งในภาษาซี ประกอบจากข้อมูลพื้นฐานในภาษาซี ทำนองเดียวกับ ข้อมูลแบบโครงสร้าง ต่างกันที่ข้อมูลต่าง ๆ ในยูเนียนสามารถใช้หน่วยความจำเดียวกันแต่ในเวลาต่างกัน จึงทำให้ใช้หน่วยความจำลดลง
การประกาศข้อมูลยูเนียน มี 2 รูปแบบ คือ ประกาศโครงสร้างข้อมูลก่อนแล้วกำหนดตัวแปรยูเนียนภายหลัง กับ ประกาศโครงสร้างข้อมูลยูเนียนและกำหนดตัวแปรยูเนียนพร้อมกัน ดังตัวอย่าง
union union_name
{
type1 name1;
type2 name2;
...
typeN nameN;
} union_variable1,..,union_variableN;
union union_name
{
type1 name1;
type2 name2;
...
typeN nameN;
} ;
union union_name union_variable1,..,union_variableN;
เช่น
union member
{
char name[15];
char surname[15];
int year;
float salary;
} teacher , student;
union person
{
char name[20];
char surname[20];
int year
float salary;
} ;
union person doctor , nurse;
คำสั่งการประกาศข้อมูลยูเนียน จะทำให้มีการจองเนื้อที่หน่วยความจำ ลักษณะทำนองในรูป(ในตัวอย่างเป็นของ member )
จากรูปในหน้าก่อน ข้อมูลแบบยูเนียน member ใช้หน่วยความจำเพียง 15 ไบต์ คือเท่ากับของ name หรือ surname เท่านั้น เพราะเมื่อใช้คำสั่งนี้ทำให้ข้อมูลต่างชนิดกันใช้หน่วยความจำเดียวกันได้ ดังนั้นแม้ว่าจะใช้หน่วยความจำน้อย แต่ต้องระวัง คือ เมื่อใช้ตัวแปรสมาชิกใดแล้วจะเปลี่ยนไปใช้ตัวใหม่จะต้องนำค่าของตัวเดิมไปใช้ก่อน เพราะว่ามันจะนำหน่วยความจำเดิมไปใช้กับตัวแปรสมาชิกตัวใหม่แทน
การอ้างถึงและคำสั่งที่ใช้กับ ตัวแปรยูเนียนและตัวแปรสมาชิกของมันเป็นในลักษณะเดียวกับตัวแปรของข้อมูลแบบโครงสร้าง ดังตัวอย่าง โปรแกรม คือ /* union.c */ ศึกษาวิเคราะห์ แล้วทดสอบ
ตัวอย่าง /* union.c */
#include
#include
#include
main()
{ clrscr();
union person
{
int year;
char name[20];
float week_money;
} mattayom4[50];
strcpy(mattayom4[0].name,"Sarunpong");
printf("mattayom[0].name = %s",mattayom4[0].name);
mattayom4[0].year = 2532;
printf("\nmattayom4[%d].year = %d ",0,mattayom4[0].year);
mattayom4[0].week_money = 1000.50;
printf("\nmattayom4[0].week_money = %8.2f ",mattayom4[0].week_money);
strcpy(mattayom4[1].name,"Kamoltip"); printf("\nmattayom[1].name = %s",mattayom4[1].name);
mattayom4[1].year = 2533; printf("\nmattayom4[1].year = %d ",mattayom4[1].year);
mattayom4[1].week_money = 2500.25;
printf("\nmattayom4[1].week_money = %8.2f ",mattayom4[1].week_money);
}
ไม่มีความคิดเห็น:
แสดงความคิดเห็น