C语言中的自定义类型：结构体、枚举、联合

我们知道c语言基本数据类型有：

本篇将重点介绍C语言中的自定义类型：结构体、枚举、联合

undefined结构体

定义：结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

构造：

struct 结构体名

{

结构体所包含的变量或数组

};

声明与定义

struct Stu

{    char name[20];//名字

    int age;//年龄

    char sex[5];//性别

    char id[20];//学号}；int main()

{    struct Stu s;    return 0;

}12345678910111213

代码含义：

struct Stu是结构体类型，相当于int、float，不申请空间。Stu是结构体标签。

struct Stu s通过类型创建变量，申请空间（实例化）。

不完全声明（匿名结构体类型）

#define _CRT_SECURE_NO_WARNINGS 1#include #include struct{    int a;    char b;    float c;

}x;struct{    int a;    char b;    float c;

}*p;int main()

{

    p = &x;

    system("pause");    return 0;

}123456789101112131415161718192021

上面的代码执行后发现是有bug的！ 小编推荐一个学C语言/C++的学习裙【 六二七，零一二，四六四 】，无论你是大牛还是小白，是想转行还是想入行都可以来了解一起进步一起学习！裙内有开发工具，很多干货和技术资料分享！

这是因为编辑器会把上面两个声明当成完全不同的两个类型。

正确代码：

struct {    int a;    char b;    float c;

}x,*p;int main()

{

    p = &x;

    system("pause");    return 0;

}123456789101112

结构体的访问

结构体变量访问成员

结构变量的成员是通过定操作符（.）访问的。点操作符接受两个操作数

struct S s; 

strcpy(s.name, "zhangsan");// ֵ使用.访问name成员s.age = 20;//使用.访问age成员1234

结构体访问指向变量的成员

有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。

struct S 

{    

    char name[20];  

    int age;  

}s;

void print(struct S* ps) 

{    

    printf("name = %s   age = %d\n", (*ps).name, (*ps).age); 

    printf("name = %s   age = %d\n", ps->name, ps->age);                

}12345678910

结构体的自引用

struct Node 

{    

    int data;    

    struct Node* next; //指向同类型数据的指针};{{123456:0}}

结构体的不完整声明

struct B; //不完整声明struct A 

{    

    int _a;    

    struct B* pb; 

}; 

struct B 

{    

    int _b;    

    struct A* pa; 

};123456789101112

结构体的内存对齐

为什么存在内存对齐

1.平台原因（移植原因）

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定的数据，否则抛出硬件异常。

2.性能原因

数据结构（尤其是栈）应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要两次内存访问；而对其的内存访问仅需要一次访问。

结构体对齐原则

1.第一个成员在与结构体变量偏移量为0 的地址处。

2.其他成员变量要对齐放到某个数字（对齐数）的整数倍的地址处。对齐数=编译器默认的一个对齐数与该成员大小的较小值。

VS中默认的值是8，Linux中默认的值是4。

3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

总的来说，结构体的内存对齐是拿空间来换取时间的做法

struct S1

{    char c1;    int i;    char c2;

}printf("%s\n",sizeof(struct S1));//1+3+4+1+3=12struct S2 

{    

    char c1;    

    int i; 

}; 

printf("%d\n", sizeof(struct S2));//1+1+2+4=8struct S3 

{    

    double d;    

    char c;    int i; 

}; 

printf("%d\n", sizeof(struct S3));//8+1+3+4=16struct S4 

{    

    char c1;    struct S3 s3;    double d;

}printf("%d\n", sizeof(struct S4));//1+7+16+8=32123456789101112131415161718192021222324252627282930

结构体传参

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

struct S

{

    char c1;

    int i;

    char c2;

}

void print(struct S *ps)

{    ...}

int main()

{

    print（&s）;    return 0;

}12345678910111213141516

undefined位段

与结构体不同的是：

位段的成员必须是 int、unsigned int、int 或signed int 、char（属于整型家族类型）

位段的成员名后边有一个冒号和一个数字

位段的分配内存

位段的空间是按照需要以1个字节（char）或4个字节（int）的方式来开辟的

位段涉及很多不确定因素，位段是不跨平台的，注重可移植性的程序应该避免使用位段

struct  S 

{    

