结构体、枚举、联合

目录

---

结构体

结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合，叫做结构。

结构体类型的声明

结构体的定义如下所示，struct为结构体关键字，tag为结构体的标志，member-list为结构体成员列表，其必须列出其所有成员；variable-list为此结构体声明的变量。

struct tag{
    member-list;
}variable-list;

在一般情况下，tag、member-list、variable-list这3部分至少要出现2个。
例如描述一个学生：

struct Stu{
    char name[20];//姓名
    int age;//年龄
    char sex[5];//性别
    char id[20];//学号
};//分号勿丢

在声明结构的时候，可以不完全声明：

//匿名结构体类型
struct{
    int a;
    char b;
    float c;
}s;

struct{
    int a;
    char b;
    float c;
}*p;

上面两个结构体声明的时候都省略了tag。
那么

p = &s;//合法么？

注意：虽然以上两个声明内容完全相同，但是编译器会把他们当成完全不同的两个类型，因此p = &s;是非法的。

结构体成员的访问

访问结构体成员有两种方法：

• 通过 . 操作符访问
  结构体变量访问成员是通过.操作符访问的，点操作符接受两个操作数。

#include <stdio.h>
#include <string.h>
struct Stu{
    char name[20];
    int age;
};

int main(){
    struct Stu s;//定义结构体变量
    strcpy(s.name, "zhangsan");
    s.age = 20;
    printf("%s %d\n",s.name, s.age);
    return 0;
}

• 通过->操作符访问
  当我们得到的不是一个结构体变量，而是一个指向结构体的指针时，就应当用->访问成员。

#include <stdio.h>
#include <string.h>
struct Stu{
    char name[20];
    int age;
};
void print(struct Stu *p){
    printf("%s %d\n",p->name, p->age);
    printf("%s %d\n",(*p).name, (*p).age);
}
int main(){
    struct Stu s;//定义结构体变量
    strcpy(s.name, "zhangsan");
    s.age = 20;
    print(&s);
    return 0;
}

结构体的自引用

结构体的自引用(self reference)，就是在结构体内部，包含指向自身类型结构体的指针。

//判断是正确的声明么？
struct Node{
    int data;
    struct Node next;
};

这种声明是错误的，结构体内部嵌套结构体，无限循环下去，无法确定占多少内存，因此是非法的。
正确的自引用为：

struct Node{
    int data;
    struct Node* next;
};

注意：

//在用typedef时，这样写正确么？
typedef struct{
    int data;
    Node* next;
}Node;

这种声明也是错误的，虽然Node* next;是指针，但是这里Node尚未定义，因此不能使用。
正确的声明：

typedef struct{
    int data;
    struct Node* next;
}Node;

结构体的不完整声明

当遇到以下的情况时，该如何处理？

struct A{
    int a;
    strcut B* pb;
};
struct B{
    int b;
    struct A* pa;
};

只能通过不完整声明来解决：

struct B;//不完整声明

struct A{
    int a;
    struct B* pb;
};
struct B{
    int b;
    struct A* pa;
};

结构体变量的定义和初始化

struct point{
    int x;
    int y;
}p1;//声明类型的同时定义变量p1
struct point p2;//定义结构体变量p2
struct point p = {2,3};//定义变量的同时赋初值

struct Stu{
char name[20];
int age;
};
struct Stu s = {"zhangsan", 20};//初始化

struct Node{
    int data;
    struct point p;
    struct Node* next;//结构体的自引用
}n1 = {10, {3,4}, NULL};//结构体嵌套初始化
struct Node n2 = {20, {4,5}, NULL};//结构体嵌套初始化

结构体内存对齐

先来看一个例题：

//在vs下，计算结构体的大小
struct S{
    char c;
    int a;
};

结构体S有两个成员，char c;占1个字节，int a;占4个字节，所以S占5个字节？
这种想法当然是不正确的，我们来介绍一个宏来更好的理解：

offsetof——该宏用于求结构体中一个成员在该结构体中的偏移量。

在msdn上，该宏被写作：size_t offsetof( structName, memberName );
第一个参数是结构体的名字，第二个参数是结构体成员的名字。该宏返回结构体structName中成员memberName的偏移量。偏移量是size_t类型的。

#include <stdio.h>
#include <stddef.h>
struct S{
    char c;
    int a;
};

