C语言结构体和位段

一.结构体类型的声明

1.1 结构体的概念

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

1.2结构的声明

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

假如是一个大学生，可以用以下带代码描述

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;

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

1.4结构体的自引用

在结构中包含?个类型为该结构本?的成员是可以的
比如：定义一个链表结点

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

1.5可以使用typedef重命名

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

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

2.1结构体变量的初始化使用{}

struct Point
{
 int x;
 int y;
}s1; //声明类型的同时定义变量s1
struct Point s2; //定义结构体变量s2

2.2初始化：定义变量的同时赋初值。

struct Point p3 = {x, y};

2.3结构体嵌套及初始化

struct Node
{
 int data;
 struct Point p;
 struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};

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

三.结构体成员访问操作符

结构成员访问操作符有两个?个是 . ，?个是 -> .

有以下两种方式：
结构体变量.成员变量名
结构体指针—>成员变量名

struct student
{
	char name[10];
	int age;
};

int main()
{
	struct student stu = { "zhangsan",10 };
	struct student* pstu = &stu;
	printf("%d", (*(pstu)).age);
	printf("%d",pstu->age);
	return 0;
}

四.结构体内存对齐

4.1对齐规则

1. 结构体的第一个成员相对于结构体变量起始位置偏移量为0的地址处
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍地址
3. 结构体总大小为 最大对其数（结构体中每个成员变量都有一个对齐数，所有对齐数中最大的）的整数倍
4. 如果要是嵌套了结构体的情况，嵌套的结构体成员对齐到自己成员中的最大对其数的整数倍，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍

以下有几个练习：

练习1

计算下列结构体大小：

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

结果是

下面画图来解释以下原因：

练习2

计算下列结构体大小：

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

结果是

下面画图来解释以下原因：

因为对齐数要是最大对齐数的整数倍，所以就是12

练习3

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

运行结果是

下面画图来解释以下原因：

练习4（嵌套结构体的对齐数）

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

struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{

	printf("%d\n", sizeof(struct S4));
	return 0;
}

运行结果

下面画图来解释以下原因：

4.2修改默认对齐数

可以使用#pragam pack(1),设置默认对齐数为1
pragam 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;
}

六.联合体

6.1联合体类型的声明

联合体的特点是所有成员共用同一块内存空间。所以联合体也叫：共用体。
给联合体其中?个成员赋值，其他成员的值也跟着变化。

//联合类型的声明
union Un
{
 char c;
 int i;
};
int main()
{
 //联合变量的定义
 union Un un = {0};
 //计算连个变量的??
 printf("%d\n", sizeof(un));
 return 0;
}

运行结果：

4

6.2联合体的特点

联合的成员是共用同?块内存空间的，这样?个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

代码

#include <stdio.h>
//联合类型的声明
union Un
{
 char c;
 int i;
};
int main()
{
 //联合变量的定义
 union Un un = {0};

 printf("%p\n", &(un.i));
 printf("%p\n", &(un.c));
 printf("%p\n", &un);
 return 0;
}

输出结果：

001AF85C
001AF85C
001AF85C

6.2计算联合体的大小

联合的大小至少是最?成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

代码：

union Un1
{
 char c[5];
 int i;
};
union Un2
{
 short c[7];
 int i;
};
int main()
{
 //下?输出的结果是什么？
 printf("%d\n", sizeof(union Un1));
 printf("%d\n", sizeof(union Un2));
 return 0;
}

运行结果：

下面画图来解释以下原因：

因为Un1的char c[5]需要占用5个字节，5不是4的倍数，所以就是8个字节
Un2的char c[7]要占用14个字节，但是14不是结构第默认对齐数的最小公倍数，所以就是16

6.3用联合体判断大小端字节序

int check_sys()
{
 union
 {
 int i;
 char c;
 }un;
 un.i = 1;
 return un.c;
}

七.枚举类型

7.1枚举类型的声明

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};
enum Sex//性别
{
 MALE,
 FEMALE,
 SECRET
}；
enum Color//颜?
{
 RED,
 GREEN,
 BLUE
};

1. 以上定义的 enum Day ， enum Sex ，enum Color 都是枚举类型。
2. {}中的内容是枚举类型的可能取值，也叫 枚举常量 。
3. 这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。

enum Color//颜?
{
 RED=2,
 GREEN=4,
 BLUE=8
};

7.2枚举的优点

1. 增加代码的可读性和可维护性
2. 和#define定义的标识符?较枚举有类型检查，更加严谨。
3. 便于调试，预处理阶段会删除 #define 定义的符号
4. 使用方便，一次可以定义多个常量
5. 枚举常量是遵循作用域规则的，枚举声明在函数内，只能在函数内使用

7.3 枚举类型的使用

enum Color//颜?
{
 RED=1,
 GREEN=2,
 BLUE=4
};
enum Color clr = GREEN;

在C语言中是可以的，但是在C++是不行的，C++的类型（语法）检查比较严格。

文章到这里结束了！！！如果有错，请立刻指正，谢谢！！！