หน่วยที่ 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)

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.2 แสดงข้อมูลแบบโครงสร้าง y ภายในหน่วยความจำ

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.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.5 ข้อมูลแบบโครงสร้างซ้อน (nested structures)

บางครั้งเราสามารถประกาศข้อมูลแบบโครงสร้างซ้อนอยู่ภายในโครงสร้างได้ดังโปรแกรมตัวอย่างต่อไปนี้

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

/* neststru.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

struct student /* บรรทัดที่ 3 */

{ /* บรรทัดที่ 4 */

char name[20]; /* บรรทัดที่ 5 */

int age; /* บรรทัดที่ 6 */

}; /* บรรทัดที่ 7 */

struct group /* บรรทัดที่ 8 */

{ /* บรรทัดที่ 9 */

struct student one; /* nested structure one */ /* บรรทัดที่ 10 */

struct student two; /* nested structure two */ /* บรรทัดที่ 11 */

}; /* บรรทัดที่ 12 */

struct group x = { /* บรรทัดที่ 13 */

{"Kannikar",25}, /* บรรทัดที่ 14 */

{"Suraporn",32} /* บรรทัดที่ 15 */

}; /* บรรทัดที่ 16 */

void main(void) /* บรรทัดที่ 17 */

{ /* บรรทัดที่ 18 */

clrscr(); /* บรรทัดที่ 19 */

printf("\n Person One :\n"); /* บรรทัดที่ 20 */

printf("Name = %s\n", x.one.name); /* บรรทัดที่ 21 */

printf("Age = %d\n", x.one.age); /* บรรทัดที่ 22 */

printf("\n Person Two :\n"); /* บรรทัดที่ 23 */

printf("Name = %s\n", x.two.name); /* บรรทัดที่ 24 */

printf("Age = %d\n", x.two.age); /* บรรทัดที่ 25 */

printf("\n\nPress any key back to program..."); /* บรรทัดที่ 26 */

getch(); /* บรรทัดที่ 27*/

} /* บรรทัดที่ 28 */

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

คำอธิบายโปรแกรม 

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

การอ้างอิงสมาชิกภายในข้อมูลแบบโครงสร้างซ้อนก็ใช้วิธีการอ้างอิงเหมือนกับข้อมูลแบบโครงสร้างธรรมดา 

เช่น บรรทัดที่ 21 x.one.name หมายถึง การอ้างอิงถึงตัวแปร name ผ่านตัวแปรโครงสร้าง one และตัวแปรโครงสร้าง x ตามลำดับ 

หรือ บรรทัดที่ 24 x.two.name หมายถึง การอ้างอิงถึงตัวแปร name ผ่านตัวแปรโครงสร้าง two และตัวแปรโครงสร้าง x ตามลำดับ

8.6 ข้อมูลชุดแบบโครงสร้าง (arrays of structures)

บางครั้งเราอาจจะต้องการตัวแปรโครงสร้างจำนวนมากกว่า 1 ตัว เราต้องการเก็บข้อมูลนักศึกษาจำนวน 10 คน หรือข้อมูลหนังสือ 20 เล่มก็สามารถใช้ความรู้เกี่ยวกับ arrays มาช่วยในการจัดการข้อมูลแบบโครงสร้างได้ดังนี้

8.6.1 การประกาศข้อมูลชุดแบบโครงสร้าง

ใช้คำสั่ง struct มาช่วยในการประกาศข้อมูลชุดแบบโครงสร้างโดยมีรูปแบบดังนี้

รูปแบบที่ 1 

struct struct_name

{

type1 name1;

type2 name2;

……..

typeN nameN;

} struct_var[n];

รูปแบบที่ 2

struct struct_name

{

type1 name1;

type2 name2;

……..

typeN nameN;

};

struct struct_name struct_var[n];

โดยที่

struct เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง

struct_name เป็นชื่อข้อมูลแบบโครงสร้าง ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว

struct_var เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายใน โครงสร้าง

type1 name1, type2 name2, …., typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2, … nameN ว่า element 1 , element 2, … element N ตามลำดับ

n คือ ขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าเริ่มต้นที่ 0,1, 2, …, n-1