int main(){
    printf("%zu\n",offsetof(struct S, c));
    printf("%zu\n",offsetof(struct S, a));
    return 0;
}

运行结果如下：

char c;偏移量为0，int a;偏移量为4，但char c;只占了1个字节，可见有3个字节的空间浪费，这里就体现出来结构体存在内存对齐。

为什么存在内存对齐？

1、平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总的来说：
结构体的内存对齐是拿空间来换取时间，浪费一些空间从而得到更高的效率。

结构体对齐规则

1. 第一个成员在偏移量为0的地址处。
2. 其他成员要对齐到该对齐数的整数倍的地址处。
   对齐数 = 编译器默认的对齐数 与 该成员大小 的 较小值。（vs中默认对齐数为8，
   Linux中默认对齐数为4）
3. 结构体的总大小为最大对齐数（每个成员都有一个对齐数）的整数倍。
4. 如果嵌套了结构体，嵌套结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是最大对齐数（含嵌套结构体的对齐数）的整数倍。

在了解了对齐规则后，再来试试解决一开始提出的问题：

//在vs下，计算结构体的大小
struct S{
    char c;
    int a;
};

如图所示：第一个成员 c 放在0偏移处，占1个字节；第二个成员 a 对齐数为vs编译器的默认对齐数8 与 int的大小4 中的较小值4，所以 a 应当从偏移量为4的位置开始存放4个字节，这时已经用了8个字节。最后结构体的总大小为每个成员中最大对齐数的整数倍，这里第一个成员对齐数为1，第二个成员对齐数为4，最大对齐数就是4。8正好是4的倍数，因此，结构体S的大小为8。

再来几道例题练习一下，在vs下，计算各个结构体的大小：

struct S1{
    char c1;
    int i;
    char c2;
};
struct S2{
    char c1;
    char c2;
    int i;
};
struct S3{
    double d;
    char c;
    int i;
};
struct S4{
    char c1;
    struct S3 s3;
    double d;
};

结构体S1大小为 12, 结构体S2大小为 8，结构体S2大小为 16,结构体S2大小为 32。

通过上面的例题了解了结构体的内存对齐，那我们在设计结构体的时候，既要满足结构对齐，又要节省空间，所以要让占空间小的成员尽量集中到一起。
例如：

struct S1{
    char c1;
    int i;
    char c2;
};
struct S2{
    char c1;
    char c2;
    int i;
};

结构体S1，S2的成员一模一样，但是S1，S2占用的空间却不同，明显S2更节省空间。

结构体传参

结构体传参时，应传结构体的地址。

struct S{
    int data[1000];
    int num;
};

struct S s = {{1,2,3,4},1000};
//结构体传参
void print1(struct S s){
    printf("%d\n",s.num);
}
//结构体传地址
void print2(strucr S* ps){
    printf("%d\n",ps->num);
}

int main(){
    print1(s);//传结构体
    print2(&s);//传地址
    return 0;
}

我们知道，函数传参的时候，参数是需要压栈的，那么如果传递一个结构体对象时，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降，因此，结构体传参时传结构体的地址。

位段

位段，C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field) 。利用位段能够用较少的位数存储数据。

位段的声明和结构体是类似的：

1. 位段的成员必须是int、unsigned int、signed int。
2. 位段的成员名后面必须有一个冒号和一个数字。

例如：

struct A{
    int a:2;
    int b:5;
    int c:10;
    int d:30;
};

A就是一个位段类型，那么A的大小是多少？

在int a:2;中的数字2是用来限定该成员所占的比特位，因此 a 只占2个比特位，同理，b 占5个比特位，c 占10个比特位。一个 int 占32个比特位，但是a、b、c加起来只占了17个比特位，可以都放在这一个 int 里，还剩余15个比特位，但是 d 占了30个比特位，剩余的15个明显放不下，这时，是要新开辟一个 int 呢，还是用完这15个比特位后再开辟下一个存放剩余的呢？这个是取决于编译器的，但是在vs编译器下，是直接开辟新的空间，浪费掉了这15个比特位。因此A的大小为8。

注意：

1. 位段不存在对齐，因为位段的存在本身就是为了节省空间，对齐反而浪费了空间。
2. 位段成员名后面的数字不能大于该成员类型的大小。例如int a:33;这样的写法就是错误的，本身一个int只能存放32个比特位，放不进去33个比特位。
3. 位段涉及的不确定因素很多，因此位段是不跨平台的。

