C语言进阶第七课-----------自定义类型的讲解（结构体枚举联合）

2023-10-20 06:04
文章标签 语言 进阶 类型 讲解 自定义 联合 结构 枚举 ----------- 第七课

本文主要是介绍C语言进阶第七课-----------自定义类型的讲解（结构体枚举联合），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

作者前言

🎂 ✨✨✨✨✨✨🍧🍧🍧🍧🍧🍧🍧🎂
​🎂 作者介绍： 🎂🎂
🎂 🎉🎉🎉🎉🎉🎉🎉 🎂
🎂作者id：老秦包你会， 🎂
简单介绍：🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂
喜欢学习C语言和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂
🎂个人主页::小小页面🎂
🎂gitee页面:秦大大🎂
🎂🎂🎂🎂🎂🎂🎂🎂
🎂 一个爱分享的小博主 欢迎小可爱们前来借鉴🎂

自定义类型

  • **作者前言**
  • 结构体
    • 结构体的声明
      • 结构的基础知识
      • 声明
    • 结构的自引用
    • 结构体变量的定义和初始化
    • 结构体内存对齐
    • 结构体内存对齐的意义
    • 修改默认对齐数
    • 结构体传参
    • 位段
    • 位段的内存分配
    • 位段跨平台的问题
  • 枚举
    • 枚举的定义
    • 枚举的优点
  • 联合体
    • 联合体的定义
    • 联合体大小的计算
    • 联合体的应用
    • 总结

结构体

结构体的声明

在C语言中，有自己的内置类型，如int 、double、 float、 等等，这些类型只能解决一些问题，但是还有一些问题无法解决，比如定义一个人，而有头、手…等许多的特征,如果光靠这里些类型来描述这些很难完成,而结构体就是为了解决这个问题出现的

结构的基础知识

结构是一些值的集合，这些值称为成员变量，结构体的成员可以是不同的变量，这跟为我们学习过的数组很像，数组是一组相同类型元素的集合。

声明

#include<stdio.h>
struct tag1
{int hand;int head;int leg;} person;
person = { 1,2,3 };
struct tag2
{int hand;int head;int leg;} Person2 = { 2,1,3 };typedef struct tag3
{int hand;int head;int leg;
}st;
int main()
{struct tag1 Person1 = { 2,1,2 };st Person3 = { 2,1,3 };return 0;
}

这里我只是列举了两三种结构类型的声明方式
还有一种匿名结构体声明，只能使用一次，就是在声明的时候进行使用，一旦结束声明就会销毁

#include<stdio.h>
struct
{char name[20];char auother[30];int a;
} ar = {"fdfdg", "fg", 5}, *ps = &ar;
int main()
{printf("%p\n", ps);printf("%s\n", ps->name);printf("%s\n", ps->auother);return 0;
}

这种结构体只能使用一次

结构的自引用

小小插曲：
数据结构：描述 的是数据在内存中存储和组织的结构
例如 我们存储12345在内存中是连续存放
在这里插入图片描述
安照这种结构（线性数据结构）我们称之为顺序表
在这里插入图片描述
如果按照这个结构（线性数据结构），我们称之为链表，图中的每一个存储的方框都是一个节点