    char _a:3;    

    char _b:4;    

    char _c:5;    

    char _d:4; 

}struct S s={0};

s.a=10;

s.b=12;

s.c=3;

s.d=4;printf("%d\n",sizeeof(struct S));//31234567891011121314

位段的跨平台问题

int位段被当作有符号数还是无符号数无法确定

位段中最大位的数目不能确定（16位机器最大16，32位机器最大32）

位段中的成员在内存中从左向右分配，还是从右向左分配标准未定义。

当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，时舍弃剩余的位还是利用，这是不确定的。

跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在

undefined枚举

定义：顾名思义就是把可能的取值一一列举

构造：

enum 枚举名{

标识符[=整型常数],

标识符[=整型常数],...标识符[=整型常数]

} 枚举变量;{{123456:0}}

如果枚举没有初始化, 即省掉”=整型常数”时, 则从第一个标识符开始, 顺

次赋给标识符0, 1, 2, …。但当枚举中的某个成员赋值后, 其后的成员按依次

加1的规则确定其值。

声明与定义

enum Color

{

    RED=1,

    GREEN=2;

    BLUE=4;

};enum Color clr = GREEN;{{1234567:0}}

enum Color是枚举类型

{}中的内容是枚举类型的可能取值，也叫枚举常量。这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。

注意:

枚举中每个成员(标识符)结束符是”,”, 不是”;”, 最后一个成员可省略”,”。

初始化时可以赋负数, 以后的标识符仍依次加1。

枚举变量只能取枚举说明结构中的某个标识符常量。

枚举优点

增加代码可读性和可维护性

和#define定义的标识符比较，枚举有类型检查，更加严谨。

防止了命名污染（封装）

便于调试

使用方便，一次可以定义多个常量

undefined联合（共用体）

定义： 在进行某些算法的C语言编程的时候，需要使几种不同类型的变量存放到同一段内存单元中。这种几个不同的变量共同占用一段内存的结构，在C语言中，被称作”共用体”类型结构，简称共用体。

构造：

union 共用体名{成员表列

}变量表列;1234

声明与定义

我们用一段代码说明，用结构体判断编译器的大小端（面试题）

int check_sys()

{    union Un

    {        int i;        char c;

    }un;

    un.i=1;    return un.c ;

}int main()

{    if(check_sys()==1)        printf("小端\n");    else

        printf("大端\n");        return 01234567891011121314151617

联合的特点

同一个内存段可以用来存放几种不同类型的成员，但是在每一瞬间只能存放其中的一种，而不是同时存放几种。换句话说，每一瞬间只有一个成员起作用，其他的成员不起作用，即不是同时都在存在和起作用。

共用体变量中起作用的成员是最后一次存放的成员，在存入一个新成员后，原有成员就失去作用。

共用体变量的地址和它的各成员的地址都是同一地址。

不能对共用体变量名赋值，也不能企图引用变量名来得到一个值。

共用体类型可以出现在结构体类型的定义中，也可以定义共用体数组。反之，结构体也可以出现在共用体类型的定义中，数组也可以作为共用体的成员。

共用体变量也可以作为函数的参数和返回值

联合大小的计算

联合的大小至少是最大成员的大小

当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

union Un1 

{    

    char c[5];    

    int i; 

}; 

union Un2 

{    

    short c[7];    

    int i; 

}; 

printf("%d\n", sizeof(union Un1)); //5*1+3=8printf("%d\n", sizeof(union Un2));//7*2+2=16123456789101112

undefined结构体和共同体的结合使用

我们网络的IP地址是long类型的一段数字，如： {{19237271:0}}，但是为了方便读写，我们写成点分十进制形式:192.37.27.1

那么我们怎么转换呢？

union ip_add

{    unsigned long addr;    struct 

    {        unsigned char c1;        unsigned char c2; 

        unsigned char c3;        unsigned char c4;

    }ip;

};int main()

{    union ip_addr my_ip;

    my_ip.addr={{19237271:0}};    printf("%d.%d.%d.%d\n",my_ip.ip.c4,my_ip.ip.c3,my_ip.ip.c2,my_ip.ip.c1);    return 0;

}123456789101112131415161718