自定义类型——结构体-CSDN博客

本文链接：https://blog.csdn.net/qq_75195919/article/details/134171642

结构是一些值的集合，这些值称为成员变量。结构体的每个成员可以是不同类型。（区别于数组）

结构体类型的声明：

struct tag[结构体标签]{

member_list[成员列表]

}variable-list;[变量列表]【可以不写】;

结构体类型定义：学生

struct Stc {定义类型（例 int char fioat）
char name;
int age;

}s1,s2；(定义类型的同时，声明变量）【全局变量】

int main()

{

struct Stu s3;局部变量

return o

}

特殊声明；匿名结构体

struct {

char name[20];

int age;

}s1;

匿名结构体只能用一次，在声明结构的时候，可以不完全声明。

特点：struct {

char name;

int age;

}x;

struct {

char name;

int age;

}a[20],*p;

p=&x;

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

结构体的自引用(类似函数的自我调用）：

数据结构——数据在内存中的存储结构

顺序表：

链表：

struct Node{

        int date;

        struct Node* next;

}

注意：typedef struct{

int date;

node* next;

}Node;

应该先有该类型的数据，才能自引用。就像先有鸡还是先有蛋的问题。

解决方案：

typedef(重命名） struct{

int date;

node* next;

}Node; struct Node n1=Node n2;

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

struct Point
{
	int x;
	int y;
}p1 = { 2,3 };//p1-结构体变量
struct score {
	int n;
	char ch;
};

struct Stu {
	char name[20];
	int age;
	struct score s;
};
int main() {
	struct Point p2 = { 3,4 };
	struct Stu s1 = { "张三",20,{100,'w'} };
//结构体是可以嵌套的
	printf("%s %d %d %c\n", s1.name, s1.age, s1.s);
	return 0;
}

struct就像先跟你表示一下我要用场地（啥都还没做），还没用，等到负责人（声明变量）来的时候，我划用了一块地（在内存里开辟了一块空间），告诉他们干啥（赋值）。

结构体内存对齐：

规则：

struct s1
{
	char c1;
	int i;
	char c2;
};
//空间大小12
struct s2
{
	char c1;
	char c2;
	int i;
};
//空间大小8
struct s3
{
	double d;
	char c;
	int i;
};
//空间大小16
struct s4
{
	char c1;
	struct s3 x;
	double d;
};
//空间大小32
int main() {
	printf("%d\n", sizeof(struct s1));
	//offsetof-可以返回一个结构体成员在类型创建中的偏移量
	printf("%d", offsetof(struct s1, c1));
	printf("%d", offsetof(struct s1, i));
	printf("%d", offsetof(struct s1, c2));
	return 0;
}

结构体的自引用在内存中的对齐：

为什么存在内存对齐：

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

2.性能原因：数据结构（尤其是柞）应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而未对齐的内存访问仅需要一次访问。

总体来说：

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

所以在设计结构体的时候，让占空间小的成员尽量集中在一起。可以节省空间。

修改默认对齐数：#pragma

使用方法：

#pragma once
头文件中使用，功能是：防止文件被多次应用
#pragma pack(4)
struct s
{
	int i;
	double d;
};
不想对齐内存
#pragma pack(1)
struct s1
{
	char c1;
	int i;
	char c2;
};
int main() {
	return 0;
}

机器32位和64位——字长——机器读写的速度

结构体传参：

struct s
{
	int data[1000];
	int num;
};
//结构体传参
void print1(struct s xx){
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", xx.data[i]);
	}
	printf("%d\n", xx.num);
}
//结构地址传参
void print2(const struct s* px) {//const是限制*px的，可以保护传输的地址
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", px->data[i]);
	}
	printf("%d\n", px->num);

}
int main() {
	struct s x = { {1,2,3},100 };
	print1(x);//传值调用
	print2(&x);//传址调用

	return 0;

}

以上的print1和print2函数首选print2函数。

原因：函数传参的时候，参数是需要压寨，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压寨的系统开销比较大，所以会导致性能的下降。

所以结构体传参的时候，要传结构体的地址。

位段：

什么是位段？——>当我们有一些成员范围是非常有限的情况下，我们所需要的内存空间也可以在一定程度大幅度减少。所以位段是可以节省空间的。

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

1.位段的成员必须是int、unsing int 或signed int。

2.位段的成员名后边有一个冒号和数字。

位----->比特位。

比如：

struct A {
	int _a : 2;//分配给_a 2个比特位。 
	int _b : 5;//_b只占5个比特位。
	int _c : 10;
	int _d : 30;
};
//47比特
//6byte*8bit-48bit
//8byte-64bit
int mian()
{
	printf("%d\n", sizeof(struct A));
	return 0;
}

是在一定程度上节省空间，并不是完全节省。

位段的内存分配：

struct A {
	//4byte-32bit
	int _a : 2;//分配给_a 2个比特位。 
	int _b : 5;//_b只占5个比特位。
	int _c : 10;
	//剩15
	int _d : 30;
	//不够，又开辟了4个字节
	//一次又开辟4个字节
};
//47比特
//6byte*8-48bit
//8byte-64bit
int mian()
{
	printf("%d\n", sizeof(struct A));
	return 0;
}

例子：

struct s {
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;//冒号后面的数字不能超过类型。
};
int main() {
	struct s S = { 0 };
	printf("%d\n", sizeof(struct s));
	S.a = 10;
	S.b = 12;
	S.c = 3;
	S.d = 4;
}

猜测内存：