【C语言】结构体

1. 结构体

1.1 结构体类型的声明

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

struct tag
{
    member-list;
}variable-list;

常见的声明和创建

//声明结构体;声明一个学生类型，是想通过学生类型来创建学生变量
//描述学生属性：名字，电话，性别,年龄
struct Stu
{
	char name[20];
	char tele[12];
	char sex[10];
	int age;
}s4,s5,s6;//创建了s4,s5,s6三个全局变量

struct Stu s3;	//	创建全局结构体变量

int main()
{
	//创建局部结构体变量
	struct Stu s1;
	struct Stu s2;
	return 0;
}

结构体变量声明时的变量列表可以省略，如果不省略的话就说明在结构体时就会创建对应的全局结构体变量。

结构体的特殊声明：匿名结构体类型

struct 
{
    int a;
    char b;
}x;

结构体名称省略了，所以在声明的时候必须创建好变量x，不然后面没法自己创建结构体变量。

struct
{
    int a;
    char b;
}* px;
//这个时候创建的就是结构体指针

注意：

px = &x;

警告：编译器会把上面的两个声明当成完全不同的两个类型。所以是非法的。

1.2 结构的自引用

所谓结构体的自引用不是结构体内包含结构体，而是结构体内含有结构体指针

例如：

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

很显然这样是不行的，比如用sizeof计算这个结构体的大小是无法计算的。正确的自引用方法如下所示：

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

这样的话结构体的大小就可以确定了，而且采用结构体指针的方式也实现了自引用的效果。

在声明结构体时候，可以使用typedef关键字给结构体进行简化，例如：

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

int main()
{
    struct Node n1;
    Node n2;
    return 0;
}

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

1.3.1 结构体变量的定义

• 在声明时就定义结构体变量

  struct var
  {
      int a;
      char b;
  }x;
  

  这里定义了一个结构体变量x

• 声明完结构体之后定义结构体变量

  struct var
  {
      int a;
      char b;
  };
  
  struct var x;
  struct var y;
  
  int main()
  {
      struct var z;
      return 0;
  }
  

1.3.2 结构体变量的初始化

struct S
{
    char c;
    int a;
    double d;
    char arr[20];
};

int main()
{
    struct S s = {'c', 100, 3.14, "hello world"};  //结构体初始化
    printf("%c %d %lf %s\n", s.c, s.a, s.d, s.arr);
}

1.4 结构体内存对齐

struct S1
{
    char c1;
    int a;
    char c2;
};

struct S2
{
    char c1;
    char c2;
    int a;
};

int main()
{
    struct S1 s1 = {0};
    struct S2 s2 = {0};
    printf("%d\n", sizeof(s1));
    printf("%d\n", sizeof(s2));
}

//12 8

1.4.1 结构体内存对齐规则

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

下面来解释为什么上面的代码结果是12和8：

• S1中的结构体第一个变量为char类型，占一个字节，所以c1直接就在第0个格子处；看规则的第二点，就是说从第二个成员开始，就要对齐到对齐数的整数倍的地址处，而int型占四个字节，所以对齐数为4，因此第1，2，3个格子都应该是空的，第四个格子开始到第七个格子存放a；接下来第八个格子就存放c2即可。又因为规则第四点，最大对齐数为4，而目前的大小为9，所以为满足规则，最终需要利用三个空字节来补齐，因此最终的结构体大小为12
  

• 同理可计算得到S2的大小为8

1.4.2 结构体嵌套结构体的内存大小计算方法

struct S3
{
    double d;
    char c;
    int i;
}

struct S4
{
    char c1;
    struct S3 s3;
    double d;
}

首先分析结构体S3的内存大小：

• d要占8个字节，对齐数等于8；c要占1个字节，对齐数等于1；i要占4个字节，对齐数等于4。所以d占据了1-8个内存格子；c占据了第9个内存格子；i的话由于对齐数为4，其实内存格子编号应该是4的倍数，所以i应该从第12个格子开始到16个格子结束。因为16是8的倍数，所以S3的大小为16

然后分析S4的大小：

• c1占据一个内存格子，对齐数为1；根据内存对齐规则5，结构体s3的最大对齐数为8，所以结构体s3从第8个格子到第24个格子；d占据8个格子，对齐数为8 ，刚好从24到32个格子。而32也是最大对齐数8的倍数，因此结构体s4大小为32

1.4.3 为什么存在内存对齐

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

1.4.4 节省结构体内存的方法

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

1.5 修改默认对齐数

VS中的默认对齐数为8，C语言中可以使用**#pragma** 这个预处理指令来修改默认对齐数。例如：

#include <stdio.h>
#pragma pack(4)//设置默认对齐数为4
struct S1
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为1
struct S2
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
    //输出的结果是什么？
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
    return 0;
}

一般都设置为2，4，8，16之类的2的次方数

1.6 offsetof宏的使用方法

用于计算结构体成员相对于结构体起始位置的偏移量

#include <stdio.h>
#include <stddef.h>

struct S
{
    char c;
    int i;
    double d;
};

int main()
{
    printf("%d\n", offsetof(struct S, c));
    printf("%d\n", offsetof(struct S, i));
    printf("%d\n", offsetof(struct S, d));
};

//0, 4, 8

1.7 结构体传参

void Init(struct S* ps)
{
    ps->a = 100;
    ps->c = 'w';
    ps->d = 3.14;
}

int main()
{
    struct S s = {0};
    Init(&s);
    return 0;
}

结构体传参同样也是传的结构体地址，因为函数想改变函数外部变量时，都是要传递地址的，如果传值，只是会创建一个临时变量，改变的也只是临时变量，不会改变函数外部变量。

但是，如果只是想打印或者只是想得到结构体的值，不需要改变结构体的值，这个时候可以传值。例如：

void Print1(struct S tmp)
{
    printf("%d %c %lf\n", tmp.a, tmp.c, tmp.d);
}

void Print2(const struct S* ps)
{
    printf("%d %c %lf\n", ps->a, ps->c, ps->d);
}

int main()
{
    struct S s = {0};
    Print1(s);	//传值
    Print2(&s);	//传址
    return 0;
}

总结：

• 结构体传参可以传地址也可以传值。如果不需要改变结构体的值，可以传值也可以传地址；如果要改变结构体，一定要传地址
• 建议结构体传参同一传地址。（因为一旦结构体比较大，传值就会产生较大的内存浪费；传地址如果不想改变结构体值可以用const修饰即可）