一、结构体

在初识结构体一文中,我们对结构体已经有所了解.

1.结构体的声明,
2.结构体变量的定义与初始化,
3.结构体传参.

其实结构体是一个很重要的内容,在数据结构中,应用十分广泛.所以学好结构体也是十分重要的!

1.1 匿名结构体

匿名结构体是一种省略struct后面的类型名的一种结构体类型.
这种情况好少见,是我们需要使用这个结构体一次时,后面不会再用这个结构体时使用.(个人感觉用处不大).
是一种不完全结构体的声明.

struct
{int age;//年龄char name[10];//姓名float grade;//成绩
}s1 = { 18,"初阶牛",80.0f };
int main()
{printf("%d %s %f\\n", s1.age,s1.name,s1.grade);return 0;
}

注意匿名结构体只有在声明结构体时的后面定义变量,否则对于一个没有名字的结构体,下次想使用就很难找到它了.

补充知识:

两个拥有相同成员变量的结构体,他们是同一类型的结构体吗?
对于两个拥有相同成员变量的结构体,编译器并不会将他们视作同一结构体类型.

//匿名结构体类型
struct s1
{int age;//年龄char name[10];//姓名double grade;//成绩
}s1 = { 18,"初阶牛",50 };struct s2
{int age;//年龄char name[10];//姓名double grade;//成绩
}  *p;int main()
{p = &s1;printf("%d %s %lf\\n", p->age, p->name, p->grade);return 0;
}

运行结果:

18 初阶牛 50.000000

这里之所以能打印出来是因为,在c语言中会发生强制转换,p会指向s1的地址,刚好偏移量又一样,所以才会打印出来,但是这并不意味着这两个结构体类型相同.

1.2 结构体的自引用

之前我们见过结构体的嵌套定义.
如:

#include <stdio.h>
typedef struct teacher
{char name[20];//名字char subject[20];//科目}ter;//将struct teacher重命名为ter,使得类型名更加简洁
typedef struct student
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号ter t1;//嵌套定义,一个结构体中包含令一个结构体.
}stu;//同理struct student重命名为stu
int main()
{//嵌套结构体的初始化stu s1 = { "初阶牛",20,"男","20216666",{"pengge","c语言"} };//嵌套结构体的打印printf("%-6s %-2d %s %s %s %s\\n", s1.name, s1.age, s1.sex, s1.id, s1.t1.name, s1.t1.subject);return 0;
}

嵌套定义示例图解:

那么可以自己引用自己(自引用)吗?
我们试着尝试写一下代码:

错误示例1:

typedef struct student
{char name[20];//名字int age;//年龄char sex[5];//性别stu s1;
}stu;

原因:
虽然我们对struct student类型进行了重命名为stu,但是在结构体内部还没有生效,因为这个结构体类型的定义还没结束,结构体本身并不认识stu,只有声明结束后才可以使用.

typedef struct student
{char name[20];//名字int age;//年龄char sex[5];//性别struct student s1;
}stu;

原因:
虽然我们这里正确的使用了结构体的类型名,但是,如果一个结构体中引用了自己,那么这个结构体的大小是多少?这不就无限递归了吗?
这样?

正确的自引用方法是:

typedef struct student
{char name[20];//名字int age;//年龄char sex[5];//性别struct student* next;//一个结构体指针,用于指向与自己类型相同的结构体
}stu;

这种结构体自引用的情况在数据结构的链表中就有应用.
我们可以简单了解一下,后续在数据结构中会详细讲解.

这只是申请了局部变量作为链表的成员,仅仅只是为了介绍结构体自引用的应用.
不需要过分研究.

typedef struct student
{char name[20];//名字int age;//年龄char sex[5];//性别struct student* next;
}stu;
int main()
{ stu s1 = { "学生1",18,"男",NULL };//暂时将最后一个成员结构体指针置空stu s2 = { "学生2",19,"女",NULL };stu s3 = { "学生3",20,"男",NULL };//将这些结构体都连接起来s1.next = &s2;s2.next = &s3;//创建一个头指针来访问他们stu* head = &s1;//打印while(head != NULL)//最后一个结构体的next是NULL{printf("%-8s %-5d%s\\n", head->name, head->age, head->sex);head = head->next;//往后找下一个结构体}return 0;
}

