自定义类型:结构体, 枚举，联合-CSDN博客

本文链接：https://blog.csdn.net/Suinnn/article/details/129097548

结构体

什么是结构

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

结构体的声明

struct 结构体名称{
	char a;
	int b;	 //a,b,c……皆为结构体成员变量(结构体内容)
	double c;
	…………
}结构体变量;//(分号不能丢),这里的结构体变量是全局变量

正常的声明

struct S
{
	char name[20];
	int age;
}s1;	// 这里的s1是一个全局的结构体变量

int main()
{
	struct S s2;	// 这里的s2是一个局部的结构体变量
}

匿名结构体类型

struct
{
	char a[30];
	double b;
	float c;
}x1;

struct
{
	char a[30];
	double b;
	float c;
}*p;

问题

// 下面的代码合法吗？
p = &x1;

显然在,x86的条件下,编译器报了警告

结构体的自引用

结构体成员变量包含同类型的结构体指针

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

注意下面的代码

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

上面的代码是错误的,因为该代码是先产生一个匿名结构体,该结构体里有一个Node* 的指针,
然后将结构体重命名为Node,
顺序显然不对

解决方案

typedef struct Node
{
	int data;
	struct Node* next;
}Node;
// 先定义一个Node的结构体,里面有两个成员变量,接着将该结构体命名为Node

结构体变量的初始化

struct B
{
	char a;
	short b;
	double c;
};

struct Student
{
	// 成员变量
	struct B sb;
	char name[20];  //名字
	int age;	//年龄
	char id[20]; //学号
};	// s1, s2也是结构体变量,但是是全局变量

int main()
{
	struct Student s = { {'a', 10, 3.14}, "张三", 18, "201233124" };			// s是一个局部的结构体变量
    printf("%c, %hd, %lf, %s, %d, %s\n", s.sb.a, s.sb.b, s.sb.c, s.name, s.age, s.id);
}

结构体的大小:内存对齐问题

#include <stdio.h>
struct S
{
	char a;
	int b;
	char c;
};
int main()
{
	struct S a = { 0 };
	printf("%d\n", sizeof(a));
	return 0;
}		// 上面这段代码的运行结果是12,下面来分析一下

==已知==:
第一个成员在与结构体偏移量为0的地址处
其它成员变量要对齐到对齐数的整数倍地址处
对齐数：在vs中,是与8该成员大小相比的较小值(8即默认对齐数)
结构体总大小为最大对齐数的整数倍
如果嵌套了结构体的情况,嵌套的结构体对齐到自己的== 最大对齐数==的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍

练习1

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

练习2，结构体嵌套问题

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

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

为什么存在内存对齐?

1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因：经过内存对齐后，CPU的内存访问速度大大提升。下文讲述具体原因：

我们可以怎样做？

让占用空间小的成员尽量集中到一起

struct S1
{
    char c1;
    char c2;
    int i;
};  // 大小是8

struct S2
{
    char c1;
    int i;
    char c2;
};  // 大小是12

修改默认对齐数

#pragma pack(num)可以用来指定默认对齐数

#pragma pack(2)
struct S1
{
    char c1;
    char c2;
    int i;
}s1;
#pragma pack()      // 改完再继续将默认对齐数重置
int main()
{
    printf("%u\n", sizeof(s1));
	return 0;
}

所以上面的代码结果为6

[offsetof](offsetof - C++ Reference (cplusplus.com))来计算偏移量包含在stddef.h中

#include <stddef.h>
#include <stdio.h>
struct S2
{
    char c1;
    int i;
    char c2;
}s2;
int main()
{
    printf("%d\n", (int)offsetof(struct S2, c1));
    printf("%d\n", (int)offsetof(struct S2, i));
    printf("%d\n", (int)offsetof(struct S2, c2));
	return 0;
}

位段

位段即一个由位组成的段, 并可为它赋以一个名字。

有以下规定

位段的成员必须是整形家族,即int,unsigned int, char
位段的成员名后面有一个冒号和一个数字

struct A
{
	int a : 2;   // 即结构体成员a占2个比特
	int b : 5;   // 即结构体成员b占5个比特,下面的同理
	int c : 10;
	int d : 30;
}a1;

int main()
{
	printf("%d\n", sizeof(a1));	// 该结构体只有8个字节
	return 0;
}

枚举

即一一列举一系列的int类型,枚举类型列举的成员都是int类型的常量

//定义一个枚举类型
enum Color
{
	RED,
	GREEN,
	BLUE
};

int main()
{
	enum Color c = RED;
	printf("%d\n", c);	// 结果是0
	return 0;
}

继续看

enum Color
{
	RED,
	GREEN,
	BLUE
};

int main()
{
	printf("%d\n", RED);
	printf("%d\n", GREEN);
	printf("%d\n", BLUE);
	return 0;
}// 结果是0 1 2

enum Color
{
	RED = 4,
	GREEN = 7,
	BLUE
};

int main()
{
	printf("%d\n", RED);
	printf("%d\n", GREEN);
	printf("%d\n", BLUE);
	return 0;
} //结果是4 7 8

所以我们知道,如果不初始化枚举类型变量,第一项默认为0,下一项比上一项大1

联合体(共用体)

定义共用体

union [union tag]
{
   member definition;
   member definition;
   ...
   member definition;
} [one or more union variables];

所占的空间大小

联合体的大小至少是最大成员的大小
如果不是最大对齐数的整数倍,则要对齐到最大对齐数的整数倍

#include <stdio.h>
union Un
{
	char c;
	int i;
}u;

int main()
{
	printf("%d\n", sizeof(u));   // 大小为4
	return 0;
}

union Un
{
	char c[5];
	int i;
}u;
int main()
{
    // 下面这条语句的结果是8
	printf("%d\n", sizeof(u));// 因为虽然5开辟了5个字节的空间,但不是最大对齐数(4)的整数倍,所以要对齐到4的倍数上
	return 0;
}

特点,共用同一块内存空间

union Un
{
	char c;
	int i;
	char str[20];
}u;

int main()
{
	u.c = 'a';	// 赋值
	u.i = 2;
	strcpy(u.str, "Str copy");
	printf("%p\n", &(u.c));
	printf("%p\n", &(u.i));
	printf("%p\n", &(u.str));
	return 0;
}

所以如果直接打印的话,就会出现数据混乱的现象

如果真的想打印的话,就一次只使用一个变量

用枚举实现大小端的判断

int System_Check()
{
	union Un 
	{
		int a;
		char c;
	}u;
	u.a = 1;
	return u.c;		// 小端返回1
}