ตัวอย่างที่ 8.3 แสดงการประกาศตัวแปรชุดแบบโครงสร้าง

เมื่อใช้คำสั่งประกาศข้างต้นภายในหน่วยความจำจะมีการจองเนื้อที่สำหรับข้อมูลชุดแบบโครงสร้าง employee[0],…, employee[9] ดังนี้ (ดูรูปที่ 8.4 ประกอบความเข้าใจ)

name salary age

employee[0] 25 bytes 4 bytes 2 bytes

employee[1] 25 bytes 4 bytes 2 bytes

…………….. ………… ……….. ………..

employee[9] 25 bytes 4 bytes 2 bytes

รูปที่ 8.4 แสดงการจองเนื้อที่ภายในหน่วยความจำให้กับตัวแปรชุดแบบโครงสร้าง

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

รูปแบบการอ้างอิงโดยไม่มีการกำหนดค่าให้ตัวแปร 

struct_var[n].member_var

โดยที่

n คือขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าตั้งแต่ 0,1, 2, …,n-1

ตัวอย่างที่ 8.4 ถ้าอ้างอิงว่า employee[3].salary หมายถึง เงินเดือนของพนักงานคนที่ 4

ตัวอย่างที่ 8.5 ถ้าอ้างอิงว่า employee[7].name หมายถึง ชื่อของพนักงานคนที่ 8

สำหรับการกำหนดค่าให้กับตัวแปรภายในข้อมูลชุดแบบโครงสร้าง มีรูปแบบดังนี้

รูปแบบอ้างอิงโดยมีการกำหนดค่าให้ตัวแปร

struct_var[n].member_var = value;

โดยที่บางครั้งจะใช้ฟังก์ชัน strcpy (s2,s1) มาช่วยในการกำหนดค่าข้อมูลที่เป็นข้อความ

เช่น employee[0].age = 20;

strcpy(employee[0].name, “Kannikar”);

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

ตัวอย่างดังต่อไปนี้

โปรแกรมตัวอย่างที่ 8.6 แสดงการใช้ตัวแปรชุดแบบโครงสร้าง

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

กรณีเลือกตัวเลือกที่ 1 จะให้เติมข้อมูลลูกจ้าง

กรณีเลือกตัวเลือกที่ 2 จะนำข้อมูลลูกจ้างที่เติม ออกมาแสดง

กรณีเลือกตัวเลือกที่ 3 ออกจากโปรแกรม

/* arrstru.c */

#include<stdio.h> /* printf(), getche(), gets() in this file */ /* บรรทัดที่ 1 */

#include<stdlib.h> /* atoi(), atof(), tolower() in this file */ /* บรรทัดที่ 2 */

#include<ctype.h> /* บรรทัดที่ 4 */

void newname(void); /* functions prototype of newname() */ /* บรรทัดที่ 5 */

void listall(void); /* functions prototype of listall() */ /* บรรทัดที่ 6 */

struct person /* บรรทัดที่ 7 */

{ /* บรรทัดที่ 8 */

char name[30]; /* บรรทัดที่ 9 */

int age; /* บรรทัดที่ 10 */

float salary; /* บรรทัดที่ 11 */

}; /* บรรทัดที่ 12 */

struct person employee[50]; /* array of 50 structures */ /* บรรทัดที่ 13 */

int n=0; /* บรรทัดที่ 14 */

void main(void) /* บรรทัดที่ 15 */