运行结果:

学生1 18 男
学生2 19 女
学生3 20 男

链表的简单了解:
抽象图:

内存中的存储图解:

1.3 结构体内存大小的计算

结构体大小的计算是一个重要知识点.

试着猜一下结构体stu的大小是多少?
示例1:

struct student
{int a;char b;int c;
}stu;
int main()
{printf("%zd", sizeof(stu));return 0;
}

12

不知道友友,们有没有听过内存对齐.

其实结构体可是一个纨绔子弟,"富哥"都是很奢侈的,他经常浪费内存!!!

结构体大小计算方法:
内存对齐规则：

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

还是举例子更好理解对吧?

🌰栗子

示例1:普通结构体

示例1答案:

首先我们将首地址作为偏移量为0的地址.
第一个元素是整形,占4个字节,默认对齐数是8字节,较少者是4字节,则对齐数就是4,故偏移量0-3分配给a变量.

第二个元素是char类型,占1个字节,min(1,8),则对齐数是1,故偏移量4位置分配给b变量.

第三个元素是int型,同理,默认对齐数是4,则偏移量5-7都不能使用,是的你没有听错,这三个字节都被浪费掉了,从偏移量为8开始,8-11偏移的地址分配给变量c.

最后,此时占用了12个字节,最大的成员对齐数是4,刚好12是4的倍数,所以整个结构体的大小就是占12个字节.
图解:

示例2:包含double类型成员的结构体

struct S4
{double d;char c;
};

运行结果:

16

原因:
double占八个字节,则0-7的偏移量分配给d
char占一个字节,则偏移量8的位置分配给c
总字节数为9,但是成员最大对齐数是8,9不是8 的倍数,所以需要内存对齐,故最后占16字节.
图解:

将结构体改成如下结构,一样是占用16字节.

struct S4
{double d;//0-7char c;//8int i;//12-15
};

示例3:嵌套结构体的内存大小计算

struct S3
{int a;char c1;int i;
};
struct S4
{char c1;struct S3 s3;int d;
};
int main()
{printf("%d\\n", sizeof(struct S4));return 0;
}

运行结果:

20

图解:

示例四:包含数组的结构体

#include <stdio.h>
typedef struct student
{char a;int arr[6];char b;
}stu;
int main()
{printf("%d", sizeof(stu));return 0;
}

数组就将其看成该元素类型的多个成员变量即可，即对齐数是4，就是6个int型的变量。

图解：

练习题1:

#include <stdio.h>
struct S2
{char c1;		//0int i;			//4-7char c2;		//8
};
struct S3
{char c1;		//0char c2;		//1int i;			//4-7
};int main()
{struct S2 a = { 'a',1,'b' };struct S3 b = { 'a','b',1};printf("%d\\n", sizeof(struct S2));	//12printf("%d\\n", sizeof(struct S3));	//8return 0;
}

当我们拿捏不定时,我们可以通过调试,在内存窗口观察其中的值.
补充知识:cc是系统分配空间时初始化的值,我们就理解为未知值(未被使用)

字符a的ASCII码值是97(十进制)---->61(16进制).
字符b的ASCII码值是98(十进制)---->62(16进制).

s2在内存中:

s3在内存中

练习2:

struct S3
{int a;//0-3char c1;//4int i;//8-11double b;//16-23
};
struct S4
{char c1;//1struct S3 s3;//8-31int d;//32-35
};
int main()
{printf("%d\\n", sizeof(struct S4));return 0;
}

答案:40

为什么要内存对齐?

讲了这么久的内存对齐,那我们不好奇为啥要内存对齐导致浪费那么多空间呢?这样设计的意义是什么?

查阅资料是这么说的:

1. 平台原因(移植原因)：
   不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常.(这个我牛牛见识少,没咋遇见过,不过可以理解)

2. 性能原因：
   数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
   原因在于为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问.

举例:16位机器一次只能读取四个字节的数据.

总结:内存对齐就是一种以时间换空间的方法,不要小看一次和两次的区别,在大量数据读取时,作用是很大的.

1.4 查看偏移量与修改默认对齐数

在c语言中,有一种宏定义,可以帮助我们查看结构体中成员的偏移量.

这里我们只需要了解它是如何使用的就行.

