①前言：

在之前【C语言】初阶——结构体 ，简单介绍了结构体。而C语言中结构体的内容还有更深层次的内容。

一.结构体

结构体(struct)是由一系列具有相同类型或不同类型的数据项构成的数据集合，这些数据项称为结构体的成员。

 1.结构体的声明

// 创建结构体
struct student
{
  char name[10];  // 学生名字
  int num;     // 学生学号
  int age;     // 学生年龄
}stu;

struct student 是类型，stu是结构体类型变量

2.结构体的定义和初始化 

2.1结构体的初始化 

struct Stu         //类型声明
{
 char name[15];    //名字
 int age;          //年龄
};
struct Stu s = {"zhangsan", 20};    //初始化

 2.2结构体的自引用

struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL};     //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};    //结构体嵌套初始化

3.结构体内存对齐 

首先得掌握结构体的对齐规则：

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

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

        对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

        VS中默认的值为8

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

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

struct S1
{
 char c1;
 char c2;
 int i;
};
printf("%d\n", sizeof(struct S1));

 

s1在内存中所占的字节大小是多少？

VS默认对齐数是8

Linux没有默认对齐数自身大小就是其对齐数

首先c1是char类型 占1个字节与8比，8大，对齐数是1，放在偏移量为0的位置

c2也是char 类型对其数是1放在1的整数倍处也就是放在偏移量为1的位置

i是int型占4个字节，最大对其数是4，放在偏移量为4的位置

最后s1偏移量为7一共占用了8个字节，8是最大偏移量4的整数倍，所以s1在内存中占用了8个字节

 3.1为什么存在内存对齐?

    结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到？
    让占用空间小的成员尽量集中在一起。 

1. 平台原因(移植原因)：

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

2. 性能原因：

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

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

3.2修改默认对齐数

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

#pragma pack(8)//设置默认对齐数为8
struct S1
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

3.3offsetof宏

用法：计算偏移量

头文件：#include <stddef.h> 

offsetof (type,member)

struct address {
   char name[50];
   char street[50];
   int phone;
};
   
int main()
{
   printf("address结构中的name 偏移 = %d 字节\n", offsetof(struct address, name));
   //0字节
   printf("address结构中的street 偏移 = %d 字节\n", offsetof(struct address, street)); 
   //50字节  
}

 👊模拟实现

//模拟实现宏offsetof
#define my_offsetof(struct_name, member_name)  (int)&(((struct_name*)0)->member_name)
//例如shtruct S{char a; char b;};
//用宏替换：(int)&(((struct S*)0)->a)
//解释：把结构体的首地址看成0，那么每个成员的地址（减去首地址0）也就是相对于首地址的偏移量，所以取到成员的地址并转换为int型就是偏移量；
 
//注意：以上把0强制转换成struct S*类型之后（把0转换成一个结构体指针类型），那么从0地址往后看就是一个结构体的形式看
//也可以说是在0地址的位置上放了一个结构体；

注：结构体传参主要以传地址为主。

二.位段 

1. 位指的是二进制位；
2. 位段的成员必须是 int、unsigned int 或signed int、char
3. 位段的成员名后边有一个冒号和一个数字；
4. 可以使数据单元节省储存空间，当程序需要成千上万个数据单元时，这种方法就显得尤为重要；
5. 不支持跨平台

struct str
{
	int _a : 2;
	int _b : 3;		//后面的数字是bit位，不是字节
};

 

int main()
{
	unsigned char puc[4];
	struct tagPIM
	{
		unsigned char ucPim1;
		unsigned char ucData0 : 1;
		unsigned char ucData1 : 2;
		unsigned char ucData2 : 3;
	}*pstPimData;
	pstPimData = (struct tagPIM*)puc;
	memset(puc, 0, 4);
	pstPimData->ucPim1 = 2;
	pstPimData->ucData0 = 3;
	pstPimData->ucData1 = 4;
	pstPimData->ucData2 = 5;
	printf("%02x %02x %02x %02x\n", puc[0], puc[1], puc[2], puc[3]);
	return 0;
}

puc是一个char数组，每次跳转一个字节，结构体不是，它只有第一个元素单独享用一字节，其他三个元素一起共用一字节，所以puc被结构体填充后，本身只有两个字节会被写入，后两个字节肯定是0，

然后第一个字节是2就是2了，第二个字节比较麻烦，首先ucData0给了3其实是越界了，1位的数字只能是0或1，所以11截断后只有1，同理ucData1给的4也是越界的，100截断后是00，只有5的101是正常的。填充序列是类似小端的低地址在低位，所以排列顺序是00 101 00 1。也就是0010 1001，

所以结果为02 29 00 00

三.枚举

枚举是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY就是一个枚举。

枚举就是一个对象的所有可能取值的集合 

#include<stdio.h>
enum sex
{
   male,
   female,
   secret,
};

枚举的关键字是enum 在括号内部注意每个成员名后面要加逗号，同时别忘了括号外面的分号

枚举内部的成员被依次赋值为0,1,2

我们假如将female赋值为1，secret就被赋值为2，male赋值为0

3.1枚举的优点 

1.增加代码的可读性和可维护性

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

3. 防止了命名污染（封装）

4. 便于调试

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

enum Sex        //枚举的申明定义
{
	Male,        //枚举常量，默认值是0开始，一次递增1
	female,
	secret
};
enum Color
{
	RED=1,        //也可以手动赋值
	GREEN=2,
	BLUE=4
};
int main(){
    enum Sex a = Male;         //枚举顾名思义就是一一列举。
	enum Color b = RED;
	printf("%d %d %d\n", Male, female, secret);
	printf("%d %d %d\n", RED, GREEN, BLUE);
}

 

四.联合（共用体）

定义： 联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。 

联合大小的计算 

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

// 联合体/共用体  -  里面的成员同一时间只能用一个

union Un
{
	char c;     // 1
	int i;     // 4
};

union U
{
	short s[7]; // 14
	int i; // 4
};

int main()
{
	union Un u = { 0 };

	printf("%d\n", sizeof(u)); // 输出 4
	// 下面三行输出同样的地址
	printf("%p\n", &u); 
	printf("%p\n", &(u.c));
	printf("%p\n", &(u.i)); 

	union U c = { 0 };

	printf("%d\n", sizeof(c)); // 输出 16 内存对齐了（最大对齐数4的倍数）
	printf("%p\n", &c); // 输出
	printf("%p\n", &(c.s)); // 输出
	printf("%p\n", &(c.i)); // 输出

	return 0;
}

 联合体、大小端结合

int check_sys()
{
	union J
	{
		char m;
		int n;
	};
	J s1;
	s1.n = 1;
	return s1.m;
}
int main()
{
	if (check_sys())
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

int main()
{
  union
  {
    short k;
    char i[2];
  }*s, a;
  s = &a;
  s->i[0] = 0x39;
  s->i[1] = 0x38;
  printf("%x\n", a.k);
  return 0;
}

 union只有2字节，2字节的十六进制只有4位，所以答案CD排除。而位顺序类似小端，低地址在低处，所以39是低地址，在低位，38在高位，所以是3839

 以上就是我对【C语言】结构体的全部介绍了，身为初学者自知有很多不足，望各位大佬指点得以改正！！！感激不尽。