位段不跨平台的原因：

1. int位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大的数目不能确定。（16位机器最大16，32位机器最大32）
3. 位段成员在内存中从左向右分配还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，也是不确定的。

---

枚举

枚举就是一一列举。
枚举在生活中很常见，例如：
一周七天：SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY。
一年十二个月：January 、February、March、April、May、June、July、August、September、October、November、December。

枚举类型的定义

//星期
enum Week{
    Mon,
    Tues,
    Wed,
    Thur,
    Fri,
    Sat,
    Sun
};
//性别
enum Sex{
    Male,
    Female,
    Secret

};

上面enum Week、enum Sex都是枚举类型，{ }中的内容是枚举类型的可能取值，也叫枚举常量。这些可能的取值都是有值的，默认从0开始，依次递增1，也可在定义的时候赋初值。
例如：

enum Sex{
    Male = 1,
    Female = 3,
    Secret//这里secret值为4

};

枚举的优点

我们用#define也可以定义常量，为什么非要用枚举？

1. 增加代码的可读性和可维护性。
2. define定义的标识符没有类型检查，枚举有类型检查，更加严谨。
3. 防止命名污染。
4. 便与调试。
5. 一次可以定义多个常量，使用方便。

枚举的使用

只能拿枚举常量给枚举变量赋值。

enum Color{
    RED = 1,
    YELLOW = 3,
    BLUE = 5
};
enum Color clr = BLUE;

这样的赋值可以么？clr = 5；
答案肯定是不行的，枚举常量不能修改。

---

联合（共用体）

联合又较共用体，是一种特殊的自定义类型，这种类型定义的变量也包含了一系列成员，特征是这些成员共用同一块空间。
例如：

//联合类型的声明
union Un{
    char c;
    int i;
};
//联合类型的定义
union Un un;

int main(){
    //计算联合的大小
    printf("%zu\n",sizeof(un));//4
    return 0;
}

联合成员共用同一块内存空间，一个联合变量的大小，至少是最大成员的大小，因为联合至少得有能力保存最大的成员。

联合大小的计算

• 联合的大小至少是最大成员的大小。
• 当最大成员的大小不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍。

例如：

union Un1{
    char c[5];
    int i;
};

union Un2{
    short c[7];
    int i;
};

Un1的大小为8，因为char c[5];占5个字节，int i;占4个字节，最大成员的大小为5，最大对齐数为4，因此需要对齐到4的倍数，所以是8。
Un2的大小为16，因为short c[7];占14个字节，int i;占4个字节，最大成员的大小为14，最大对齐数为4，因此需要对齐到4的倍数，所以是16。

#判断当前计算机大小端存储

来一道习题练习一下联合：
如何判断当前计算机是大端存储还是小端存储？
这里介绍两种方法：

1.将1存放在整形里，如果是小端存储的话，在内存中应该是 01 00 00 00，取出第一个字节，如果是1就是小端存储，否则是大端存储。

#include <stdio.h>
int check_sys(){
    int i = 1;
    return *(char *)&i;
}

int main(){

    int ret = check_sys();
    if(ret == 1){
        printf("小端存储\n");
    }
    else{
        printf("大端存储\n");
    }
    return 0;
}

2.利用联合中所有成员都共用同一块内存，将1赋给int，如果是小端存储，在内存中是
01 00 00 00，这时想要取出第一个字节中的内容，可通过char来取出，很巧妙。

#include <stdio.h>
int check_sys(){
    union Un{
        char c;
        int i;
    }un;
    un.i = 1;
    return un.c;
}

int main(){

    int ret = check_sys();
    if(ret == 1){
        printf("小端存储\n");
    }
    else{
        printf("大端存储\n");
    }
    return 0;
}

联合体和结构体的巧妙使用

将long类型的IP地址，转换为点分十进制的表示形式。

#include <stdio.h>
union ip_addr{
    unsigned addr;
    struct ip{
        unsigned char c1;
        unsigned char c2;
        unsigned char c3;
        unsigned char c4;
    }ip;
};
int main(){
    union ip_addr my_ip;
    my_ip.addr = 176238479;
    printf("%d.%d.%d.%d\n",my_ip.ip.c1, my_ip.ip.c2, my_ip.ip.c3, my_ip.ip.c4);
    return 0;
}

运行结果如下：

---