结构体超详解

[1. 结构体的声明与创建](#1. 结构体的声明与创建)

[1.1 结构体类型的定义声明（类型）](#1.1 结构体类型的定义声明（类型）)

[1.2 结构体变量的创建和初始化（变量）](#1.2 结构体变量的创建和初始化（变量）)

[1.3 结构体变量的特殊声明（类型和变量）](#1.3 结构体变量的特殊声明（类型和变量）)

[1.3.1 定义时创建变量](#1.3.1 定义时创建变量)

[1.3.2 结构体的不完全声明（匿名声明）](#1.3.2 结构体的不完全声明（匿名声明）)

[1.4 结构体的自引用](#1.4 结构体的自引用)

[1.5 结构体的重定义【typedef】](#1.5 结构体的重定义【typedef】)

[1.5.1 普通结构体的两种重定义方式](#1.5.1 普通结构体的两种重定义方式)

[1.5.2 匿名结构体与重定义](#1.5.2 匿名结构体与重定义)

[1.6 前置声明](#1.6 前置声明)

[2. 结构体的内存对齐](#2. 结构体的内存对齐)

[2.1 对齐规则](#2.1 对齐规则)

[2.2 内存对齐的原因](#2.2 内存对齐的原因)

[2.3 修改默认对齐数](#2.3 修改默认对齐数)

[3. 结构体中的位段](#3. 结构体中的位段)

[3.1 位段是什么](#3.1 位段是什么)

[3.2 位段的内存分配](#3.2 位段的内存分配)

[3.3 位段的应用与跨平台问题](#3.3 位段的应用与跨平台问题)

[3.4 位段成员的赋值方式](#3.4 位段成员的赋值方式)

[4. 结构体的函数传参方式](#4. 结构体的函数传参方式)

1. 结构体的声明与创建

结构体（Struct）是C语言中一种用户自定义的数据类型，它允许将不同类型的数据项组合成一个单一的实体。

结构体可以包含多个成员【结构是⼀些值的集合，这些值称为成员变量】，每个成员可以是基本数据类型（如int、float、char等），也可以是其他结构体类型。

1.1 结构体类型的定义声明（类型）

在C语言中，需要使用**关键字struct**来定义一个结构体类型。

结构体的定义声明：

struct tag //❶整个"struct tag"是结构体的名字

{

member-list; //❷大括号{}内部是成员表，里面定义了一系列的成员变量

} ; //❸最后的分号;不能丢

例如描述⼀个学⽣：

cpp 复制代码

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

1.2 结构体变量的创建和初始化（变量）

有了结构体的定义，我们就可以开始创建结构体变量了

struct tag

{

member-list;

} ;

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

struct tag 变量名 = { 成员赋值 }；

我们继续用学生来具体举例：

cpp 复制代码

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
};
int main()
{
	//按照结构体成员的顺序初始化
	struct Stu s = { "张三", 20, "男", "20230818001" };
	printf("name: %s\n", s.name);
	printf("age : %d\n", s.age);
	printf("sex : %s\n", s.sex);
	printf("id : %s\n", s.id);

	//按照指定的顺序初始化
	struct Stu s2 = { .age = 18, .name = "lisi", .id = "20230818002", .sex = "⼥" };
	printf("name: %s\n", s2.name);
	printf("age : %d\n", s2.age);
	printf("sex : %s\n", s2.sex);
	printf("id : %s\n", s2.id);
	return 0;
}

指定成员初始化 时要在成员名前加上 结构体成员直接操作符( . ) ，如只给上面的".tag = 18"；如果不指定成员，则按默认顺序赋值。

与数组初始化赋值类似：

大括号{}内如果是不完全初始化 ，则其他成员均以0初始化赋值。
如果是结构体变量创建完后才赋值 ，则不能再用大括号{}来赋值，要用**" 结构体变量名.成员名 = 数值 " 或 " 结构体指针名->成员名 = 数值 "** 的方式赋值（如果该成员是字符串，不能用赋值符=来赋值，要用strcpy的方式赋值）。

比如：

cpp 复制代码

struct Stu
{
	char name[20];//名字
	int age;//年龄
};
int main()
{
	struct Stu s = { .age=20 };
	strcpy(s.name, "小明");
	printf("%s %d\n", s.name, s.age);
	return 0;
}

输出：

因为name是数组名，数组名本身就是数组首元素的地址，所以不用写成strcpy ( &(s.name), "小明" );

1.3 结构体变量的特殊声明（类型和变量）

1.3.1 定义时创建变量

可以在结构体定义的同时，顺便把结构体的变量创建出来。

一般结构体的定义写在main函数的外面，此时的变量是全局变量：

struct tag

{

member-list;

}变量名 ;

注意：此时结构体变量已经被创建出来了，不能再用大括号{}的方式进行初始化了。

代码举例：

cpp 复制代码

struct Stu
{
	char name[20];//名字
	int age;//年龄
}stu1;

int main()
{
	strcpy(stu1.name, "小军");
	stu1.age = 17;
	printf("%s %d\n", stu1.name, stu1.age);
	return 0;
}

1.3.2 结构体的不完全声明（匿名声明）

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

//匿名结构体类型，如：

struct

{

int a;

char b;

float c;

}x，arr[6]，*p;

注意：匿名声明时，如果没有对结构体类型重命名的话，基本上只能使用一次。如果没有重定义，++则在匿名声明的同时就要把变量创建出来。++

问题代码：

cpp 复制代码

struct
{
	char c;
}a;

struct
{
	char c;
}*p;

int main()
{
	p = &a;
	return 0;
}

那么问题来了，语句"p = &a;"合法吗？

我们运行一下看看：

可以看到，虽然编译是通过了，但是这样操作并不合法！！！

1.4 结构体的自引用

在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？

比如写成这样？：

cpp 复制代码

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

上述代码正确吗？如果正确，那 sizeof(struct Node) 是多少？

仔细分析，其实是不行的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的大小就会无穷大，是不合理的。

正确的⾃引用方式：

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

(指针的大小是固定的，要么4要么8，所以这样写没有问题)

1.5 结构体的重定义【typedef】

1.5.1 普通结构体的两种重定义方式

结构体有2种重定义的方式，可分为定义声明时的重定义和定义声明后的重定义。

（建议：重定义的结构体名字最好是首字母大写）

定义声明时的重定义：

typedef struct tag

{

member-list;

}Tag; //新的结构体名

注意： 在重定义时，大括号后面的标识符不再是变量名，而是新的结构体名称。 比如这里的结构体名字由" struct tag "重命名为" Tag "。
定义声明后的重定义：

struct tag

{

member-list;

};

typedef struct tag Tag;

1.5.2 匿名结构体与重定义

由于匿名结构体的特殊性，在声明定义时就要进行重定义：

typedef struct

{

member-list;

}Tag; //新的结构体名

tips：匿名结构体重命名后就可以多次使用了，而且创建时还可以使用大括号{}来给成员变量初始化。

比如：

cpp 复制代码

typedef struct 
{
	int age;
	char name[20];
}Stu;

int main()
{
	Stu s1 = { 17,"小军" };
	Stu s2 = { 18,"小名" };
	printf("%s %d\n", s1.name, s1.age);
	printf("%s %d\n", s2.name, s2.age);
	return 0;
}

在结构体⾃引⽤使⽤的过程中，夹杂了 typedef 对匿名结构体类型重命名，也容易产生引用问题，看看下面的代码，可行吗？

cpp 复制代码

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

答案是不行的：

因为Node是对前⾯的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使用Node类型来创建成员变量，这是不行的。

注意：匿名结构体的重定义本质上也是特殊的定义声明时的重定义，所以在定义声明的重定义时，也不能提前使用新的结构体名进行自引用。

1.6 前置声明

一般来说，结构体的定义声明是放在头文件，但如果2个不同头文件的结构体在定义时需要包含对方，那么就需要使用前置声明。（否则会报错，比如xx表示符未定义）

结构体的前置声明允许程序员在使用结构体之前先声明该结构体的存在，而不需要立即提供完整的定义。前置声明需要写出被引用的结构体的原始名称。

例如：

cpp 复制代码

头文件1
typedef struct tag1
{
    int data;
}Tag1;

cpp 复制代码


头文件2:该文件2的结构体定义时需要引用文件1的结构体
struct tag1；//struct tag1的前置声明

typedef struct tag2
{
    char id[20];
    struct tag1 s;
}Tag2；

这样struct tag2创建时就不会报错了。

2. 结构体的内存对齐

我们已经掌握了结构体的基本使⽤了。现在我们深⼊讨论⼀个问题：计算结构体的⼤⼩。这也是⼀个特别热⻔的考点：结构体内存对⻬。

2.1 对齐规则

在讲解规则之前，我们先认识几个名词：

①默认对齐数： 默认对齐数是编译器用于内存对齐的基本单位大小，通常取决于平台或编译器的设置。

VS 的默认对齐数是8个字节。(x86和x64都相等)

Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

②(成员)对齐数： 它是默认对⻬数与该成员变量⼤⼩的较小值。

即 " 对齐数 =min{ 默认对齐数，成员变量的数据类型大小 } "

③最大对齐数： 结构体中每个成员变量都有⼀个对⻬数，它是所有对齐数 中最大的。

即" 最大对齐数 = max{对齐数1，对齐数2，...... ，对齐数k } "

在认识了这几种对齐数后，我们来看看内存对齐的规则：

结构体的内存对齐规则：

结构体的第一个成员对⻬到和结构体变量起始位置偏移量(序数)为0的地址处。

其他成员变量 要对齐到偏移量(序数)为对应(成员)对齐数的整数倍的地址处 。【每个成员的对齐数由自身数据类型 与 默认对齐数比较得来】

结构体总大小为最大对齐数的整数倍字节数(个数)。

特殊情况：如果嵌套了别的结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处(序数) ；结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍(个数)。

我用2个例子给大家讲解一下：（这里假设是VS环境）

例1：

cpp 复制代码

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

① 首先我们计算每个成员的对齐数：

double d的对齐数 = min{8，8} = 8、char c的对齐数 = min{1,8} = 1、int i的对齐数 = min{4,8} = 4。

②有了每个成员的对齐数，我们就可以得到最大对齐数：

s1的最大对齐数 = max{ d，c，i } = max{8,1,4} = 8。

③我们按照对齐规则填入：（这里画图演示）

④计算结构体S1的总大小：

大小为最大对齐数的整数倍，这里需要2倍，(即8*2等于16个字节) 就能装满所有成员。

【注意：虽然序号0~15共16个数字，但如果没有成员int i，结构体S1的大小仍然按倍数计算，即16个字节】

例2：嵌套结构体S2

cpp 复制代码

struct S1
{
	double d;
	char c;
	short i;
};
struct S2
{
	char c1;
	struct S1 s1;
	double d;
};

① 我们先计算出没有嵌套的结构体S1的最大对齐数和大小：

由例1可知，S1的最大对齐数是8，大小是16。

② 再计算嵌套结构体中的每个成员的对齐数：

在S2中，char c1的对齐数 = min{1,8} = 1、double d的对齐数 = min{8,8} = 8。

③ 计算嵌套结构体S1的最大对齐数：

S1的最大对齐数 = max{c1 ,s1 ,d } = max{1,8,8} = 8。【注意：S1的最大对齐数不是16】

④ 按照对齐规则填入：

⑤ 计算嵌套结构体S1的总大小：

总大小为S1最大对齐数的整数倍，这里需要4倍，(即8*4=32个字节)就能装满所有成员。

2.2 内存对齐的原因

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

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

2.性能原因：

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。

**总体来说：**结构体的内存对⻬是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满⾜对⻬，⼜要节省空间。例如：

cs 复制代码

struct S1
{
  char c1;
  int i;
  char c2;
};
struct S2
{
  char c1;
  char c2;
  int i;
};

S1 和 S2 类型的成员⼀模⼀样，但是 S1 和 S2 所占空间的⼤⼩有了⼀些区别。S1的大小是12个字节，S2的大小是8个字节。

所以我们在创建结构体时，尽量把数据类型相同的成员放在一起。

2.3 修改默认对齐数

#pragma 这个预处理指令，可以++改变编译器的默认对⻬数++。

例如：

#pragma pack(4) //可以把默认对齐数修改为4.

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

cpp 复制代码

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

修改默认对齐数的方式是：

在**语句"#pragma pack(k)"到语句"#pragma pack()"**之间定义声明的结构体，它们的默认对齐数都是k；

在这两条语句之外定义的结构体，它们的默认对齐数仍然为8(VS环境下)。
结构体在对⻬⽅式不合适的时候，我们可以⾃⼰更改默认对⻬数。

但要注意，修改的对齐数最好是2的倍数，不要出现3,5这种奇数数字。

3. 结构体中的位段

3.1 位段是什么

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

位段的成员必须是 int、char、unsigned int 或signed char，在C99中位段成员的类型也可以选择其他类型。

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

冒号后面的数字，就是该成员的大小，单位是bit(二进制位)。

比如：

cpp 复制代码

struct A
{
	int a : 2;
	int b : 5;
	int c : 10;
	int d : 30;
};

A就是⼀个位段类型。

但为了提高代码的可读性和可维护性，通常在位段成员起名时，首字符用" _ "。

比如：

cpp 复制代码

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

3.2 位段的内存分配

VS 2022上位段开辟空间的方式：(这里以char为例)

① 首先会开辟1个字节大小(char型大小)的空间。

② 每个成员从右往左进行填入。【其他编译器可能会从左往右】

③ 剩余的bit位不够下一个成员使用时，浪费掉这些剩余的bit位，并开辟新的char型大小空间来存放下一个成员。

④关于位段成员读入数据，如果该二进制数值超出位段的大小，则只存入较小位二进制数。

注意：对于char型的位段成员，最大数目不能超过8。

举例：

cpp 复制代码

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};

int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

我们把数据从十进制转化为二进制：

10 == 1010、12 == 1100、3 == 11 、4 == 100

画出内存的分配图：

并填入数据：(位段不够大的只填入较小位数)

3.3 位段的应用与跨平台问题

位段的应用

下图是⽹络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要⼏个bit位就能描述，这⾥使⽤位段，能够实现想要的效果，也节省了空间，这样⽹络传输的数据报⼤⼩也会较⼩⼀些，对⽹络的畅通是有帮助的。

位段的跨平台问题

int 位段被当成有符号数还是⽆符号数是不确定的。

位段中最大位的数目不能确定。（16位机器最⼤16，32位机器最⼤32；比如写成27，在16位机器会出问题)

位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。（不同编译器不一样）

当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结： 跟结构相⽐，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。平时在编程时不建议使用位段。

3.4 位段成员的赋值方式

对于位段成员的赋值，我们要明确几点：

位段的⼏个成员共用同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。

内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。

所以不能对位段的成员使用&操作符 ，这样就不能使⽤scanf直接给位段的成员输⼊值，只能是先输入放在⼀个变量中，然后赋值给位段的成员。

比如：

cpp 复制代码

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;
	printf("%d\n", sa._b);
	return 0;
}

如果用错误的方式赋值，就会报这样的错误：

用第二种方式就能成功赋值：

4. 结构体的函数传参方式

cpp 复制代码

struct S
{
	int num;
};
struct S s = { 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函数。

原因：

函数传参的时候，形参变量是需要压栈的，会有时间和空间上的系统开销。如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销比较⼤，所以会导致性能的下降。

传地址的话，操作的就是原来的结构体变量，而且不会拷贝出一个新的结构体来消耗内存空间。
结论： 结构体传参的时候，要传结构体的地址。

本期分享完毕，感谢大家的支持Thanks♪(･ω･)ﾉ

结构体 超详解

1. 结构体的声明与创建

1.1 结构体类型的定义声明（类型）

1.2 结构体变量的创建和初始化（变量）

1.3 结构体变量的特殊声明（类型和变量）

1.3.1 定义时创建变量

1.3.2 结构体的不完全声明（匿名声明）

1.4 结构体的自引用

1.5 结构体的重定义【typedef】

1.5.1 普通结构体的两种重定义方式

1.5.2 匿名结构体与重定义

1.6 前置声明

2. 结构体的内存对齐

2.1 对齐规则

2.2 内存对齐的原因

2.3 修改默认对齐数

3. 结构体中的位段

3.1 位段是什么

3.2 位段的内存分配

3.3 位段的应用与跨平台问题

3.4 位段成员的赋值方式

4. 结构体的函数传参方式

结构体超详解