#include <stdio.h>
#include <stddef.h>
typedef struct S2
{char c1;//0char c2;//1int i;//4
}s2;typedef struct S3
{int a;//0-3char c1;//4int i;//8-11double b;//16-23
}s3;
typedef struct S4
{char c1;//1struct S3 s3;//8-31int d;//32-35
}s4;
int main()
{printf("%d\\n", offsetof(s2, c1));printf("%d\\n", offsetof(s2,c2));printf("%d\\n", offsetof(s2, i));printf("\\n%d\\n", offsetof(s3, a));printf("%d\\n", offsetof(s3, c1));printf("%d\\n", offsetof(s3, i));printf("%d\\n", offsetof(s3, b));printf("\\n%d\\n", offsetof(s4, c1));printf("%d\\n", offsetof(s4, s3));printf("%d\\n", offsetof(s4, d));return 0;
}

运行结果:

0
1
40
4
8
160
8
32

在vs环境下修改默认对齐数:

#pragma pack(4)//设置默认对齐数为4

在vs环境下还原默认对齐数:

#pragma pack()//取消设置的默认对齐数，还原为默认

二、位段篇

你听过"位段"吗?不是段位哦,嘘~~偷偷告诉你,牛牛王者是最强王者段位哦!

位段其实和结构体很相似,我们可以先观察一个位段先.

#include <stdio.h>
typedef struct A
{int a : 2;int b : 5;int c : 10;int d : 15;
}A;
int main()
{printf("%d", sizeof(A));return 0;
}

位段长得与结构体很相似,但是他与"富哥"结构体不一样,位段就十分节省了,字节都是省着用,一个字节都要按比特位数着用!是出了名的"吝啬鬼".

位段的使用要求:

1.位段的成员必须是 int、unsigned int 或signed int 或者char类型
2.位段的成员名后边有一个冒号和一个数字。(冒号后面的数字不得超过前面类型的大小.)

位段的位就是指"比特位",一个字节占8比特位.

位段空间使用规则是:

1.先申请该类型所占的字节个数个的字节空间(如:int占四个字节,则先申请四个字节的空间)
2.从低位向高位使用":"(冒号)个比特位的空间.
3.如果字节不够了,就继续申请新的类型大小数目的字节空间.

比如示例1:

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

由于int占四个字节,则先申请四个字节空间.
a:2,表示a申请占用2个比特位,
b:5,表示b申请占用5个比特位,
…
是的你没有听错,就是比特位,经过计算,2+5+10+15=32,四个字节刚好够用,那他真的是占四个字节吗?
是的,不相信的小伙伴,可以复制示例1运行一下,结果就是四个字节.

那超出四字节会怎样申请新的空间?

#include <stdio.h>
typedef struct B
{int a : 20;int b : 5;int c : 10;int d : 15;
}B;
int main()
{a=1;b=2;c=3;d=5;printf("%d", sizeof(B));return 0;
}

分析:

int占四个字节,前申请四个字节的空间.
a占用了其中的20个比特位,b又占用了5个比特位.(还剩7个比特位)
c需要10个比特位,显然是不够的,
这时,又向内存申请了四个字节的空间,
假设,我们大方一点,这7个比特位不要了,直接使用新的内存空间,d又占用15个比特位,八个字节,足够了.

通过调试,我们发现,确实占用了八个字节大小.

我们可以通过调试,在内存窗口观察内存中实际是怎样存放的.

计算转化为16进制:

调试验证:(图中是小端存储,所以是反过来的).

但是,我们只是假设那7个剩余的比特位不要了,有的编译器可没有这么大方,这取决于编译环境,所以这也是位段的一个缺点!

位段总结:

1. 在位段中,int是有符号还是无符号是未知的.
2. 虽然说位段中":"(冒号)后面的数字不得超过该成员类型所占字节数所换算的比特位,但是在不同的平台,类型的大小是不确定的.
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。(我们在vs是从左向右分配的)
4. 当第一个位段的剩余的内容无法存储第二个位段时,要开辟新的空间,那之前剩余的空间是否被利用取决于平台,也没有规定.

总结,虽然位段节省了大量的空间,但是时间效率,跨平台可移植性都堪忧.

三.枚举(enum)

在c语言初阶时,我们在讨论c语言类型时,其实也提到过这个名词"枚举".
那么今天就来真正学懂"枚举"吧!
"枚举"其实就是列举的意思.