{ /* บรรทัดที่ 16 */

char ch; /* บรรทัดที่ 17 */

do { /* บรรทัดที่ 18 */ 

clrscr( ); /* บรรทัดที่ 19 */

printf(" ****************************\n"); /* บรรทัดที่ 20 */

printf(" * Main Menu *\n"); /* บรรทัดที่ 21 */

printf(" ****************************\n"); /* บรรทัดที่ 22 */

printf(" 1. Create a new employee\n"); /* บรรทัดที่ 23 */

printf(" 2. Display All employees\n"); /* บรรทัดที่ 24 */

printf(" 3. Exit Program\n\n"); /* บรรทัดที่ 25 */

printf(" Enter your choice ( 1 or 2 or 3 ) : "); /* บรรทัดที่ 26 */

ch=getche(); /* บรรทัดที่ 27 */

switch(tolower(ch)) /* บรรทัดที่ 28 */

{ /* บรรทัดที่ 29 */

case '1': /* บรรทัดที่ 30 */

newname(); break; /* บรรทัดที่ 31 */

case '2': /* บรรทัดที่ 32 */

listall(); break; /* บรรทัดที่ 33 */

case '3': /* บรรทัดที่ 34 */

printf("\nExit Program."); exit(0); /* บรรทัดที่ 35 */

default: /* บรรทัดที่ 36 */

printf("\n Choice Error ! Please choice agian"); /* บรรทัดที่ 37 */

} /* บรรทัดที่ 38 */

}while(ch!='3'); /* บรรทัดที่ 39 */

}/* end main */ /* บรรทัดที่ 40 */

/* newname() */ /* บรรทัดที่ 41 */

void newname() /* บรรทัดที่ 42 */

{ /* บรรทัดที่ 43 */

char numstr[81]; /* บรรทัดที่ 44 */

printf("\n Record %d.\n Enter name:", n+1); /* บรรทัดที่ 45 */

gets(employee[n].name); /* บรรทัดที่ 46 */

printf("Enter age :"); /* บรรทัดที่ 47 */

gets(numstr); /* บรรทัดที่ 48 */

employee[n].age = atoi(numstr); /* บรรทัดที่ 49 */

printf("Enter salary :"); /* บรรทัดที่ 50 */

gets(numstr); /* บรรทัดที่ 51 */

employee[n].salary = atof(numstr); /* บรรทัดที่ 52 */

n++; /* บรรทัดที่ 53 */

} /* บรรทัดที่ 54 */

/* listall() */ /* บรรทัดที่ 55 */

void listall() /* บรรทัดที่ 56 */

{ int j; /* บรรทัดที่ 57 */

if (n<1) printf("\n Empty list.\n"); /* บรรทัดที่ 58 */

for(j=0; j<n; j++) { /* บรรทัดที่ 59 */

printf("\n Record number %d\n", j+1); /* บรรทัดที่ 60 */

printf("Name : %s\n", employee[j].name); /* บรรทัดที่ 61 */

printf("Age : %d\n", employee[j].age); /* บรรทัดที่ 62 */

printf("Salary : %.2f\n", employee[j].salary); /* บรรทัดที่ 63 */

} /* บรรทัดที่ 64 */

getch(); /* บรรทัดที่ 65 */

} /* บรรทัดที่ 66 */

8.7 พอยน์เตอร์กับข้อมูลแบบโครงสร้าง (pointer and structures)

หัวข้อนี้จะมีประโยชน์มากเมื่อต้องการทำโครงสร้างข้อมูลแบบ linked list และ tree แบบต่าง ๆ การใช้พอยน์เตอร์อ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง สามารถทำได้ดังนี้

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

(*ptr_name).member_var

หรือ

ptr_name->member_var

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

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

/* ptrstru.c */

#include<stdio.h> /* บรรทัดที่ 1 */ 

#include<conio.h> /* บรรทัดที่ 2 */

void main(void) /* บรรทัดที่ 3 */

{ /* บรรทัดที่ 4 */

struct x /* บรรทัดที่ 5 */

{ /* บรรทัดที่ 6 */

int num; /* บรรทัดที่ 7 */

char ch; /* บรรทัดที่ 8 */

}; /* บรรทัดที่ 9 */

struct x one; /* บรรทัดที่ 10 */

struct x *ptr; /* define pointer to structure */ /* บรรทัดที่ 11 */

clrscr(); /* บรรทัดที่ 12 */

ptr = &one; /* assign address of struc to ptr */ /* บรรทัดที่ 13 */

ptr->num = 230; /* or ptr.num = 230 */ /* บรรทัดที่ 14 */

ptr->ch = 'K'; /* or ptr.ch = 'K' */ /* บรรทัดที่ 15 */

printf("\nNumber = %d\n",ptr->num); /* บรรทัดที่ 16 */

printf("Char = %c", ptr->ch); /* บรรทัดที่ 17 */

printf("\n\nPress any key back to program..."); /* บรรทัดที่ 18 */

getch(); /* บรรทัดที่ 19 */

} /* บรรทัดที่ 20 */

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