#include<stdio.h>struct Node
{int num;//存放数据--数据域struct Node* pa;//存放下一个结构体的地址--指针域};
int main()
{struct Node a5 = { 5, NULL };struct Node a4 = { 4, &a5};struct Node a3 = { 3, &a4 };struct Node a2 = { 2, &a3 };struct Node a1 = { 1, &a2 };struct Node* p = &a1;while (p){printf("%d\n", p->num);p = (*p).pa;}return 0;
}

而结构体的自引用也就是自己的成员有自己类型的指针
自引用方式：

 struct Node
{int num;struct Node* pa;};

需要注意的是匿名结构体不行,即使使用了typedef类型重定义也不行,

 typedef struct Node
{int num;Node* pa;}Node;

这种写法是错误的,因为类型重定义还没有执行完就直接使用就会报错,代码从上往下执行,
在这里插入图片描述

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

在前面我写的结构体声明有很多种,初始化也有多种

#include<stdio.h>
struct Point
{int a;int b;} a1 = {1,2}, s1; //1struct Sp
{int a;
};struct Sd
{int b;struct Sp c;
};struct Point a2 = { 1,2 };//2
int main()
{struct Point s = { 3,4 };//3s1.a = 3;//4s1.b = 6;struct Point s3 = { s3.a = 5, s3.b = 9 };//5struct Point s4 = { .a = 5, .b = 9 };struct Sd s5 = { 4, {6} };printf("%d", s5.c.a);return 0;
}

这里我列举了一些定义和初始化的情况,包含结构体嵌套结构体

结构体内存对齐

#include<stdio.h>
struct S1
{int a;char b;short c;};
struct S2
{short c;int a;char b;};
int main()
{printf("%d\n", sizeof(struct S1));printf("%d\n", sizeof(struct S2));return 0;
}

在这里插入图片描述
可以看到两个结构体,大小不一样,但是成员是一样的,是啥造成这个原因?
其实就是关于结构体内存对齐
首先得掌握结构体的对齐规则：

  1. 第一个成员在与结构体变量偏移量为0的地址处。
  2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
    对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
    VS中默认的值为8
  3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
  4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
    体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
    在这里插入图片描述

也就是说在结构体的大小是由内存对齐决定的，结构体的第一个成员的开辟的空间必须是在偏移量为0的地址处
这里我引入一个宏offsetof 计算结构体成员的偏移量
在这里插入图片描述
第一个参数就是结构体类型，第二个参数就是结构体成员
返回值：
类型为 size_t 的值，其偏移值为类型中的成员。

#include<stdio.h>
#include<stddef.h>
struct S1
{int a;char b;short c;};
int main()
{printf("%d\n", offsetof(struct S1, a));printf("%d\n", offsetof(struct S1, b));printf("%d\n", offsetof(struct S1, c));printf("%d", sizeof(struct S1));return 0;
}

在这里插入图片描述
我们来模拟一下这个宏

#include<stdio.h>
#include<stddef.h>
#define OFFSETOF(type, money) (size_t)(&(((type*)0) ->money))//设计一个结构体初始地址，使用 ->可以找到对应的成员,然后取地址,因为offsetof的返回值的类型为size_t
struct stu
{char name[20];int money;
};
int main()
{printf("%zd\n", OFFSETOF(struct stu, money));printf("%zd\n", offsetof(struct stu, money));return 0;
}

在这里插入图片描述
如果我们要计算出结构体的内存对齐情况，不可能全部根据offsetof来确定，所以我们要学会计算结构体内存对齐
在vs编译器中默认的对齐数是8，而成员的对齐数是成员的大小（空间大小）和vs编译器默认的对齐数进行比较，取最小的为该成员的对齐数
在这里插入图片描述
变量a从结构体变量的偏移量为0的地址处开始，存放4个字节，当我们遇到变量b对齐时要判断这个地址处是否是b的对齐数的整数倍，图中的地址4是1的整数倍，所以可以对齐，遇到变量c时，因为c的对齐数是2.而5不是2的倍数，所以要往后找。直到找到是2的倍数的地址，当我们把所有的成员对齐后，计算出目前结构体的大小，结构体的大小是该结构体最大对齐数的整数倍，而图中的当我们对齐完刚刚好，大小为8，而结构体的最大对齐数为4

结构体内存对齐的意义

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

在32位机器中 有字长的概念，字长的长度是32位bit ，也就是4个字节，也就是从计算机中读取一次就读取4个字节
假设结构体没有内存对齐，就会可能造成一些情况，一个数据要读取两次才能读取完整
在这里插入图片描述
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。

如果我们要结构体既满足对齐又节约空间的方法：

  1. 让占空间小的成员尽量靠在一起

修改默认对齐数

vs编译器默认的对齐数是8，如果我们要修改这个对齐 数就要使用#pragma pack（）来设计

#include<stdio.h>
#include<stddef.h>
#pragma pack(1)//设计对齐数为1
struct S3
{double d;char c;int i;
};
#pragma pack()//取消设计的对齐数
struct S4
{double d;char c;int i;};
int main()
{printf("%d\n", sizeof(struct S4));printf("%d\n", sizeof(struct S3));return 0;
}
  • #pragma pack(1)//设计对齐数为1
  • #pragma pack()//取消设计的对齐数,还原vs默认对齐数

结构体传参

传参有两种一种是传值，一种是传地址，
传值

#include<stdio.h>
#include<stddef.h>
struct S
{int a;int arr[10];};
void print(struct S s)
{int i = 0;for (i = 0; i < 9; i++) {printf("%d ", s.arr[i]);}
}
int main()
{struct S s = { 5,{1,2,3,4,5,6,7,8,9} };print(s);return 0;
}

传地址

#include<stdio.h>
#include<stddef.h>
struct S
{int a;int arr[10];};
void pri(struct S* p)
{int i = 0;for (i = 0; i < 10; i++){printf("%d ", p->arr[i]);}
}
int main()
{struct S s = { 5,{1,2,3,4,5,6,7,8,9} };pri(&s);return 0;
}

两种差异，假设结构体的大小很大，传值的时候又会开辟一块一模一样的临时空间（压栈），，而传值调用，虽然也会压栈，但是开辟的空间只有4个字节，所以我建议结构体尽量使用传地址，
如果我们不想修改结构体成员的值，我们可以使用const修饰参数，或者使用传值调用。
传地址效率会很好

位段

位段是为了节省空间的，但也会浪费空间。
位段的声明和结构是类似的，有两个不同：

  1. 位段的成员必须是 int、unsigned int 或signed int 。
  2. 位段的成员名后边有一个冒号和一个数字。
  3. 位段的位指的是二进制位，bit
  4. 在c99以后，位段的成员也可以是其他类型，但基本上是int 和char
    为啥要有位段呢？
    在这里插入图片描述
    我们可以想想我们有时候存储一些数据的时候，会有一些空间被浪费掉，只是用了其中的一个或者几个比特位
#include<stdio.h>
#include<stddef.h>
struct A
{int a : 2;//占2个bitint b : 4;//占4个bitint c : 6;//占6个bit
};
struct B
{int a;int b;int c;
};
int main()
{printf("%d\n", sizeof(struct A));printf("%d\n", sizeof(struct B));return 0;
}

在这里插入图片描述

位段的内存分配

  1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
  2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
  3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
    在我们使用位段的时候，规定了一个成员占几个bit，当开辟好空间后，这些成员怎么存，从哪边开始使用，我们是不知道的，
    我以下面为例
    在这里插入图片描述
    在这里插入图片描述
    这是一个字节，如果我们要把a存储进去，是要存放在左边还是右边或者是中间呢？我们是不知道的，但是我们是可以探究的
    以vs编译器为例
#include<stdio.h>
#include<stddef.h>
struct A
{char a : 3;char b : 4;char c : 5;char d : 4;
};int main()
{struct A s = { 0 };s.a = 10;s.b = 12;s.c = 3;s.d = 4;return 0;
}

我们知道，连续的地址会有高低地址，在vs编译器中，位段的存储是先使用高地址进行存储的，上图代码，中先开辟一个字节进行存储a，然后再存储b如果剩下的空间足够b存储，就不会开辟新的空间，
在这里插入图片描述
a = 10 补码二进制位为：1010，但是a的大小只有3个bit，所以会丢失数据只存储了010
b = 12 补码二进制位为：1100 b的大小为4bit，所以不会丢失数据
c = 3 补码二进制位为：011，因为c的大小为5bit 所以 会存储 00011
d = 4 补码二进制位为：100 ，因为大小为4bit 所以会存储0100
最终结果为011000100000001100000100，换算成十六进制62 03 04
在这里插入图片描述
结果是一模一样的

位段跨平台的问题

  1. int 位段被当成有符号数还是无符号数是不确定的。
  2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
    器会出问题。
  3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
  4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
    在这里插入图片描述
    总结：
    跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

枚举

在前面我们在定义常量的时候就运用到了enum
常量：

  1. 字符常量
  2. const 修饰的常变量
  3. #define定义的
  4. enum的枚举常量

枚举的定义

枚举的作用是把一些情况一一列举出来

enum Day
{MON,//枚举常量TUES,WED,THUR,FRI,SAT,SUN};

这种写法是使用默认值
而下面这种写法可以自己定义值

enum Day
{MON = 1,TUES = 2,WED = 3,THUR = 4,FRI = 5,SAT = 6,SUN = 7};

我们在使用枚举时可以定义枚举类型变量进行接收
在这里插入图片描述
枚举常量是有类型,类型不是int ,在C语言中可以使用整形变量接收枚举常量,但是在c++却不行

枚举的优点

  1. 增加代码的可读性和可维护性
  2. 和#define定义的标识符比较,枚举有类型检查,更加严谨
  3. 便于调试
  4. 使用方便,一次可以定义多个变量

联合体

联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。和结构体的定义相似
联合体的关键字: union

联合体的定义


```sql
#include<stdio.h>
#include<stddef.h>
union Un
{char a;int b;
};
int main()
{printf("%zd\n", sizeof(union Un));union Un aa;printf("%p\n", &(aa.a));printf("%p\n", &(aa.b));return 0;
}

在这里插入图片描述
可以看到联合体成员公用一块空间
在这里插入图片描述
那怎么计算联合体的大小呢?
我们可以想想,既然要共用一块空间,那么这块空间就要有最大成员空间的大小,这样才能保证成员能正常存储
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

如果我们要使用联合体进行赋值可以这样赋值

#include<stdio.h>
#include<stddef.h>
union Un
{char a;int b;
};
int main()
{union Un aa;aa.a = 'a';aa.b = 0xffffff12;return 0;
}

如果使用union Un aa = {‘b’};就相当于全部成员都初始化了,因为成员之间公用一块空间
但是我们还是不知道共用了空间,一旦修改会变动哪一部分
前面我们知道,内存的存储是分大、小端存储的,我们还写了判断大、小端存储的方法

#include<stdio.h>
#include<stddef.h>
int check_sys()
{union Un{char a;int b;};union Un te;te.b = 1;return te.a;}
int main()
{int a = 1;char* p = (char*)&a;//int a = check_sys();if (*p){printf("小端存储");}else{printf("大端存储");}return 0;
}

图中定义的函数,里面的联合体就是利用了这一特性
在这里插入图片描述
这里是vs存储1的情况是小端存储,

联合体大小的计算

  1. 联合的大小至少是最大成员的大小。
  2. 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
#include<stdio.h>
#include<stddef.h>
union Un1
{char arr[7];int a;
};
union Un2
{int arr[7];long long a;
};int main()
{printf("%d\n", sizeof(union Un1));printf("%d\n", sizeof(union Un2));return 0;
}

这个代码就可以很清楚的明白了
在这里插入图片描述

联合体的应用

#include<stdio.h>
#include<stddef.h>
struct prize
{int stock_number;//库存double price;//定价int item_type;//商品类型union{struct{char title[20];//书名char author[20];//作者int ngnum_pages;//页数} book;struct{char design[30];//设计}mug;struct{char design[30];//设计int colors;//颜色int sizes;//尺寸}shirt;} item;};int main()
{//书struct prize Book;//杯子struct prize Cup;//被子struct prize blanket;return 0;
}

总结

结构体、枚举、联合体的声明都有匿名声明，如果有不懂可以私聊我

​

这篇关于C语言进阶第七课-----------自定义类型的讲解（结构体枚举联合）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/245173。

相关文章

R语言中的正则表达式深度解析

R语言中的正则表达式深度解析

《R语言中的正则表达式深度解析》正则表达式即使用一个字符串来描述、匹配一系列某个语法规则的字符串,通过特定的字母、数字及特殊符号的灵活组合即可完成对任意字符串的匹配,：本文主要介绍R语言中正则表达... 目录前言一、正则表达式的基本概念二、正则表达式的特殊符号三、R语言中正则表达式的应用实例实例一：查找匹配
阅读更多...
Go语言结构体标签(Tag)的使用小结

Go语言结构体标签(Tag)的使用小结

《Go语言结构体标签(Tag)的使用小结》结构体标签Tag是Go语言中附加在结构体字段后的元数据字符串,用于提供额外的属性信息,这些信息可以通过反射在运行时读取和解析,下面就来详细的介绍一下Tag的使... 目录什么是结构体标签？基本语法常见的标签用途1.jsON 序列化/反序列化（最常用）2.数据库操作（
阅读更多...
SpringBoot全局异常拦截与自定义错误页面实现过程解读

SpringBoot全局异常拦截与自定义错误页面实现过程解读

《SpringBoot全局异常拦截与自定义错误页面实现过程解读》本文介绍了SpringBoot中全局异常拦截与自定义错误页面的实现方法,包括异常的分类、SpringBoot默认异常处理机制、全局异常拦... 目录一、引言二、Spring Boot异常处理基础2.1 异常的分类2.2 Spring Boot默
阅读更多...
自定义注解SpringBoot防重复提交AOP方法详解

自定义注解SpringBoot防重复提交AOP方法详解

《自定义注解SpringBoot防重复提交AOP方法详解》该文章描述了一个防止重复提交的流程,通过HttpServletRequest对象获取请求信息,生成唯一标识,使用Redis分布式锁判断请求是否... 目录防重复提交流程引入依赖properties配置自定义注解切面Redis工具类controller
阅读更多...
MySQL快速复制一张表的四种核心方法(包括表结构和数据)

MySQL快速复制一张表的四种核心方法(包括表结构和数据)

《MySQL快速复制一张表的四种核心方法(包括表结构和数据)》本文详细介绍了四种复制MySQL表（结构+数据）的方法,并对每种方法进行了对比分析,适用于不同场景和数据量的复制需求,特别是针对超大表（1... 目录一、mysql 复制表（结构+数据）的 4 种核心方法（面试结构化回答）方法 1：CREATE
阅读更多...
SQL Server中行转列方法详细讲解

SQL Server中行转列方法详细讲解

《SQLServer中行转列方法详细讲解》SQL行转列、列转行可以帮助我们更方便地处理数据,生成需要的报表和结果集,：本文主要介绍SQLServer中行转列方法的相关资料,需要的朋友可以参考下... 目录前言一、为什么需要行转列二、行转列的基本概念三、使用PIVOT运算符进行行转列1.创建示例数据表并插入数
阅读更多...
C++,C#,Rust,Go,Java,Python,JavaScript的性能对比全面讲解

C++,C#,Rust,Go,Java,Python,JavaScript的性能对比全面讲解

《C++,C#,Rust,Go,Java,Python,JavaScript的性能对比全面讲解》：本文主要介绍C++,C#,Rust,Go,Java,Python,JavaScript性能对比全面... 目录编程语言性能对比、核心优势与最佳使用场景性能对比表格C++C#RustGoJavapythonjav
阅读更多...
MyBatis中的两种参数传递类型详解(示例代码)

MyBatis中的两种参数传递类型详解(示例代码)

《MyBatis中的两种参数传递类型详解(示例代码)》文章介绍了MyBatis中传递多个参数的两种方式,使用Map和使用@Param注解或封装POJO,Map方式适用于动态、不固定的参数,但可读性和安... 目录✅ android方式一：使用Map<String, Object>✅ 方式二：使用@Param
阅读更多...
C语言逗号运算符和逗号表达式的使用小结

C语言逗号运算符和逗号表达式的使用小结

《C语言逗号运算符和逗号表达式的使用小结》本文详细介绍了C语言中的逗号运算符和逗号表达式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习... 在Ｃ语言中逗号“，”也是一种运算符，称为逗号运算符。 其功能是把两个表达式连接其一般形式为：表达
阅读更多...
Go语言实现桥接模式

Go语言实现桥接模式

《Go语言实现桥接模式》桥接模式是一种结构型设计模式,它将抽象部分与实现部分分离,使它们可以独立地变化,本文就来介绍一下了Go语言实现桥接模式,感兴趣的可以了解一下... 目录简介核心概念为什么使用桥接模式？应用场景案例分析步骤一：定义实现接口步骤二：创建具体实现类步骤三：定义抽象类步骤四：创建扩展抽象类步
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2