设计完美数据蓝图:玩转自定义结构体

夜雨声烦1413

发布于 2026-01-12 15:45:39

660

hello,uu们,今天呢我们来详细讲解结构体,好啦,废话不多讲,开干

1:结构体类型的声明

1.1:结构体的概念

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

1.2:结构体的声明

我们通过使用结构体来描述一个商品或者学生信息.

1.2.1:代码1

struct Commdity
{
	//商品的价格
	int Price;
	//商品的属性
	char Character[20];
};//分号不能省略

1.2.2:代码2

struct Student
{
	//名字
	char Name[20];
	//年龄
	int Age;
	//性别
	char Sex[5];
	//学号
	char Id[20];
};

1.3:特殊的声明(匿名结构体类型)

在声明结构体的时候,可以对结构体进行不完全的声明.

1.3.1:代码1

struct 
{
	char name[20];
	char author[12];
	double price;
}b1,b2;

struct
{
	char name[20];
	char author[12];
	double price;
}*p;

上述代码的两个结构体在声明的时候省略掉了结构体标签. 那么问题来了

//在代码1的基础上,下面的代码合法吗？
p = &b1;

1.3.2:代码2

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct 
{
	char name[20];
	char author[12];
	double price;
}b1,b2;

struct
{
	char name[20];
	char author[12];
	double price;
}*p;

int main()
{

	p = &b1;
	return 0;
}

我们可以清晰地看到:

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

1.4:结构体的自引用

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

例如,定义一个链表的节点

1.4.1:代码1(错误的自引用方式)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct NewNode
{
	int _value;
	struct NewNode next;
};

上面的代码正确吗,如果正确的话,那么sizeof(struct NewNode)是多少呢仔细分析滴话,其实是不行的呢, 因为一个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的大小就会无穷的大，是不合理的.

1.4.2:代码2(正确的自引用方式)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct NewNode
{
	//数值域
	int _value;
	//指针域
	struct NewNode * next;
};

在结构体自引用使用的过程中,夹杂了typedef对匿名结构体类型重命名,也容易引入问题,我们来看看下面滴这段代码是否可行.

1.4.3:代码3

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct
{
	//数值域
	int _value;
	//指针域
	NewNode * next;
}NewNode;

答案是不行的,因为NewNode是对前面的匿名结构体类型的重命名产生的,但是在匿名结构体内部提前使用NewNode类型来创建成员变量,这是不行滴. 那么该如何解决呢

1.4.4:代码4(定义结构体不要使用匿名结构体了)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct NewNode
{
	//数值域
	int _value;
	//指针域
	struct NewNode * next;
}NewNode;

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

有了结构体类型,那么该如何定义变量,其实很简单滴,结构体变量的初始化使用{}

2.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct Point
{
	int _x;
	int _y;
}p1;//声明类型的同时定义结构体变量p1

//p1,p2为全局变量
struct Point p2;

//初始化:定义变量的同时赋初值.
struct Point p3 = { 3,2 };

struct Student
{
	char name[15];
	int  _age;
};

int main()
{
	int a = 5;
	int b = 6;

	struct Point p3 = { a,b };
	struct Student s1 = { "波比",18 };
	struct Student s2 = { ._age=18,.name = "超人强"};

	printf("%s %d\n", s1.name, s1._age);
	printf("%s %d\n", s2.name, s2._age);
	
	return 0;
}

2.2:代码2(结构体嵌套初始化)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct Point
{
	int _x;
	int _y;
};

struct NewNode
{
	int _value;
	struct Point p;
	struct Node* next;
}n1 = { 10,{4,5},NULL };//n1为全局变量
//结构体嵌套初始化
struct NewNode n2 = { 20,{5,6},NULL };

int main()
{
	return 0;
}

3:结构体成员访问操作符

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

3.1:访问格式

结构体变量 . 成员变量名结构体指针 —> 成员变量名

3.2:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

struct Student
{
	//名字
	char name[15];
	//年龄
	int _age;
};