比如:

三原色: “红”,“绿”,“蓝”.
性别: “男”,“女”.
星期:" 星期一",“星期二”……

当一件事物可以一 一列举出来,我们可以使用枚举将他们表示出来.
枚举类型中的成员只有在定义时可以更改(因为常量也要有值不是吗?)
他们都是常量,定义之后是不允许更改的.

枚举的定义:

🌰栗子

#include <stdio.h>
enum Day//星期
{Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
};
enum Sex//性别
{MALE=6,FEMALE,
};
enum Color//颜色
{RED,GREEN=7,BLUE=10
};
int main()
{printf("Day;");printf("%d ", Monday);printf("%d ", Tuesday);printf("%d ", Wednesday);printf("%d ", Thursday);printf("%d ", Friday);printf("%d ", Saturday);printf("%d ", Sunday);printf("\\n");printf("%d ", MALE);printf("%d ", FEMALE);printf("\\n");printf("%d ", RED);printf("%d ", GREEN);printf("%d ", BLUE);return 0;
}

运行结果:

Day;0 1 2 3 4 5 6
Sex;6 7
Color;0 7 10’’

对于未被初始化的枚举常量,默认是从0开始的.

枚举的优点

当我们在使用case语句,或者其它选择语句时,数字1,2,3这类并没有指向性.
这时我们可以用枚举常量代替他们,使得代码可读性极大提高.

示例:
请设计一个程序,要求:
输入:一个整数date范围是(0-7)
输出:打印星期一到星期天.

enum Day//星期
{Monday=1,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
};
#include <stdio.h>
int main()
{int date = 0;scanf("%d", &date);switch (date){case Monday:printf("星期一");break;case Tuesday:printf("星期二");break;case Wednesday:printf("星期三");break;case Thursday:printf("星期四");break;case Friday:printf("星期五");break;case Saturday:printf("星期六");break;case Sunday:printf("星期天");break;default:printf("超出范围了兄弟!!!\\n");}return 0;
}

这个例子可能有些牵强,但是希望友友们能理解,很多情况,枚举常量还是能够可以帮助我们更好的提升代码可读性的.例如,通讯录那里有好的例子.

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

四、联合体(unio)

联合体是一种很特殊的自定义类型,他与结构体一样可以同时定义多个变量.
但是最主要的特点是,这些成员变量使用的都是同一块内存空间.
所以,他还有另外一个名字—共用体.

我们看一个联合体的例子.

union Un
{char a;int b;double c;
};

联合体的定义有了前面结构体的基础,还是很简单理解的.牛牛不过多介绍了.

联合体的应用:

#include <stdio.h>
typedef union test
{int a;char b;
}test;
int main()
{test t1;printf("%p\\n", &(t1.a));printf("%p\\n", &(t1.b));t1.a = 0xaabbccdd;t1.b = 0xaa;printf("%x\\n", t1.a);return 0;
}

运行结果:

0000004B5DFCFC64
0000004B5DFCFC64
aabbccaa

联合体的特点是其中的成员变量都在使用同一块内存空间,所以打印出来的地址是一样的.
但是这样就产生了一个问题,如果我们同时使用这里的多个成员,那内存地址中存放谁的值呢?
所以联合体中的成员变量不能同时使用.
这也就是为什么修改了b,导致a的一个字节的数据也被修改的原因.

联合体的大小计算

很明显,由于他们都是使用同一块空间,所以大小是由最大成员变量所决定的,但是要注意的是,联合体也是要讲究内存对齐的.
练习一下吧!

#include <stdio.h>
union test1
{char a[9];int b;double c;
};
union test2
{short a[7];int b;char c;
};int main()
{printf("%d\\n", sizeof(union test1));printf("%d\\n", sizeof(union test2));return 0;
}

答案:

16
16

分析:
test1:最大元素是a[9],但是需要内存对齐,对齐数是取double的8,所以占16字节.
test2:最大元素是a[7],占14个字节,但是对齐数是四个字节的b,所以也要内存对齐为16字节.

好了,今天的c语言自定义类型就讲到这里了,我们下次再见!
最后，码文不易,敲了2天键盘了,如果文章对大家有帮助的话，求一波三连吧！
💗💗💗886