วันพฤหัสบดีที่ 10 กรกฎาคม พ.ศ. 2557

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

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  */

ผลลัพธ์ที่ได้จากโปรแกรม
แผนผังลำดับงาน: จอภาพ: Size   of  union intflo  = 4  Number  =  25  F  =  1.2345    Press any key back to program...
คำอธิบายโปรแกรม
            จากโปรแกรมตัวอย่างข้างต้น  เพื่อความเข้าใจเกี่ยวกับข้อมูลแบบ  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  */

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

แผนผังลำดับงาน: จอภาพ: Size   of  Structure  twointeger  = 4  Number1  =  25  Number2  =  70  Size   of  union intflo  = 4  Number3  =  55  F  =  9.8765    Press any key back to program...
            8.8.4 ข้อควรระวังในการใช้ยูเนียน
                        การใช้เนื้อที่ร่วมกันของตัวแปรต่างชนิดกัน    เมื่อใช้ตัวแปรใดแล้ว  ควรพิมพ์ค่าตัวแปรนั้นออมาก่อนที่จะใช้ตัวแปรตัวอื่น  เพราะข้อมูลเดิมจะหายไปเนื่องจากใช้เนื้อที่ร่วมกัน

ไม่มีความคิดเห็น:

แสดงความคิดเห็น