其他分享
首页 > 其他分享> > 联合体,枚举类型

联合体,枚举类型

作者:互联网

联合体基本概念

 联合体也叫共同体,共用体,从外表看联合体与结构体长得很类似,结构体每一个成员都有自己独立的内存空间,但是联合体则共用同一片内存空间,也就是联合体同时只能允许一个变量存在。
 特点:
  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.枚举常量支持所有整形的操作。

标签:联合体,union3,uin,union1,枚举,类型,my
来源: https://www.cnblogs.com/ding-ding-light/p/14094268.html