8.8 ข้อมูลแบบยูเนียน (unions) 

8.8.1 ความหมายและลักษณะของข้อมูลแบบยูเนียน

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

เช่น สมมติว่าเรามีตัวแปรอยู่ 3 ตัว คือตัวแปร a, b และ c ตามลำดับ โดยที่ตัวแปร a เป็นชนิด integer, ตัวแปร b เป็นชนิด floating point และตัวแปร c เป็นชนิด single character และเราต้องการให้ตัวแปร a, b และ c ใช้เนื้อที่ภายในหน่วยความจำร่วมกัน

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

union {

int a;

float b; 

char c;

} ShareArea;

8.8.2 การประกาศข้อมูลแบบยูเนียน 

(declaration of an unions data type)

สามารถทำได้โดยใช้คำสั่ง union มาช่วยในการประกาศข้อมูลแบบยูเนียน โดยมีรูปแบบการประกาศดังนี้

รูปแบบที่ 1

union union_name

{

type1 name1;

type2 name2;

………

typeN nameN;

} union_var;

รูปแบบที่ 2

union union_name

{

type1 name1;

type2 name2;

………

typeN nameN;

};

union union_name union_var;

โดยที่

union เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบยูเนียน

union_name เป็นชื่อข้อมูลแบบยูเนียน ใช้สำหรับการประกาศข้อมูลแบบยูเนียนกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มยูเนียนที่เคยประกาศไว้แล้ว

union_var เป็นชื่อตัวแปรยูเนียนใช้สำหรับการอ้างอิงภายในยูเนียน

type1 name1, type2 name2,…, typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2,…, nameN ว่า element 1, element2, …, element N ตามลำดับ

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

union same

{

int j;

char ch;

float a; 

} one;

หรือใช้คำสั่ง

union same

{

int j;

char ch;

float a; 

} ;

union same one;

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

รูปที่ 8.5 แสดงการจองเนื้อที่ภายในหน่วยความจำของข้อมูลแบบยูเนียนชื่อ same

จากรูปข้างต้นจะเห็นได้ว่ามีการจองเนื้อที่ในหน่วยความจำมากที่สุดเพียง 4 bytes ซึ่งเพียงพอสำหรับตัวแปรชนิด float เนื่องจาก float ใช้เนื้อที่มากที่สุด 4 bytes ส่วน int ใช้ 2 bytes และ char ใช้ 1 bytes เมื่อใช้คำสั่ง union จะมีการจองเนื้อที่เพื่อให้ใช้หน่วยความจำร่วมกันได้โดยใช้หลักการจองเนื้อที่เท่ากับตัวแปรที่ใช้มากที่สุด ถึงแม้ว่าจะมีข้อมูลต่างชนิดกันก็ตาม

8.8.3 การอ้างอิงตัวแปรภายในข้อมูลแบบยูเนียน 

(accessing union members)

การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบยูเนียน สามารถทำได้โดยเรียกชื่อตัวแปรยูเนียน (union_var) ตามด้วยเครื่องหมาย . (period) จากนั้นก็ตามด้วยชื่อตัวแปรภายในยูเนียน (element_name หรือ member_name) ซึ่งมีลักษณะการอ้างอิงทำนองเดียวกันกับข้อมูลแบบโครงสร้าง

รูปแบบการอ้างอิงตัวแปรภายในยูเนียน

union_var.member_name

เช่น จากตัวอย่างการประกาศยูเนียนที่ผ่านมา ถ้าต้องการอ้างอิงภายในยูเนียนสามารถ ทำได้ดังนี้ 

same.a หมายถึง ตัวแปร a ที่อยู่ในยูเนียน same

same.ch หมายถึง ตัวแปร ch ที่อยู่ในยูเนียน same

same.j หมายถึง ตัวแปร j ที่อยู่ในยูเนียน same

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

โปรแกรมตัวอย่างที่ 8.8 แสดงการใช้ยูเนียน

