聯合體，枚舉類型

聯合體基本概念

 聯合體也叫共同體，共用體，從外表看聯合體與結構體長得很相似，結構體每個成員都有本身獨立的內存空間，可是聯合體則共用同一片內存空間,也就是聯合體同時只能容許一個變量存在。
 特色:
  1.聯合體的內部是以堆疊的形式存在的；
  2.整個聯合體的尺寸取決於，成員中尺寸最大的那個成員；
  3.給聯合體成員賦值的時候只有最後一個是有效數據 （其餘數據被踐踏）；
  4.聯合體的成員之間是互相排斥的，在某一時刻只有一個成員有效。

聯合體的定義：

union 聯合體的標籤 {
 
      成員1 ; 
      成員2 ; 
      成員3 ; 
      ...... ....
    };

 語法：
  聯合體的標籤:用來區分不一樣的聯合體
  成 員：是指包含在聯合體內的各個成員，能夠是任意類型

聲明聯合體

typedef union my_union{

      int    a;
      double b;
      char   c;
    }my_uin, *p_my_uin;

    int main(int argc, char const *argv[]){   
      
        my_uin my_union1;    
        int size = sizeof(my_uin);     
        printf("%d\n" , size);          
        return 0;
    }

聯合體操做

 聯合體的操做與結構體沒有差異，可是因爲聯合體的內存特性， 在賦值/初始化的時候，只有最後一個/第一個數據是有效數據。

普通初始化

//普通初始化只有第一個成員是有效的
    my_uin my_union1 = {100, 0.01, 'a'};  
    printf("my_union1.a:%d\t my_union1.b:%lf\t my_union1.c:%c\n", my_union1.a, my_union1.b, my_union1.c);

輸出：my_union1.a:100  my_union1.b:0.000000    my_union1.c:d   //注意：my_union1.c輸出的'd'是無效值，正確的值應該是'a'

指定成員初始化

//指定成員初始化只有最後一個成員是有效的
    my_uin my_union2 = {

      .a = 100,
      .b = 0.02,
      .c = 'b'
    };
    printf("my_union2.a:%d\t my_union2.b:%lf\t my_union2.c:%c\n", my_union2.a, my_union2.b, my_union2.c);

輸出：my_union2.a:98   my_union2.b:0.000000    my_union2.c:b //注意：my_union2.a是無效值

指定成員賦值

my_uin my_union3;
    my_union3.a = 100;
    printf("my_union3.a: %d\t my_union3.b: %f\t my_union3.c:%c \n", my_union3.a, my_union3.b, my_union3.c); 
    my_union3.b = 0.03;
    printf("my_union3.a: %d\t my_union3.b: %f\t my_union3.c:%c \n", my_union3.a, my_union3.b, my_union3.c); 
    my_union3.c = 'c';
    printf("my_union3.a: %d\t my_union3.b: %f\t my_union3.c:%c \n", my_union3.a, my_union3.b, my_union3.c); 
    
輸出：
my_union3.a:100        my_union3.b: 0.000000        my_union3.c:d 
my_union3.a:-343597384 my_union3.b: 0.030000        my_union3.c:
my_union3.a:-343597469 my_union3.b: 0.030000        my_union3.c:c

注意：
聯合體的成員之間是互相排斥的，在某一時刻只有一個成員有效，即便輸出的值是正確的。

共同體指針指定成員初始化

//共同體指針指定成員初始化只有最後一個指定的是有效的
    p_my_uin p_my_union1 = NULL;
    p_my_union1 = (p_my_uin)calloc(1, sizeof(my_uin)); //注意，共同體指針須要給它指向一個空間，這個'空間的類型'是my_uin

    p_my_union1->a = 100;
    p_my_union1->b = 0.001;
    p_my_union1->c = 'c';
    printf("p_my_union1->a:%d\t p_my_union1->b:%lf\t p_my_union1->c:%c\n" ,p_my_union1->a, p_my_union1->b,  p_my_union1->c); 
    free(p_my_union1);
    p_my_union1 = NULL;

輸出：p_my_union1->a:-755914397       p_my_union1->b:0.001000         p_my_union1->c:c  //最後一個值纔是有效

聯合體的使用

 聯合體不多單獨去使用，通常會與結構體一塊兒使用， 用來表達某個互斥的屬性.

typedef struct my_struct{

       int a;
       float b;
       char c;

       my_uin my_union4; //注意my_uin，在上面的程序中已經聲明瞭
    }my_str, *p_my_str;

    int main(int argc, char const *argv[]){
     
       my_str my_struct1 ;     
       my_struct1.my_union4.f = 345.123;     
       printf("my_struct1.my_union4.f: %lf\n",my_struct1.my_union4.f);     
       return 0; 
    } 

輸出：my_struct1.my_union4.f: 345.123

枚舉類型

 枚舉類型本質上是一個受限制的整型數據，好比咱們用0-6 表示6個命令，0-3來表示4個狀態......

enum {

       枚舉常量1,
       枚舉常量2,
       枚舉常量3,
       ....
    };

注意：
1.枚舉常量本質上是整型，首個枚舉常量默認是0；
2.枚舉常量在沒有賦值的狀況下，是前一個枚舉常量的值+1；
3.枚舉常量能夠接受賦值；
4.枚舉常量支持全部整形的操做。