结构体总结

结构体是什么：

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

数组：一组相同类型的集合

结构体的声明：

结构的成员可以是标量、数组、指针，甚至是其他结构体。

定义一个学生类型：

struct Stu
{
 char name[20];//名字
 int age;//年龄
 char sex[5];//性别
 char id[20];//学号
}；//注意分号

 这是一个类型，为结构体类型。

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

定义：全局定义和局部定义

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}s4,s5;//定义全局结构体变量，可以定义多个
struct Stu  s6,s7;// 定义全局结构体变量，可以定义多个

int main(){
	struct Stu s1, s2, s3;//定义局部结构体变量
}

初始化：

struct Stu
{
	int age;//年龄
	char id[20];//学号
}s4 = {17,"qq"}, s5 = {16,"mr.pu"};

定义变量的同时赋初值

不能直接在成员列表初始

还可以这样初始化：

struct Stu s = {"zhangsan", 20};//初始化

struct Stu
{
	int age;//年龄
	char id[20];//学号
} ;//定义全局结构体变量，可以定义多个
int main() {
	struct Stu s1 = {18,"啊啊"}, s2 = {17,"qq"};//定义局部结构体变量
	}

前面我们说过结构的成员可以是标量、数组、指针，甚至是其他结构体。

struct Stu
{
	int age;//年龄
	char id[20];//学号
} ;//定义全局结构体变量，可以定义多个
struct jl
{
	int qq;
	struct Stu s2;
	char zz[20];

};
int main() {
	struct jl s1 = {12,14,"qq","wu"};//定义局部结构体变量
	}

 当然用{}来区别嵌套的结构体类型

结构体成员的访问：

构体变量访问成员

结构变量的成员是通过点操作符（.）访问的。

 

 可以看到(.)可以操作qq,结构体s2,zz

 如何打印结构体ji内部结构体Stu内的成员？

此处用（.）来访问Stu内部成员

 

结构体指针访问指向变量的成员

有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。

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

void print(struct Stu* ps)
{
    printf("name = %s   age = %d\n", (*ps).name, (*ps).age);
}
int main()
{
    struct Stu s = { "zhangsan", 20 };
    print(&s);
    return 0;
}

上面我们还可以用->来实现结构体成员的访问（限于左边为结构体指针）

printf("name = %s   age = %d\n", ps->name, ps->age);

结构体传参：

上面是传的结构体变量的地址，为传地址调用，不用开辟大量空间，拷贝时间短

结构体指针是一个指向结构体的指针变量。结构体是一种用户定义的数据类型，它可以包含多个不同类型的数据成员，而结构体指针则指向这个结构体在内存中的地址。

在函数中，参数ps是一个指向struct Stu类型的指针。如果我们想要访问指针所指向的结构体中的成员变量，我们需要解引用该指针。使用*运算符可以对指针进行解引用操作。因此，在print函数中，(*ps)就是将指针ps所指向的struct Stu结构体进行解引用操作，以便访问该结构体中的成员变量。接下来，使用.运算符可以访问struct Stu结构体中的成员变量name和age。所以，(*ps).name引用了ps所指向的struct Stu结构体中的name成员变量，(*ps).age引用了ps所指向的struct Stu结构体中的age成员变量

struct Stu
{
    char name[20];
    int age;
};
void print(struct Stu  s)
{
    printf("name = %s   age = %d\n", s.name, s.age);
}
int main()
{
    struct Stu s = { "zhangsan", 20 };
    print(s);
    return 0;
}

这里我们是传值调用开辟大量空间，拷贝时间长，所以我们一般是传地址调用

对结构体类型重命名：

 typedef struct Stu
{
    char name[20];
    int age;
}qq;
typedef struct Stu ww;
int main()
{
    typedef struct Stu aa;
    aa s3 = { "sb",24 };
    qq s = { "zhangsan", 20 };
    struct Stu s1 = {"lishi",23};
    ww s2 = { "zz",25 };
    return 0;
}

关键字：typedef ，可以在定义类型时，对其进行重命名；定义完命名1.全局命名2.局部命名

用typedef来进行重命名可以简写如  struct  Stu  简写为aa,qq,ww

匿名结构体：

匿名结构体当你只用一次时，就可以用匿名结构体

其形式是

struct
{
 int a;
 char b;
 float c;
}x;

1.定义时，匿名结构体变量必须同时定义（因为没用结构体名）

2.匿名结构体后面用不了（因为没用结构体名）

struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
} * p;
int main() {
	p = &x;
}

当我们用结构体指针p来接收结构体变量x的地址此处会报错

这俩个结构体的结构体成员相同，且都是匿名结构体，但在编译器来看认为是俩种不同类型

 结构的自引用：

当我们结构体自己来引用自己时：

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

此时我们来分析：

成员有date,同一类型结构体，同一类型结构体成员有date,同一类型结构体，同一类型结构体成员有date,同一类型结构体.............

这个结构体的成员无穷多导致无法使用

正确的使用方式：结构体指针

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

因为在C或C++中，结构体或类的声明只是一种模板，它并不占用内存空间。只有当定义了该结构体或类的实例时，才会分配内存空间。因此，在结构体的定义中，即使某些成员变量的类型是自身的指针，也不会出现无限递归的情况。

在这个结构体中，成员变量 next 是一个指向 Node 类型的指针，它指向链表中的下一个节点。由于指针只是一个内存地址，因此在结构体定义中使用指针变量是很常见的，这使得链表等数据结构的实现更加方便和简洁。

结构体内存对齐：

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

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

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8

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

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

实例：

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

我们来画图分析：

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

  其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8

开始放第二成员，int类型4个字节 VS中默认的值为8，4<8对齐数4

开始放第三成员，char类型一个字节 VS中默认的值为8，1<8对齐数1，此时8为1的对奇数，8存放char  c

 ****是从0开始计算

 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。前面我们看到最大对齐数位4，此处为9，不是整数倍，所以要继续往后面

上面有6个字节浪费，为了满足对齐规则

我们再来举一个例子：

struct s1
{
	double d;
	char c;
	int i;
};
int main() {
	printf("%d\n", sizeof(struct s1));
}

我们来画图分析：

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

double为8字节

 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8

开始放第二成员，char类型一个字节 VS中默认的值为8，1<8对齐数1，此时8为1的对奇数，8存放char  c

开始放第三成员，int类型四个字节 VS中默认的值为8，4<8对齐数4，开始往后数

****是从0开始计算

 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。前面我们看到最大对齐数位8，此处为16，所以刚好为整数倍

结构体嵌套问题，这方面就是规则4

我们再来举个例子：

struct s1
{
	double d;
	char c;
	int i;
};
struct s2
{
	char c1;
	struct s1 qq;
	double d;
};

int main() {
	printf("%d\n", sizeof(struct s2));
}

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

结构体s1占16个字节，嵌套的结构体对齐到自己的最大对齐数的整数倍处，此处最大对齐数为8

我们画图来分析

放入double  d对齐数位为8

此处刚好为24为8的整数，可以放double  d

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

最大对齐数为8，32为其整数倍

为什么存在内存对齐：

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

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

struct s
{
	char c;
	int i;

};

假设我们没对齐

32位机情况下，一次访问4个字节

 int i被分为二个部分

对齐情况下

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

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

修改默认对齐数（#pragma）

#pragma pack(1)//设置默认对齐数为1
struct S1
{
    char c1;
    int i;
    char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
    printf("%d\n", sizeof(struct S1));
    
}

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。

结构体的总结就到这里了，后面会持续更新自定义类型

求三连！！！！！！！！！！！！！！！！！！！