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。

相关文章

Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
usaco 1.3 Mixing Milk (结构体排序 qsort) and hdu 2020(sort)

usaco 1.3 Mixing Milk (结构体排序 qsort) and hdu 2020(sort)

到了这题学会了结构体排序 于是回去修改了 1.2 milking cows 的算法~ 结构体排序核心： 1.结构体定义 struct Milk{int price;int milks;}milk[5000]; 2.自定义的比较函数，若返回值为正，qsort 函数判定a>b ；为负，a<b；为0，a==b； int milkcmp(const void *va,c
阅读更多...
零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...
科研绘图系列：R语言扩展物种堆积图（Extended Stacked Barplot）

科研绘图系列：R语言扩展物种堆积图（Extended Stacked Barplot）

介绍 R语言的扩展物种堆积图是一种数据可视化工具，它不仅展示了物种的堆积结果，还整合了不同样本分组之间的差异性分析结果。这种图形表示方法能够直观地比较不同物种在各个分组中的显著性差异，为研究者提供了一种有效的数据解读方式。 加载R包 knitr::opts_chunk$set(warning = F, message = F)library(tidyverse)library(phyl
阅读更多...
透彻！驯服大型语言模型（LLMs）的五种方法，及具体方法选择思路

透彻！驯服大型语言模型（LLMs）的五种方法，及具体方法选择思路

引言 随着时间的发展，大型语言模型不再停留在演示阶段而是逐步面向生产系统的应用，随着人们期望的不断增加，目标也发生了巨大的变化。在短短的几个月的时间里，人们对大模型的认识已经从对其zero-shot能力感到惊讶，转变为考虑改进模型质量、提高模型可用性。 「大语言模型(LLMs)其实就是利用高容量的模型架构（例如Transformer）对海量的、多种多样的数据分布进行建模得到，它包含了大量的先验
阅读更多...
hdu 2489 (dfs枚举 + prim)

hdu 2489 (dfs枚举 + prim)

题意： 对于一棵顶点和边都有权值的树，使用下面的等式来计算Ratio 给定一个n 个顶点的完全图及它所有顶点和边的权值，找到一个该图含有m 个顶点的子图，并且让这个子图的Ratio 值在所有m 个顶点的树中最小。 解析： 因为数据量不大，先用dfs枚举搭配出m个子节点，算出点和，然后套个prim算出边和，每次比较大小即可。 dfs没有写好，A的老泪纵横。 错在把index在d
阅读更多...
[MySQL表的增删改查-进阶]

[MySQL表的增删改查-进阶]

🌈个人主页：努力学编程’ ⛅个人推荐： c语言从初阶到进阶 JavaEE详解 数据结构 ⚡学好数据结构，刷题刻不容缓：点击一起刷题 🌙心灵鸡汤：总有人要赢，为什么不能是我呢 💻💻💻数据库约束 🔭🔭🔭约束类型 not null: 指示某列不能存储 NULL 值unique: 保证某列的每行必须有唯一的值default: 规定没有给列赋值时的默认值.primary key:
阅读更多...
计算机毕业设计 大学志愿填报系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

计算机毕业设计 大学志愿填报系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

🍊作者：计算机编程-吉哥 🍊简介：专业从事JavaWeb程序开发，微信小程序开发，定制化项目、 源码、代码讲解、文档撰写、ppt制作。做自己喜欢的事，生活就是快乐的。 🍊心愿：点赞 👍 收藏 ⭐评论 📝 🍅 文末获取源码联系 👇🏻 精彩专栏推荐订阅 👇🏻 不然下次找不到哟~Java毕业设计项目~热门选题推荐《1000套》 目录 1.技术选型 2.开发工具 3.功能
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2