/* union1.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void main(void) /* บรรทัดที่ 3 */

{ /* บรรทัดที่ 4 */

union intflo /* บรรทัดที่ 5 */

{ /* บรรทัดที่ 6 */

int num; /* บรรทัดที่ 7 */

float f; /* บรรทัดที่ 8 */

} unsame; /* บรรทัดที่ 9 */

clrscr(); /* บรรทัดที่ 10 */

printf("Size of union intflo = %d\n", sizeof(union intflo)); /* บรรทัดที่ 11 */ 

unsame.num = 25; /* บรรทัดที่ 12 */

printf("Number = %d\n", unsame.num); /* บรรทัดที่ 13 */

unsame.f = 1.2345; /* บรรทัดที่ 14 */

printf("F = %.4f\n", unsame.f); /* บรรทัดที่ 15 */

printf("\n\nPress any key back to program..."); /* บรรทัดที่ 16 */

getch(); /* บรรทัดที่ 17 */

} /* บรรทัดที่ 18 */

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

คำอธิบายโปรแกรม

จากโปรแกรมตัวอย่างข้างต้น เพื่อความเข้าใจเกี่ยวกับข้อมูลแบบ union มากขึ้น (ดูรูปที่ 8.6 ประกอบความเข้าใจ)

unsame เป็นตัวแปรยูเนียน

รูปที่ 8.6 แสดงการจองเนื้อที่ในหน่วยความจำของข้อมูลแบบยูเนียนชื่อ intflo

โปรแกรมตัวอย่างที่ 8.9 แสดงการใช้ยูเนียน

/* union2.c */

#include<stdio.h> /* บรรทัดที่ 1 */

#include<conio.h> /* บรรทัดที่ 2 */

void main(void) /* บรรทัดที่ 3 */

{ /* บรรทัดที่ 4 */

struct twointeger /* บรรทัดที่ 5 */

{ /* บรรทัดที่ 6 */

int num1; /* บรรทัดที่ 7 */

int num2; /* บรรทัดที่ 8 */

} us; /* บรรทัดที่ 9 */

union intflo /* บรรทัดที่ 10 */

{ /* บรรทัดที่ 11 */

int num3; /* บรรทัดที่ 12 */

float f; /* บรรทัดที่ 13 */

} unsame; /* บรรทัดที่ 14 */

clrscr( ); /* บรรทัดที่ 15 */

printf("Size of Structure twointeger = %d\n", sizeof(struct twointeger)); /* บ. 16 */

us.num1 = 25; /* บรรทัดที่ 17 */

printf("Number1 = %d\n", us.num1); /* บรรทัดที่ 18 */

us.num2 = 70; /* บรรทัดที่ 19 */

printf("Number2 = %d\n", us.num2); /* บรรทัดที่ 20 */

printf("\nSize of Union intflo = %d\n", sizeof(union intflo)); /* บรรทัดที่ 21 */

unsame.num3 = 55; /* บรรทัดที่ 22 */

printf("Number3 = %d\n", unsame.num3); /* บรรทัดที่ 23 */

unsame.f = 9.8765; /* บรรทัดที่ 24 */

printf("F = %.4f\n", unsame.f); /* บรรทัดที่ 25 */

printf("\n\nPress any key back to program..."); /* บรรทัดที่ 26 */

getch(); /* บรรทัดที่ 27 */

} /* บรรทัดที่ 28 */

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

8.8.4 ข้อควรระวังในการใช้ยูเนียน

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

8.9 สรุปท้ายบท

ข้อมูลแบบโครงสร้าง คือ ข้อมูลชนิดหนึ่งที่เกิดจากการรวบรวมตัวแปรหลาย ๆ ชนิดมาเก็บไว้ด้วยกัน โดยเก็บไว้ภายใต้ชื่อโครงสร้าง (structure name) เดียวกัน