void Print(struct Student s)
{
	printf("%s %d\n", s.name, s._age);
}

void Set_Student(struct Student * ps)
{
	strcpy(ps->name, "张三");
	ps->_age = 18;
}

int main()
{
	struct Student s = { "超人强",22 };
	Print(s);
	Set_Student(&s);
	Print(s);
	return 0;
}

4.结构体内存对齐

我们已经掌握了结构体的基本使用了,那么接下来,我们深入探讨一个问题:计算结构体的大小,同样这也是在面试的时候一个重要滴的考点:结构体内存对齐.

4.1:对齐规则

要计算结构体的大小,那么首先得了解结构体的内存对齐的规则

对齐规则:

第一个成员变量在结构体变量偏移量为0的地址处.
其他成员变量要对齐到对齐数的整数倍的地址处.

对齐数 = 编译器默认的一个对齐数与该成员变量大小的较小值. 1:Vistual Studio中的默认的对齐数的值为8 2:Linux(gcc的编译器)中没有默认对齐数,对齐数就是成员自身的大小.

结构体的总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍.
如果嵌套了结构体了的话,嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体中成员的对齐数)的整数倍.

4.1.1:代码1(使用offsetof计算结构体成员相较于起始位置的偏移量)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//使用offsetof需要包含的头文件
#include <stddef.h>

struct s1
{
	char c1;
	int _value;
	char c2;
};

struct s2
{
	char c1;
	char c2;
	int _value;
};

int main()
{
	//offsetof计算结构体成员相较于起始位置的偏移量
	printf("s1->c1的偏移量:>%d\n", offsetof(struct s1, c1));
	printf("s1->_value的偏移量:>%d\n", offsetof(struct s1, _value));
	printf("s1->c2的偏移量\n", offsetof(struct s1, c2));
	
	printf("\n");

	printf("s2->c1的偏移量:>%d\n", offsetof(struct s2, c1));
	printf("s2->_value的偏移量:>%d\n", offsetof(struct s2, _value));
	printf("s2->c2的偏移量\n", offsetof(struct s2, c2));
	return 0;
}

了解了结构体内存对齐的规则后,接下来我们简单练习几道题目

4.2:练习1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


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

4.3:练习2

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct S2
{
	char c1;
	char c2;
	int i;
};

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

4.4:练习3

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//练习3
struct S3
{
	double d;
	char c;
	int i;
};

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

4.5:练习4(嵌套结构体的计算)

4.6:为什么存在内存对齐

有的uu会比较好奇,为什么计算结构体的大小会存在内存对齐这么一个规则呢？

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

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

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

那么在设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到

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

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct S1
{
	char c1;
	int i;
	char c2;
};

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

S1 和 S2 类型的成员⼀模⼀样，但是 S1 和 S2 所占空间的大小有了一些区别。

4.7:修改默认对齐数

4.7.1:代码1(修改默认对齐数)

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

4.7.2:代码2

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#pragma pack(1)//设置默认对⻬数为1
//取消修改的默认对齐数,还原为默认
#pragma pack()
struct S
{
	char c1;
	int i;
	char c2;
};


int main()
{
	//输出的结果是什么？
	printf("%d\n", sizeof(struct S));
	return 0;
}

结构体在对齐方式不合适的时候，我们可以自己更改默认对齐数。

5:结构体传参

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct S
{
	int arr[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:结构体实现位段

6.1:什么是位段

位段的声明与结构体式类似,但是以下两点不同

位段的成员必须是int、unsigned int 或者signed int,在C99中位段成员的类型也可以选其他类型.
位段的成员名后边有一个冒号和一个数字.

6.1.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


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

int main()
{
	printf("%zd\n", sizeof(struct A));
	return 0;
}

6.2:位段的内存分配

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

我们来看一个例子

6.2.1:代码1

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直接给位段的成员输⼊值，只能是先输入放在⼀个变量中，然后赋值给位段的成员。

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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;
}