结构体超级详解~赶紧来学习~

最新推荐文章于 2024-09-29 13:44:32 发布

蒲公英的吴

最新推荐文章于 2024-09-29 13:44:32 发布

阅读量1.9k

点赞数 18

分类专栏： C语言文章标签：学习 c语言

本文链接：https://blog.csdn.net/zijin555/article/details/127165286

版权

C语言专栏收录该内容

19 篇文章 10 订阅

订阅专栏

🍑什么是结构体？

🍑结构体的声明：

🍑正常声明：

🍑特殊声明：

🍑小tips:

什么是结构体？

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

结构体的声明：

正常声明：

struct tag  //结构体标签tag
{
	member - list; //括号里面就是写成员变量的地方，可以写多个变量并且可以是不同类型的
}variable - list; //这个地方可写可不写，写了的话就是创建了一个全局的该结构体变量

struct tag
{
	member - list;
}* /*在这个地方加一个*号就是该结构体指针类型*/variable - list;//variable - list就是一个全局的结构体指针变量

int main()
{
	struct stu s;//在这个地方创建的结构体变量是局部的结构体变量
	return 0;
}

例如描述一个学生：

struct stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
};//分号不能忽略！！！

struct stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
}s1,s2;//这里就是创建了两个全局的该结构体变量，s1和s2。

特殊声明：

在声明结构体的时候，可以不完全的声明。

//匿名结构体类型
struct  //匿名结构体类型就是省略了结构体标签
{
	int a;
	char b[5];
	char c;
}st1,st2; //但是只能在这个位置创建该结构体变量且是全局的，也可以创建多个变量


struct
{
	int a;
	char b[5];
	char c;
}*t1,st2;//这个地方加一个*，t1就是该结构体指针类型，但是st2并不是指针。也是属于匿名结构体(指针)类型

int main()
{
    t1 = &st1;//这个地方是错误的，编译器会将这两种声明当成完全不同的两个类型，所以是非法的
    return 0;
}

结构体的重命名：

结构体的重命名就是给一个结构体类型重新起一个名字

使用typedef关键字

比如，不想要struct前缀就可以重命名：

typedef struct Node//在struct前面加一个typedef
{
	int data;
}Node;//在这里写下新的名字

int main()
{
    Node d1;//这里就定义了一个Node类型的结构体
    struct Node d2;//但是加上struct也是可以的~
    return 0;
}

结构体的自引用：

在结构中包含一个类型为该结构本身的成员就是结构体的自引用

struct Node
{
	int data;
	struct Node* next;//带一个自身结构体的指针类型就是结构体的自引用
};

//错误的自引用：
//ex1
struct Node
{
	int data;
	struct Node next;//结构体的自引用只能引用自身结构体指针！！！
};
//ex2
typedef struct Node
{
	int data;
	Node* next;//结构体的自引用不能使用重命名的名字，因为还没有重命名成功。
}Node;

结构体的定义与初始化：

struct Point
{
	int x;
	int y;
}p1; //声明类型的同时定义变量p1（全局变量）
struct Point p2; //定义结构体变量p2（全局变量）

//初始化：定义变量的同时赋初值。
struct Point p3 = { x, y };  //（全局变量）
struct Stu        //类型声明
{
	char name[15];//名字
	int age;      //年龄
};
struct Stu s = { "zhangsan", 20 };//初始化（全局变量）
struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化（全局变量）,含别的类型的结构体时初始化就在中间加一个大括号初始化嵌套的别的结构体
struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化（全局变量）

int main()
{
    struct Node n3 = {30, {6,7}, NULL};//结构体嵌套初始化（局部变量）
}

结构体内存对齐：

内存对齐是一个存储数据的规则，可以依此来计算结构体的大小

我们先来猜一下两个结构体的大小是多少：

struct node1
{
	char a;
	int i;
	char b;
};

struct node2
{
	int i;
	char a;
	char b;
};
int main()
{
	printf("%d\n%d\n", sizeof(struct node1), sizeof(struct node2));
	return 0;
}

虽然两个结构体的成员是一样的，但是结构体的大小确实不一样的，这就要考虑内存对齐了。

每个成员都要在该成员对齐数的整数倍的偏移量处开始存放！

结构体内存对齐的规则：

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

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

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

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

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

接下来还是参照上面的两个结构体来说明：

从0偏移量开始，

a为char类型占一个字节，默认对齐数位8，较小值为1，所以对齐数为1，从0偏移量的地方开始存放；

i为int类型，占四个字节，默认对齐数为8，较小值为4，所以对齐数为4，要放在偏移量为4的倍数的地方，从而就跳过了三个字节的空间；

b与a相同，如上图所示，直接放到8偏移量的位置。

存放完所有数据后，共占用的9个字节，该结构体最大的成员变量对齐数为4，而9并不是4的倍数，所以要多浪费3个字节，最终该结构体的大小就为12.

与上一个结构体成员一样，只不过成员的顺序不同，结果也不同；

这里也就不赘述了，规则都是一样的。

为什么存在内存对齐？

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

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

2. 性能原因：

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

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

小tips:

在声明结构体时，将相同类型的数据放在一起，可以节省空间！

修改默认对齐数：

使用预指令#pragma来改变默认对齐数；

#include <stdio.h>
#pragma pack(2)//设置默认对齐数为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()//取消设置的默认对齐数，还原为默认
int main()
{
    //输出的结果是什么？
    printf("%d\n", sizeof(struct S1));//结果为8
    printf("%d\n", sizeof(struct S2));//结果为6
    return 0;
}

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

#pragma pack(); //恢复默认对齐数

结构体传参：

结构体传参可以传结构体，也可以传结构体地址；

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;
}