การประกาศข้อมูลแบบโครงสร้าง (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 ตามลำดับ

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

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

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

struct_var. member_name

ข้อมูลชุดแบบโครงสร้าง (arrays of structures) บางครั้งเราอาจจะต้องการตัวแปรโครงสร้างจำนวนมากกว่า 1 ตัว เราต้องการเก็บข้อมูลนักศึกษาจำนวน 10 คน หรือข้อมูลหนังสือ 20 เล่ม ก็สามารถใช้ความรู้เกี่ยวกับ arrays มาช่วยในการจัดการข้อมูลแบบโครงสร้างได้ดังนี้

การประกาศข้อมูลชุดแบบโครงสร้าง 

ใช้คำสั่ง struct มาช่วยในการประกาศข้อมูลชุดแบบโครงสร้างโดยมีรูปแบบดังนี้

รูปแบบที่ 1 

struct struct_name

{

type1 name1;

type2 name2;

……..

typeN nameN;

} struct_var[n];

รูปแบบที่ 2

struct struct_name

{

type1 name1;

type2 name2;

……..

typeN nameN;

};

struct struct_name struct_var[n];

โดยที่

struct เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง

struct_name เป็นชื่อข้อมูลแบบโครงสร้าง ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว

struct_var เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายใน โครงสร้าง

type1 name1, type2 name2, …., typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2, … nameN ว่า element 1 , element 2, … element N ตามลำดับ

n คือ ขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าเริ่มต้นที่ 0,1, 2, …, n-1

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

รูปแบบการอ้างอิงโดยไม่มีการกำหนดค่าให้ตัวแปร 

struct_var[n].member_var

โดยที่

n คือขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าตั้งแต่ 0,1, 2, …,n-1

พอยน์เตอร์กับข้อมูลแบบโครงสร้าง (pointer and structures) เรื่องนี้จะมีประโยชน์มากเมื่อต้องการทำโครงสร้างข้อมูลแบบ linked list และ tree แบบต่าง ๆ การใช้พอยน์เตอร์อ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง สามารถทำได้ดังนี้

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

(*ptr_name).member_var

หรือ

ptr_name->member_var

ข้อมูลแบบยูเนียน (unions)

ความหมายและลักษณะของข้อมูลแบบยูเนียน

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

เช่น สมมติว่าเรามีตัวแปรอยู่ 3 ตัว คือตัวแปร a, b และ c ตามลำดับ โดยที่ตัวแปร a เป็นชนิด integer, ตัวแปร b เป็นชนิด floating point และตัวแปร c เป็นชนิด single character และเราต้องการให้ตัวแปร a, b และ c ใช้เนื้อที่ภายในหน่วยความจำร่วมกัน 

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

union {

int a;

float b; 

char c;

} ShareArea;

การประกาศข้อมูลแบบยูเนียน (declaration of an unions data type)

สามารถทำได้โดยใช้คำสั่ง union มาช่วยในการประกาศข้อมูลแบบยูเนียน โดยมีรูปแบบการประกาศดังนี้

รูปแบบที่ 1

union union_name

{

type1 name1;

type2 name2;

………

typeN nameN;

} union_var;

รูปแบบที่ 2 

union union_name

{

type1 name1;

type2 name2;

………

typeN nameN;

};

union union_name union_var;

โดยที่

union เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบยูเนียน

union_name เป็นชื่อข้อมูลแบบยูเนียน ใช้สำหรับการประกาศข้อมูลแบบยูเนียนกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มยูเนียนที่เคยประกาศไว้แล้ว

union_var เป็นชื่อตัวแปรยูเนียนใช้สำหรับการอ้างอิงภายในยูเนียน

type1 name1, type2 name2,…, typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2,…, nameN ว่า element 1, element2, …, element N ตามลำดับ

การอ้างอิงตัวแปรภายในข้อมูลแบบยูเนียน (accessing union members)

การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบยูเนียน สามารถทำได้โดยเรียกชื่อตัวแปรยูเนียน (union_var) ตามด้วยเครื่องหมาย . (period) จากนั้นก็ตามด้วยชื่อตัวแปรภายในยูเนียน (element_name หรือ member_name) ซึ่งมีลักษณะการอ้างอิงทำนองเดียวกันกับข้อมูลแบบโครงสร้าง

รูปแบบการอ้างอิงตัวแปรภายในยูเนียน

union_var.member_name