自定义类型变量：结构体

结构体

结构体的定义

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

struct Stu
{
    
    
  char name[20];
  int age;
  char sex[5];
  char id[20];
}x,y,z;

我们可以把x,y,z前面的部分看作是变量类型，上例就相当于是定义了x,y,z三个结构体变量。
前面的部分是对该自定义结构体变量的描述：Stu是结构体名称，{}内是结构体内所含有的结构体成员变量。

---

但我们一般这样声明结构体：
这样可以做到随时需要，随时定义。

#include<stdio.h>

struct Stu
{
    
    
  char name[20];
  int age;
  char sex[5];
  char id[20];
};

int main()
{
    
    
  struct Stu x,y,z;
  return 0;
}

当然我们这样声明，系统是不会报错的，但这毫无意义，不能在后期用来定义变量：

struct 
{
    
    
  char name[20];
  int age;
  char sex[5];
  char id[20];
};

结构体内部成员变量是不能为空的！

---

最推荐使用的声明结构的方式是：

typedef struct Stu
{
    
    
  char name[20];
  int age;
  char sex[5];
  char id[20];
}stu_t;

int main()
{
    
    
  stu_t x,y,z;
  return 0;
}

typedef 是对类型名重命名，这样我们在后面定义结构体变量时直接使用重命名后的类型名，不用再加struct，更加方便快捷。

结构体的自引用

结构体是允许自己引用自己的，类似于函数的递归。

struct Node
{
    
    
 int data;
 struct Node* next;
};

最推荐使用这种方式：

typedef struct LinkNode{
    
    
    int data;
    struct LinkNode *next;
}Node;

---

那么为什么这样不可以呢？

struct Node
{
    
    
 int data;
 struct Node next;
};

假设我们对这样一个结构体定义变量，那么如何开辟空间？
首先会对int开辟4字节，遇到struct Node又开辟结构体，再遇到int，开辟4字节……
如此循环往复，系统将会进入死循环。

所以不能如此自引用！

结构体的初始化

对于上例

stu_t x = {
    
    "zhangsan","20","man","1772991378"};

结构体嵌套式初始化：

struct Node
{
    
    
  int data;
  struct Stu p;
  struct Node * next;
}n1 = {
    
    10,{
    
    4,5},NULL};

struct Node n2 = {
    
    20,{
    
    5,6},NULL};

结构体的访问

1. 方式一：
   结构体变量访问成员 结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。 例如：
   
   我们可以看到 s 有成员 name 和 age ； 那我们如何访问s的成员？

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

2. 方式二
   结构体指针访问指向变量的成员 有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。
   那该如何访问成员。 如下：

struct Stu
{
    
    
 char name[20];
 int age;
};

void print(struct Stu* ps) {
    
    
 printf("name = %s   age = %d\n", (*ps).name, (*ps).age);
    //使用结构体指针访问指向对象的成员
 printf("name = %s   age = %d\n", ps->name, ps->age);
}

int main()
{
    
    
    struct Stu s = {
    
    "zhangsan", 20};
    print(&s);//结构体地址传参
    return 0;
}

结构体传参

struct S {
    
    
 int data[1000];
 int num;
};
struct S s = {
    
    {
    
    1,2,3,4}, 1000};
//结构体传参
void print1(struct S s) {
    
    
 printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps) {
    
    
 printf("%d\n", ps->num);
}
int main()
{
    
    
 print1(s);  //传结构体
 print2(&s); //传地址
 return 0; }

上面的 print1 和 print2 函数哪个好些？

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

结论： 结构体传参的时候，首选传址传参。

结构体内存对齐

我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。

我们试着计算一下以下代码的大小：

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

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

我们会发现这两次看似一样内容的结构体，但是其所占字节大小是完全不同的。
这里就会涉及到我们结构体内存对齐问题了。

为什么要内存对齐？

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

假如一个硬件平台的内存读取是按一次性读取4字节地址的内容的话：
如果按照紧密开辟一个结构体空间就会发生以下情况：

第一次CPU读取时得到的是0~4字节的内容，能保证读到完整的b，但是当CPU第二次读取时就不能读取完成的a了，所以只能记下a的起始位置，再一次读取a，这样不仅使CPU工作变得繁琐，还变的效率低下。

为此开辟结构体时，只要分开每个成员变量的位置，让CPU每次都读到等量大小地址的内容，就可一次读到整个结构体，提高CPU工作效率。

虽然我们牺牲了空间的利用率，但是我们换取了高效的工作效率。

内存对齐是怎么计算的呢？

内存对齐遵循以下四点规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
   对齐数可以自行设置，默认对齐数是其自身大小，如果设置了对齐数，编译器将按上述规则选择较小的。
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所
   有最大对齐数（含嵌套结构体的对齐数）的整数倍。

怎么才算是对齐？
对齐：其他成员在放入结构体时，其起始偏移量能整除对齐数成为对齐。

回头看看一开始的代码：

对于第四点规则，如果结构体内部嵌套了其他结构体，则在对齐时，只需对齐到该其他结构体的最大对齐数即可。
例如：

struct S3
{
    
    
 double d;//对齐数=8
 char c;//对齐数=4
 int i;//对齐数=4
};
//S3总大小=16

struct S4
{
    
    
 char c1;//对齐数=8（结构体内部嵌套了其他结构体，则在对齐时，只需对齐到该其他结构体的最大对齐数即可）
 struct S3 s3;//对齐数=16
 double d;//对齐数=8
};
//S4总大小=32

所以在结构体定义的时候，做好结构体的成员变量的顺序设计，可以有效提高空间利用率

修改默认对齐数

#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct S1
{
    
    
 char c1;
 int i;
 char c2;
 };
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为1
struct S2
{
    
    
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

位段

什么是位段

位段的声明和结构体是类似的，有两个不同：

1. 位段的成员必须是 int、unsigned int 或signed int ，并且只能有一种类型。
2. 位段的成员名后边有一个冒号和一个数字，意思是使用该变量的几个bit位。

struct A {
    
    
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
};

位段的目的是为了压缩存储、节省空间，所以它不考虑计算效率的问题，而是要优先考虑空间利用的问题。

位段的内存分配

由于位段操作的是bit位，所以要了解bit的储存。

与大端小端机器一样，bit也有大小端之分，在一个字节内，左边为大端还是右边为大端都由硬件决定，不同的机器带来的结果可能不同。

位段赋值

假设一段代码：

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;

实际储存：


也就是说在内存里发生了以下情况：

位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位
   还是利用，这是不确定的。

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

位段的应用

这是一个IPV4协议的报头

对于这种情况时，就可以使用位段来很好的解决分区问题。