C语言自定义类型结构体

1.结构体类型的声明

1.1结构体的概念

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

1.2结构的声明

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

1.3特殊的声明

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

//匿名结构体类型
struct
{
 int a;
 char b;
 float c;
}x;
struct
{
 int a;
 char b;
 float c;
}a[20], *p;

p = &x;

• 编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的
• 匿名的结构体类型，如果没有对结构体重命名的话，基本上只能使用一次

1.4结构的自引用

示例1

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

解释:结构体中在包含一个同类型的结构体变量，这样结构体变量的大小会无穷大，是不合理的

//改正
struct Node
{
 int data;
 struct Node* next;
};

示例2

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

解释，Node是对前面的匿名结构体类型的重命名产生的，但是在匿名结构体内部提前使用Node类型创建变量是不行的

//改正
typedef struct Node
{
 int data;
 struct Node* next;
}Node;

2.结构体变量的创建和初始化

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};//结构体嵌套初始化

指示器初始化方式(c99)，这种方式允许不是按照成员顺序初始化

struct Stu
{
 char name[15];
 int age; 
};
struct Stu s = {.age=20, .name="zhangsan"};//初始化

3.结构成员访问操作符

结构成员访问操作符有两个，一个是. ，一个是→

//结构体变量.成员变量名
//结构体指针—>成员变量名
struct S
{
	int data[1000];
	int num;

};
void print1(struct S t)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ",t.data[i]);
	}
	printf("\n");
	printf("%d\n", t.num);
}
void print2(const struct S* ps)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
	printf("%d\n", ps->num);
}
int main()
{
	struct S s = { {1,2,3,4},1000 };
	print1(s);//结构体变量-传值调用

	print2(&s);//结构体变量地址-传址调用
	return 0;
}

4.结构体内存对齐

4.1对齐规则

• 1.结构体的第一个成员对齐到相对结构体变量起始位置偏移量为0的地址处
• 2.其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处
  对齐数＝编译器默认的一个对齐数与该成员变量大小的较小值
  vs默认的值为8
  linux中没有默认对齐数，对齐数就是成员自身的大小
• 3.结构体总大小为最大对齐数(结构体中每个成员变量都有一个队期数，所有对齐数中最大的)的整数倍
• 4.如果嵌套结构体，嵌套的结构体成员对齐到自己的成员变量中最大的对齐数的整数倍处，结构体的整体大小就是所有最大
  对齐数(含嵌套结构体成员的对齐数)的整数倍

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

解释:c1的对齐数为1，对齐位置为偏移量0位置，i对齐数为4，对齐位置为偏移量为4-7位置，c2对齐数为1，对齐位置为偏移量为8位置，由于成员变量中最大对齐数为4，显然9不是4的整数倍，所以结构体大小为12字节

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

解释:c1的对齐数为1，对齐位置为偏移量0位置，c2对齐数为1，对齐位置为偏移量1位置，i对齐数为4，对齐位置为偏移量4-7，由于成员变量最大对齐数为4，8是4的整数倍，所以结构体大小为8字节

//练习3
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));

解释，d的对齐数为8，对齐位置为偏移量0-7位置，c对齐数为1，对齐位置为偏移量8位置，i对齐数为4，对齐位置是12-15，由于成员变量中最大对齐数为8，所以结构体大小为16字节

struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%d\n", sizeof(struct S4));

解释:c1对齐数为1，对齐位置为偏移量0位置，结构体成员s3, 其中d的对齐数为8，对齐位置为偏移量0-7位置，c对齐数为1，对齐位置为偏移量8位置，i对齐数为4，对齐位置是偏移量12-15位置，结构体s3的大小为16，整体对齐位置为偏移量1-16位置,d对齐数为8，对齐位置为偏移量24-31位置，由于最大对齐数为8，所以结构体大小为32字节

4.2为什么存在内存对齐

1.平台原因(移植原因)
不是所有的硬件平台都能访问任意地址上的任意数据的，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常
2.性能原因
数据结构(尤其是栈)应该尽可能地在自然边界上对齐，原因在于，为了访问未对齐的内存，处理器需要做两次内存访问，而对齐的内存访问仅需要一次访问，假设一个处理器总是从内存中取8个字节，则地址必须是8的倍数，如果保证将所有的double 类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作来读或者写值了，否则，可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中
结论:结构体的内存对齐是拿空间换取时间的做法

设计结构体时，如果既满足对齐，又节省空间，可以让占用空间小的成员尽量集中一起

//例如：
struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
 }

s1和s2类型的成员一模一样，但所占空间大小不同

4.3修改默认对齐数

#pragma这个预处理指令，可以修改编译器的默认对齐数

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

5.结构体传参

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函数优于print1
原因

• 函数传参的时候，参数需要压栈，会有时间和空间上的系统开销，如果传递一个结构体对象时，结构体过大，参数压栈的系统开销比较大，导致性能下降
• 结论:函数传参的时候，要传结构体地址

6. 结构体实现位段

6.1什么是位段

位段的声明和结构是类似的，但也不全相同

• 1.位段的成员必须是int, unsigned int 或signed int, 在c99中位段成员的类型也可以选择其他类型
• 2.位段的成员名后面有一个冒号和数字

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

解释：a占用2位的整数，b占用5位整数，c占用10位整数，d占用30位整数，一共47位，int类型是32位，所以占用8个字节大小

6.2位段的内存分配

1.位段的成员可以是int unsigned int signed int或者char等类型
2. 位段的空间是按照需要以4个字节(int)或者1个字节(char)的方式开辟的
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植程序应该避免使用位段

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;

6.3位段的跨平台问题

1.int位段被当成有符号数还是无符号数是不确定的
2.位段中最大位的数目不能确定(16位机器最大16，32位机器最大32写成27在16位机器会出问题)
3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义
4.当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，是不确定的
结论，跟结构相比，位段可以达到同样的效果，并且可以很好的节省空间，但有跨平台的问题存在

6.4位段的应用

下图是网络协议中，ip数据报的格式，可以看到其中很多属性只需要几个bit位就能描述，这里使用位段，能够实现想要的效果，也节省了空间，这样网络传输的数据报大小也会较小一些，对网络的通畅是有帮助的

6.5位段使用的注意事项

位段的几个成员共有同一个字节，这样有些成员的起始位置，那么这些位置处是没有地址的。内存中每个字节分配一个地址，一个字节内部的bit为是没有地址的，所以不能对位段成员使用&操作符，这样就不能使用scanf直接给位段的成员输入值，只能是先输入放在一个变量中，然后复制给位段成员

struct A
{
 int _a : 2;
 int _b : 5;
 int _c : 10;
 int _d : 30;
};
int main()
{
 struct A sa = {0};
 scanf("%d", &sa._b);//这是错误的
 
 //正确的⽰范
 int b = 0;
 scanf("%d", &b);
 sa._b = b;
 return 0;
}